

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

# 在 Amazon EMR on EKS 上執行互動式工作負載
<a name="connect-emr-studio"></a>

*互動端點*是一個閘道，它將 Amazon EMR Studio 連接到 Amazon EMR on EKS，以便您可執行互動式工作負載。可以將互動端點與 EMR Studio 搭配使用，在 [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) 和 [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) 等資料存放區中使用資料集來執行互動式分析。

**使用案例**
+ 使用 EMR Studio IDE 體驗建立 ETL 指令碼。IDE 會擷取內部部署資料，並在轉換後將其儲存在 Amazon S3 中，以供後續分析。
+ 使用筆記本探索資料集，並訓練機器學習模型，以偵測資料集中的異常情況。
+ 建立指令碼，為分析應用程式 (例如，商業儀表板) 產生每日報告。

**Topics**
+ [互動端點概觀](how-it-works.md)
+ [在 Amazon EMR on EKS 上建立互動端點的先決條件](prereqs-for-studio.md)
+ [為虛擬叢集建立互動端點](create-managed-endpoint.md)
+ [配置互動端點的設定](managed-endpoint-parameters.md)
+ [監控互動端點](managed-endpoints-customer-metrics.md)
+ [使用自助託管的 Jupyter 筆記本](managed-endpoints-self-hosted.md)
+ [使用 CLI 命令取得互動式端點的相關資訊](other-operations.md)

# 互動端點概觀
<a name="how-it-works"></a>

*互動端點*可讓 Amazon EMR Studio 等互動式用戶端連線到 Amazon EMR on EKS 叢集，以執行互動式工作負載。互動端點由 Jupyter Enterprise Gateway 提供支援，可提供互動式用戶端所需的遠端核心生命週期管理功能。*核心*是特定於語言的程序，可與 Jupyter 型 Amazon EMR Studio 用戶端互動，以執行互動式工作負載。

互動端點支援下列核心：
+ Python 3
+ PySpark on Kubernetes
+ 帶 Scala 的 Apache Spark

**注意**  
Amazon EMR on EKS 定價適用於互動端點和核心。如需詳細資訊，請參閱 [Amazon EMR on EKS 定價頁面](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS)。

EMR Studio 需要以下實體才能與 Amazon EMR on EKS 連接。
+ **Amazon EMR on EKS 虛擬叢集** - *虛擬叢集*是您向其註冊 Amazon EMR 的 Kubernetes 命名空間。Amazon EMR 使用虛擬叢集來執行作業和託管端點。可使用相同實體叢集來支援多個虛擬叢集。不過，每個虛擬叢集都會映射 Amazon EKS 叢集上的一個命名空間。虛擬叢集不會建立任何增加帳單或需要在服務之外進行生命週期管理的作用中資源。
+ **Amazon EMR on EKS 互動端點** - *互動端點*是一個 HTTPS 端點，EMR Studio 使用者可以將工作區與其相連。只能從 EMR Studio 中存取 HTTPS 端點，並在 Amazon EKS 叢集的 Amazon Virtual Private Cloud (Amazon VPC) 的私有子網路中建立這些端點。

  Python、PySpark 和 Spark Scala 核心使用在 Amazon EMR on EKS 作業執行角色中定義的許可來調用其他 AWS 服務。連線到互動端點的所有核心和使用者都會利用您在建立端點時指定的角色。我們建議您為不同的使用者建立不同的端點，並且使用者具有不同的 AWS Identity and Access Management (IAM) 角色。
+ **AWS Application Load Balancer 控制器** – *AWS Application Load Balancer 控制器*會管理 Amazon EKS Kubernetes 叢集的 Elastic Load Balancing。當您建立 Kubernetes Ingress 資源時，控制器會佈建 Application Load Balancer (ALB)。ALB 會在 Amazon EKS 叢集之外但在相同 Amazon VPC 內公開 Kubernetes 服務 (例如互動端點)。當您建立互動端點時，也會部署 Ingress 資源，透過 ALB 公開互動端點，以供互動式用戶端連線。您只需要為每個 Amazon EKS 叢集安裝 one AWS Application Load Balancer 控制器。

下圖說明 Amazon EMR on EKS 中的互動端點架構。Amazon EKS 叢集包含用於執行分析工作負載的*運算*和*互動端點*。Application Load Balancer 控制器會在 `kube-system` 命名空間中執行；工作負載和互動端點會在您建立虛擬叢集時指定的命名空間中執行。建立互動端點時，Amazon EMR on EKS 控制平面會在 Amazon EKS 叢集中建立互動端點部署。此外，應用程式負載平衡器傳入的執行個體是由 AWS 負載平衡器控制器所建立。Application Load Balancer 可為 EMR Studio 等用戶端提供外部介面，已連接到 Amazon EMR 叢集並執行互動式工作負載。

![\[互動端點架構圖\]](http://docs.aws.amazon.com/zh_tw/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png)


# 在 Amazon EMR on EKS 上建立互動端點的先決條件
<a name="prereqs-for-studio"></a>

本章節描述了設定互動端點的先決條件，EMR Studio 可使用該端點連線到 Amazon EMR on EKS 叢集並執行互動式工作負載。

## AWS CLI
<a name="cli-installed"></a>

請依照[安裝或更新至最新版本 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)中的步驟，安裝最新版本的 AWS Command Line Interface (AWS CLI)。

## 安裝 eksctl
<a name="eksctl-install"></a>

請依照[安裝 kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) 中的步驟安裝最新版本的 eksctl。如果為 Amazon EKS 叢集使用 Kubernetes 版本 1.22 或更新版本，請使用 eksctl 0.117.0 以後的版本。

## Amazon EKS 叢集
<a name="eks-cluster"></a>

建立 Amazon EKS 叢集。使用 Amazon EMR on EKS ，將叢集註冊為虛擬叢集。以下是此叢集的要求和考量事項。
+ 叢集必須與 EMR Studio 處於相同的 Amazon Virtual Private Cloud (VPC)。
+ 叢集必須擁有至少一個私有子網路，以啟動互動端點、連結 Git 型儲存庫以及以私有模式啟動 Application Load Balancer。
+ EMR Studio 和用於註冊虛擬叢集的 Amazon EKS 叢集之間必須至少有一個共同的私有子網路。這可確保互動端點在 Studio 工作區中顯示為選項，並啟用從 Studio 到 Application Load Balancer 的連線。

  您可以選擇兩種方法來連接 Studio 和 Amazon EKS 叢集：
  + 建立 Amazon EKS 叢集，並將其與屬於 EMR Studio 的子網路產生關聯。
  + 或者，建立 EMR Studio，並為 Amazon EKS 叢集指定私有子網路。
+ Amazon EMR on EKS 互動端點不支援 Amazon EKS 優化的 ARM Amazon Linux AMI。
+ 僅支援 [Amazon EKS 受管節點群組](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html)和 Karpenter 佈建節點。

## 為 Amazon EMR on EKS 授予叢集存取權
<a name="emr-eks-cluster-virtual"></a>

使用[為 Amazon EMR on EKS 授予叢集存取權](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html)中的步驟，將 Amazon EMR on EKS 存取權授予給叢集中的特定命名空間。

## 在 Amazon EKS 叢集上啟用 IRSA
<a name="activate-iam-roles"></a>

若要在 Amazon EKS 叢集上啟用服務帳戶的 IAM 角色 (IRSA)，請按照[啟用服務帳戶的 IAM 角色 (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html) 中的步驟進行操作。

## 建立 IAM 作業執行角色
<a name="iam-role"></a>

必須建立 IAM 角色，才能在 Amazon EMR on EKS 互動端點上執行工作負載。在本文件中，我們將 IAM 角色稱為*作業執行角色*。此 IAM 角色會同時指派給互動端點容器和您使用 EMR Studio 提交作業時所建立的實際執行容器。您將需要 Amazon EMR on EKS 之作業執行角色的 Amazon Resource Name (ARN)。這需要兩個步驟：
+ [建立適用於作業執行的 IAM 角色。](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 的存取權
<a name="iam-permission"></a>

提出建立互動端點請求的 IAM 實體 (使用者或角色) 也必須擁有下列 Amazon EC2 和 `emr-containers` 許可。請遵循 [授予使用者對 Amazon EMR on EKS 的存取權](setting-up-iam.md) 中描述的步驟，授予這些許可，以允許 Amazon EMR on EKS 建立、管理和刪除安全群組，這些安全群組會將傳入流量限制到互動端點的負載平衡器。

下列 `emr-containers` 許可允許使用者執行基本的互動端點操作：

```
"ec2:CreateSecurityGroup",
"ec2:DeleteSecurityGroup",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress"

"emr-containers:CreateManagedEndpoint",
"emr-containers:ListManagedEndpoints",
"emr-containers:DescribeManagedEndpoint",
"emr-containers:DeleteManagedEndpoint"
```

## 向 Amazon EMR 註冊 Amazon EKS 叢集
<a name="register-eks-cluster"></a>

設定虛擬叢集，並將其映射至 Amazon EKS 叢集中您要執行作業的命名空間。僅限 AWS Fargate叢集，請針對 Amazon EMR on EKS 虛擬叢集和 Fargate 設定檔使用相同的命名空間。

如需有關設定 Amazon EMR on EKS 虛擬叢集的資訊，請參閱 [向 Amazon EMR 註冊 Amazon EKS 叢集](setting-up-registration.md)。

## Amazon EKS 叢集的 Deploy AWS Load Balancer 控制器
<a name="load-balancer-controller"></a>

Amazon EKS 叢集需要 An AWS Application Load Balancer。只需為每個 Amazon EKS 叢集設定一個 Application Load Balancer 控制器。如需有關設定 AWS Application Load Balancer控制器的資訊，請參閱《*Amazon EKS 使用者指南*》中的[安裝 AWS Load Balancer控制器附加元件](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)。

# 為虛擬叢集建立互動端點
<a name="create-managed-endpoint"></a>

本主題說明使用 AWS 命令列界面 (AWS CLI) 建立互動式端點的幾種方式，並包含可用組態參數的詳細資訊。

## 使用 `create-managed-endpoint` 命令建立互動端點
<a name="create-using-json-file"></a>

在 `create-managed-endpoint` 命令中指定參數，如下所示。Amazon EMR on EKS 支援使用 Amazon EMR 6.7.0 及更高版本建立互動端點。

```
aws emr-containers create-managed-endpoint \
‐‐type JUPYTER_ENTERPRISE_GATEWAY \
‐‐virtual‐cluster‐id 1234567890abcdef0xxxxxxxx \
‐‐name example-endpoint-name \
‐‐execution-role-arn arn:aws:iam::444455556666:role/JobExecutionRole \
‐‐release-label emr-6.9.0-latest \
‐‐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"
        }
    }
}'
```

如需詳細資訊，請參閱[用於建立互動端點的參數](#parameters-for-creating)。

## 在 JSON 檔案中使用指定參數建立互動端點
<a name="create-using-json-file-B"></a>

1. 建立 `create-managed-endpoint-request.json` 檔案並指定端點所需的參數，如下列 JSON 檔案所示：

   ```
   {
       "name": "MY_TEST_ENDPOINT",
       "virtualClusterId": "MY_CLUSTER_ID",
       "type": "JUPYTER_ENTERPRISE_GATEWAY",
       "releaseLabel": "emr-6.9.0-latest",
       "executionRoleArn": "arn:aws:iam::444455556666:role/JobExecutionRole",
       "configurationOverrides":
       {
           "applicationConfiguration": 
           [
               {
                   "classification": "spark-defaults",
                   "properties":
                   {
                       "spark.driver.memory": "8G"
                   }
               }
           ],
           "monitoringConfiguration":
           {
               "persistentAppUI": "ENABLED",
               "cloudWatchMonitoringConfiguration":
               {
                   "logGroupName": "my_log_group",
                   "logStreamNamePrefix": "log_stream_prefix"
               },
               "s3MonitoringConfiguration":
               {
                   "logUri": "s3://my_s3_log_location"
               }
           }
       }
   }
   ```

1. 搭配使用 `create-managed-endpoint` 命令與儲存在本機或 Amazon S3 中的 `create-managed-endpoint-request.json` 檔案路徑。

   ```
   aws emr-containers create-managed-endpoint \
   ‐‐cli-input-json  file://./create-managed-endpoint-request.json ‐‐region AWS-Region
   ```

## 建立互動端點的輸出
<a name="create-managed-endpoint-output"></a>

在終端中應能看到下列輸出。輸出包括新互動端點的名稱和識別符：

```
{
    "id": "1234567890abcdef0",
    "name": "example-endpoint-name", 
    "arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666",
    "virtualClusterId": "111122223333xxxxxxxx"
}
```

執行中的 `aws emr-containers create-managed-endpoint` 會建立自我簽署的憑證，它允許 EMR Studio 和互動端點伺服器之間的 HTTPS 通訊。

如果您執行 `create-managed-endpoint` 但尚未完成先決條件，Amazon EMR 會傳回錯誤訊息，其中包含為了繼續而必須採取的動作。

## 用於建立互動端點的參數
<a name="parameters-for-creating"></a>

**Topics**
+ [互動端點的必要參數](#parameters-for-creating-required)
+ [互動端點的選用參數](#parameters-for-creating-optional)

### 互動端點的必要參數
<a name="parameters-for-creating-required"></a>

建立互動端點時，必須指定下列參數：

**`‐‐type`**  
請使用 `JUPYTER_ENTERPRISE_GATEWAY`。這是唯一支援的類型。

**`‐‐virtual-cluster-id`**  
您 Amazon EMR on EKS 註冊的虛擬叢集的識別符。

**`‐‐name`**  
互動端點的描述性名稱，它可幫助 EMR Studio 使用者從下拉式清單中選擇。

**`‐‐execution-role-arn`**  
適用於 Amazon EMR on EKS 的 IAM 作業執行角色的 Amazon Resource Name (ARN)，該角色作為先決條件的一部分而建立。

**`‐‐release-label`**  
用於端點的 Amazon EMR 版本的版本標籤。例如 `emr-6.9.0-latest`。透過 Amazon EMR 6.7.0 及更高版本，Amazon EMR on EKS 支援互動端點。

### 互動端點的選用參數
<a name="parameters-for-creating-optional"></a>

建立互動端點時，也可選擇性地指定下列參數：

**`‐‐configuration-overrides`**  
若要覆寫應用程式的預設組態，請提供組態物件。可以使用速記語法，以提供組態或參考 JSON 檔案中物件的組態。

組態物件是由分類、屬性和選用的巢狀組態所組成。屬性由您想要在檔案中覆寫的設定組成。您可以在單一 JSON 物件中，為多個應用程式指定多個分類。可用的組態分類因 Amazon EMR on EKS 版本而異。如需每個 Amazon EMR on EKS 版本可用的組態分類清單，請參閱 [Amazon EMR on EKS 發行版本](emr-eks-releases.md)。除了針對每個版本列出的組態分類之外，互動端點還會引入其他分類 `jeg-config`。如需詳細資訊，請參閱[Jupyter Enterprise Gateway (JEG) 組態選項](jeg-config-options.md)。

# 配置互動端點的設定
<a name="managed-endpoint-parameters"></a>

本節包含一系列主題，涵蓋互動式端點和 Pod 設定的各種組態。這些可讓您監控故障並進行故障診斷、將日誌資訊傳送至 Amazon S3 或 Amazon CloudWatch Logs，或建立互動式端點以指定自訂 Pod 範本。

**Topics**
+ [監控 Spark 任務](monitoring-spark-jobs.md)
+ [使用互動端點指定自訂 Pod 範本](custom-pod-templates.md)
+ [將 JEG Pod 部署到節點群組](managed-endpoint-nodegroups-setup.md)
+ [Jupyter Enterprise Gateway (JEG) 組態選項](jeg-config-options.md)
+ [修改 PySpark 工作階段參數](modify-pyspark-parameters.md)
+ [具有互動端點的自訂核心映像](custom-kernel.md)

# 監控 Spark 任務
<a name="monitoring-spark-jobs"></a>

如此一來，您就可以監控故障並進行疑難排解，設定互動端點，以便透過端點啟動的作業可以將日誌資訊傳送到 Amazon S3、Amazon CloudWatch Logs 或兩者。以下各章節描述了針對您透過 Amazon EMR on EKS 互動端點啟動的 Spark 作業，如何將 Spark 應用程式日誌傳送至 Amazon S3。

**設定 Amazon S3 日誌的 IAM 政策**

在您的核心將日誌資料傳送到 Amazon S3 之前，作業執行角色的許可政策必須包含下列許可。將 *amzn-s3-demo-destination-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 也可以建立 S3 儲存貯體。如果無法使用 S3 儲存貯體，請在 IAM 政策中包含 `s3:CreateBucket` 許可。

將所需許可授予給執行角色以便將日誌傳送到 S3 儲存貯體之後，您的日誌資料會傳送到以下 Amazon S3 位置。在 `create-managed-endpoint` 請求的 `monitoringConfiguration` 區段中傳遞 `s3MonitoringConfiguration` 時，會發生這種情況。
+ **驅動程式日誌** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)`
+ **執行程式日誌** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-<Number>/(stderr.gz/stdout.gz)`

**注意**  
Amazon EMR on EKS 不會將端點日誌上傳到 S3 儲存貯體。

# 使用互動端點指定自訂 Pod 範本
<a name="custom-pod-templates"></a>

您可以建立互動端點，在其中指定驅動程式和執行程式的自訂 Pod 範本。*Pod 範本*是決定如何執行每個 Pod 的規範。可以使用 Pod 範本檔案來定義 Spark 組態不支援的驅動程式或執行程式 Pod 的組態。Amazon EMR 6.3.0 版本及更高版本目前支援 Pod 範本。

如需有關 Pod 範本的詳細資訊，請參閱《Amazon EMR on EKS 開發指南》**中的[使用 Pod 範本](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html)。

以下範例會示範如何使用 Pod 範本建立互動端點：

```
aws emr-containers create-managed-endpoint \
    --type JUPYTER_ENTERPRISE_GATEWAY \
    --virtual-cluster-id virtual-cluster-id \
    --name example-endpoint-name \
    --execution-role-arn arn:aws:iam::aws-account-id:role/EKSClusterRole \
    --release-label emr-6.9.0-latest \
    --configuration-overrides '{
        "applicationConfiguration": [
        {
            "classification": "spark-defaults",
            "properties": {
                "spark.kubernetes.driver.podTemplateFile": "path/to/driver/template.yaml",
                "spark.kubernetes.executor.podTemplateFile": "path/to/executor/template.yaml"
            }
        }]
    }'
```

# 將 JEG Pod 部署到節點群組
<a name="managed-endpoint-nodegroups-setup"></a>

JEG (Jupyter Enterprise Gateway) Pod 放置是一項功能，可讓您在特定節點群組上部署互動端點。使用此功能，可以設定互動端點的設定，例如 `instance type`。

## 將 JEG Pod 關聯至受管節點群組
<a name="associate-jegpod-to-nodegroup"></a>

下列組態屬性可讓您指定要部署 JEG Pod 之 Amazon EKS 叢集上的受管節點群組名稱。

```
//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'
```

節點群組必須已將 Kubernetes 標籤 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` 附接至屬於節點群組的所有節點。若要列出節點群組中擁有此標籤的所有節點，請使用下列命令：

```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```

如果上述命令輸出未傳回屬於受管節點群組的節點，則節點群組中沒有附接 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 標籤的節點。在這種情況下，遵循以下步驟將標籤附接至節點群組中的節點。

1. 使用下列命令，將 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 標籤新增至受管節點群組 `NodeGroupName` 中的所有節點：

   ```
   kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
   ```

1. 使用下列命令，確認已正確標記節點：

   ```
   kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
   ```

受管節點群組必須與 Amazon EKS 叢集的安全群組相關聯，這通常發生在您使用 `eksctl` 建立叢集和受管節點群組時。您可以使用下列步驟在 AWS 主控台中驗證此項目。

1. 轉至 Amazon EKS 主控台中的叢集。

1. 轉至叢集的「聯網」索引標籤，並記下叢集安全群組。

1. 轉至叢集的「運算」索引標籤，然後按一下受管節點群組名稱。

1. 在受管節點群組的**詳細資訊**索引標籤下，確認您先前記下的叢集安全群組列在**安全群組**下。

如果受管節點群組未附接至 Amazon EKS 叢集安全群組，則需要將 `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` 標籤附接至節點群組安全群組。使用下列步驟來附接此標籤。

1. 轉至 Amazon EC2 主控台並按一下左側導覽窗格中的安全群組。

1. 按一下核取方塊，選取受管節點群組的安全群組。

1. 在**標籤**索引標籤下，使用**管理標籤**按鈕新增標籤 `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`。

## 將 JEG Pod 關聯至自我管理節點群組
<a name="associate-jegpod-to-self-managed-nodegroup"></a>

下列組態屬性可讓您指定要部署 JEG Pod 之 Amazon EKS 叢集上的自我管理或未受管節點群組名稱。

```
//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "self-managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'
```

節點群組必須已將 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 標籤附接至屬於節點群組的所有節點。若要列出節點群組中擁有此標籤的所有節點，請使用下列命令：

```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```

如果上述命令輸出未傳回屬於自我管理節點群組的節點，則節點群組中沒有附接 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 標籤的節點。在這種情況下，遵循以下步驟將標籤附接至節點群組中的節點。

1. 如果使用 `eksctl` 建立自我管理節點群組，請使用下列命令將 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 標籤一次新增至自我管理節點群組 `NodeGroupName` 中的所有節點。

   ```
   kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
   ```

   如果您未使用 `eksctl` 建立自我管理節點群組，則需要將上述命令中的選取器取代為附接至節點群組中所有節點的不同 Kubernetes 標籤。

1. 使用下列命令，確認已正確標記節點：

   ```
   kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
   ```

自我管理節點群組的安全群組必須已附接 `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` 標籤。使用下列步驟將標籤從 AWS 管理主控台中附接至安全群組。

1. 導覽至 Amazon EC2 主控台。在左側導覽窗格中，選取**安全群組**。

1. 選取自我管理節點群組中安全群組旁邊的核取方塊。

1. 在**標籤**索引標籤下，使用**管理標籤**按鈕新增標籤 `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`。用適當的值取代 `ClusterName` 和 `NodeGroupName`。

## 將 JEG Pod 關聯至具有隨需執行個體的受管節點群組
<a name="associate-jegpod-to-on-demand-instances"></a>

也可以定義其他標籤 (稱為 *Kubernetes 標籤選取器*)，以指定其他約束或限制，以便在指定節點或節點群組上執行互動端點。以下範例說明如何將隨需 Amazon EC2 執行個體用於 JEG Pod。

```
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName,
                    "node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
                }        
            }
        ] 
    }'
```

**注意**  
只能將 `node-labels` 屬性與 `managed-nodegroup-name` 或 `self-managed-nodegroup-name` 屬性搭配使用。

# Jupyter Enterprise Gateway (JEG) 組態選項
<a name="jeg-config-options"></a>

Amazon EMR on EKS 使用 Jupyter Enterprise Gateway (JEG) 開啟互動端點。建立端點時，可以為允許列出的 JEG 組態設定下列值。
+ **`RemoteMappingKernelManager.cull_idle_timeout`** - 以秒為單位的逾時值 (整數)，在此時間之後核心會被視為閒置並準備好被剔除。`0` 或更低的值會停用剔除。對於網路連線不佳的使用者而言，短暫的逾時可能會導致核心被剔除。
+ **`RemoteMappingKernelManager.cull_interval`** - 以秒為單位的時間間隔 (整數)，會根據該時間值檢查超過剔除逾時值的閒置核心。

# 修改 PySpark 工作階段參數
<a name="modify-pyspark-parameters"></a>

從 Amazon EMR on EKS 6.9.0 開始，可透過在 EMR 筆記本儲存格中執行 `%%configure` 魔術命令，在 Amazon EMR Studio 中調整與 PySpark 工作階段相關聯的 Spark 組態。

下列範例顯示了範例承載，可用來修改 Spark 驅動程式和執行程式的記憶體、核心和其他屬性。對於 `conf` 設定，可設定 [Apache Spark 組態文件](https://spark.apache.org/docs/latest/configuration.html)中提到的任何 Spark 組態。

```
%%configure -f
{
  "driverMemory": "16G",
  "driverCores": 4,
  "executorMemory" : "32G",
  "executorCores": 2,
  "conf": {
     "spark.dynamicAllocation.maxExecutors" : 10,
     "spark.dynamicAllocation.minExecutors": 1
  }
}
```

下列範例顯示範例承載，可用於將檔案、PyFiles 和 jar 相依性新增至 Spark 執行期。

```
%%configure -f
{
  "files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt",
  "pyFiles": : "path-to-python-files",
  "jars" : "path-to-jars
}
```

# 具有互動端點的自訂核心映像
<a name="custom-kernel"></a>

為了確保在 Amazon EMR Studio 中執行互動式工作負載時具有應用程式的正確相依性，您可以為互動端點自訂 Docker 映像檔，並執行自訂的基礎核心映像。若要建立互動端點，並將其與自訂 Docker 映像檔相連，請執行以下步驟。

**注意**  
只能覆寫基礎映像。無法新增核心映像類型。

1. **建立並發布自訂的 Docker 映像檔。**基礎映像包含 Spark 執行期和隨之一起執行的筆記本核心。若要建立映像，可遵循 [如何自訂 Docker 映像檔](docker-custom-images-steps.md) 中的步驟 1 到 4。在步驟 1 中，Docker 檔案中的基礎映像 URI 必須使用 `notebook-spark` 代替 `spark`。

   ```
   ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
   ```

   如需如何選取 AWS 區域 和容器映像標籤的詳細資訊，請參閱 [選取基礎映像 URI 的詳細資訊](docker-custom-images-tag.md)。

1. **建立可與自訂映像搭配使用的互動端點。**

   1. 使用下列內容建立 JSON 檔案 `custom-image-managed-endpoint.json`。此範例使用 Amazon EMR 6.9.0 版。  
**Example**  

      ```
      {
          "name": "endpoint-name",
          "virtualClusterId": "virtual-cluster-id",
          "type": "JUPYTER_ENTERPRISE_GATEWAY",
          "releaseLabel": "emr-6.9.0-latest",
          "executionRoleArn": "execution-role-arn",
          "configurationOverrides": {
              "applicationConfiguration": [
                  {
                      "classification": "jupyter-kernel-overrides",
                      "configurations": [
                          {
                              "classification": "python3",
                              "properties": {
                                  "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-python:latest"
                              }
                          },
                          {
                              "classification": "spark-python-kubernetes",
                              "properties": {
                                  "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-spark:latest"
                              }
                          }
                      ] 
                  }
              ]
          }
      }
      ```

   1. 使用 JSON 檔案中指定的組態建立互動端點，如下列範例所示。如需詳細資訊，請參閱[使用 `create-managed-endpoint` 命令建立互動端點](create-managed-endpoint.md#create-using-json-file)。

      ```
      aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
      ```

1. **透過 EMR Studio 連接至互動端點。**如需詳細資訊和完成的步驟，請參閱 AWS Workshop [Studio 文件的 Amazon EMR on EKS 區段中的從 Studio 連線](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html)。

# 監控互動端點
<a name="managed-endpoints-customer-metrics"></a>

使用 Amazon EMR on EKS 6.10 版及更高版本，互動端點會發出 Amazon CloudWatch 指標，用於監控核心生命週期操作並進行疑難排解。指標是由互動式用戶端 (例如 EMR Studio 或自行託管的 Jupyter 筆記本) 觸發。互動端點支援的每個操作都有與其相關聯的指標。操作會建模為每個指標的維度，如下表所示。互動端點發出的指標會顯示在您帳戶中的自訂命名空間 EMRContainers 下方。


| 指標 | Description | 單位 | 
| --- | --- | --- | 
|  RequestCount  |  互動端點所處理之操作的請求累計數目。  |  計數  | 
|  RequestLatency  |  從請求到達互動端點到互動端點傳送回應的時間。  |  毫秒  | 
|  4XXError  |  當操作的請求導致在處理過程中出現 4xx 錯誤時發出。  |  計數  | 
|  5XXError  |  當操作的請求導致 5Xxx 伺服器端錯誤時發出。  |  計數  | 
|  KernelLaunchSuccess  |  僅適用於 CreateKernel 操作。它表示成功執行且包含此請求的核心啟動累計次數。  |  計數  | 
|  KernelLaunchFailure  |  僅適用於 CreateKernel 操作。它表示發生失敗且包含此請求的核心啟動累計次數。  |  計數  | 

每個互動端點指標都附接有下列兩個維度：
+ **`ManagedEndpointId`** - 互動端點的識別符 
+ **`OperationName`** - 互動式用戶端觸發的操作

**`OperationName`** 維度的可能值如下表所示：


| `operationName` | 操作說明 | 
| --- | --- | 
|  `CreateKernel`  |  互動端點啟動核心的請求。  | 
|  `ListKernels`  |  互動端點列出核心 (先前已使用相同的工作階段字符啟動這些核心) 的請求。  | 
|  `GetKernel`  |  互動端點取得先前已啟動之特定核心詳細資訊的請求。  | 
|  `ConnectKernel`  |  互動端點在筆記本用戶端與核心之間建立連線的請求。  | 
|  `ConfigureKernel`  |  在 pyspark 核心上發布 `%%configure magic request`。  | 
|  `ListKernelSpecs`  |  互動端點列出可用核心規範的請求。  | 
|  `GetKernelSpec`  |  互動端點取得先前已啟動之核心規範的請求。  | 
|  `GetKernelSpecResource`  |  互動端點取得先前已啟動之核心規範相關聯特定資源的請求。  | 

## 範例
<a name="metrics-examples"></a>

### 若要存取在特定日期為互動端點啟動的核心總數：
<a name="example01"></a>

1. 選取自訂命名空間：`EMRContainers`

1. 選取您的 `ManagedEndpointId`、`OperationName – CreateKernel`。

1. 具有統計值 `SUM` 和期限 `1 day` 的 `RequestCount` 指標將提供過去 24 小時內發出的所有核心啟動請求。

1. 具有統計值 `SUM` 和期限 `1 day` 的 KernelLaunchSuccess 指標將提供過去 24 小時內發出的所有成功的核心啟動請求。

### 若要存取特定日期互動端點的核心失敗次數：
<a name="example02"></a>

1. 選取自訂命名空間：EMRContainers 

1. 選取您的 `ManagedEndpointId`、`OperationName – CreateKernel`。

1. 具有統計值 `SUM` 和期限 `1 day` 的 `KernelLaunchFailure` 指標將提供過去 24 小時內發出的所有失敗的核心啟動請求。也可選擇 `4XXError` 和 `5XXError` 指標來了解發生了什麼類型的核心啟動失敗。

# 使用自助託管的 Jupyter 筆記本
<a name="managed-endpoints-self-hosted"></a>

可以在 Amazon EC2 執行個體或您自己的 Amazon EKS 叢集上託管和管理 Jupyter 或 JupyterLab 筆記本，作為*自助託管的 Jupyter 筆記本*。然後，使用自助託管的 Jupyter 筆記本執行互動式工作負載。以下各章節將逐步介紹在 Amazon EKS 叢集上設定和部署自助託管的 Jupyter 筆記本的程序。



**Topics**
+ [建立安全群組](#managed-endpoints-self-hosted-security)
+ [建立 Amazon EMR on EKS 互動端點](#managed-endpoints-self-hosted-create-me)
+ [擷取互動端點的閘道伺服器 URL](#managed-endpoints-self-hosted-gateway)
+ [擷取驗證字符以連接到互動端點](#managed-endpoints-self-hosted-auth)
+ [範例：部署 JupyterLab 筆記本](#managed-endpoints-self-hosted-example)
+ [刪除自助託管的 Jupyter 筆記本](#managed-endpoints-self-hosted-cleanup)

## 建立安全群組
<a name="managed-endpoints-self-hosted-security"></a>

必須先建立安全群組來控制筆記本與互動端點之間的流量，才能建立互動端點並執行自助託管的 Jupyter 或 JupyterLab 筆記本。若要使用 Amazon EC2 主控台或 Amazon EC2 SDK 建立安全群組，請參閱《*Amazon EC2 使用者指南*》中的[建立安全群組](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group)中的步驟。應該在要部署筆記本伺服器的 VPC 中建立安全群組。

若要遵循本指南中的範例，請使用與 Amazon EKS 叢集相同的 VPC。如果想要將筆記本託管在與 Amazon EKS 叢集的 VPC 不同的 VPC 中，則可能需要在這兩個 VPC 之間建立對等互連。如需在兩個 VPC 之間建立對等互連的步驟，請參閱《Amazon VPC 入門指南》中的[建立 VPC 對等互連](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html)。

您需要安全群組的 ID，才能在下一個步驟中[建立 Amazon EMR on EKS 互動端點](https://docs.aws.amazon.com/)。

## 建立 Amazon EMR on EKS 互動端點
<a name="managed-endpoints-self-hosted-create-me"></a>

為筆記本建立安全群組之後，請使用 [為虛擬叢集建立互動端點](create-managed-endpoint.md) 中提供的步驟建立互動端點。必須提供在 [建立安全群組](#managed-endpoints-self-hosted-security) 中為筆記本建立的安全群組 ID 。

在下列組態覆寫設定中插入安全 ID 來取代 *your-notebook-security-group-id*：

```
--configuration-overrides '{
    "applicationConfiguration": [
        {
            "classification": "endpoint-configuration",
            "properties": {
                "notebook-security-group-id": "your-notebook-security-group-id"
            }
        }
    ],
    "monitoringConfiguration": {
    ...'
```

## 擷取互動端點的閘道伺服器 URL
<a name="managed-endpoints-self-hosted-gateway"></a>

建立互動端點後，請使用 AWS CLI中的 `describe-managed-endpoint` 命令來擷取閘道伺服器 URL。需要此 URL 才能將筆記本連接到端點。閘道伺服器 URL 是私有端點。

```
aws emr-containers describe-managed-endpoint \
--region region \
--virtual-cluster-id virtualClusterId \
--id endpointId
```

最初，您的端點處於 **CREATING** 狀態。幾分鐘後，它會轉換為 **ACTIVE** 狀態。當端點為 **ACTIVE** 時，即已準備好可供使用。

記下 `aws emr-containers describe-managed-endpoint` 命令從作用中端點傳回的 `serverUrl` 屬性。當您[部署自助託管的 Jupyter 或 JupyterLab 筆記本](https://docs.aws.amazon.com/)時，需要此 URL 才能將筆記本連接到端點。

## 擷取驗證字符以連接到互動端點
<a name="managed-endpoints-self-hosted-auth"></a>

若要從 Jupyter 或 JupyterLab 筆記本連接到互動端點，必須使用 `GetManagedEndpointSessionCredentials` API 產生工作階段字符。字符充當驗證證明，以連接到互動端點伺服器。

下面的輸出範例將更詳細地說明以下命令。

```
aws emr-containers get-managed-endpoint-session-credentials \
--endpoint-identifier endpointArn \
--virtual-cluster-identifier virtualClusterArn \
--execution-role-arn executionRoleArn \
--credential-type "TOKEN" \
--duration-in-seconds durationInSeconds \
--region region
```

**`endpointArn`**  
端點的 ARN。可以在 `describe-managed-endpoint` 呼叫的結果中尋找 ARN。

**`virtualClusterArn`**  
虛擬叢集的 ARN。

**`executionRoleArn`**  
執行角色的 ARN。

**`durationInSeconds`**  
字符有效的持續時間 (以秒為單位)。預設持續時間為 15 分鐘 (`900`)，最長為 12 小時 (`43200`)。

**`region` **  
與端點相同的區域。

輸出應類似以下範例。請記下您在[部自助託管的 Jupyter 或 JupyterLab 筆記](https://docs.aws.amazon.com/)本時將使用的 `session-token` 值。

```
{
    "id": "credentialsId",
    "credentials": {
        "token": "session-token"
    },
    "expiresAt": "2022-07-05T17:49:38Z"
}
```

## 範例：部署 JupyterLab 筆記本
<a name="managed-endpoints-self-hosted-example"></a>

完成上述步驟後，可以嘗試此範例程序，將 JupyterLab 筆記本部署到具有互動端點的 Amazon EKS 叢集中。

1. 建立命名空間，以執行筆記本伺服器。

1. 在本機建立檔案 `notebook.yaml`，其中具有以下內容。檔案內容如下所述。

   ```
   apiVersion: v1
   kind: Pod
   metadata:
     name: jupyter-notebook
     namespace: namespace
   spec:
     containers:
     - name: minimal-notebook
       image: jupyter/all-spark-notebook:lab-3.1.4 # open source image 
       ports:
       - containerPort: 8888
       command: ["start-notebook.sh"]
       args: ["--LabApp.token=''"]
       env:
       - name: JUPYTER_ENABLE_LAB
         value: "yes"
       - name: KERNEL_LAUNCH_TIMEOUT
         value: "400"
       - name: JUPYTER_GATEWAY_URL
         value: "serverUrl"
       - name: JUPYTER_GATEWAY_VALIDATE_CERT
         value: "false"
       - name: JUPYTER_GATEWAY_AUTH_TOKEN
         value: "session-token"
   ```

   如果您要將 Jupyter 筆記本部署到僅限 Fargate 的叢集，請使用 `role` 標籤來標記 Jupyter Pod，如下列範例所示：

   ```
   ...
   metadata:
     name: jupyter-notebook
     namespace: default
     labels:
       role: example-role-name-label
   spec:
               ...
   ```  
**`namespace`**  
在其中部署筆記本的 Kubernetes 命名空間。  
**`serverUrl`**  
`describe-managed-endpoint` 命令在 [擷取互動端點的閘道伺服器 URL](#managed-endpoints-self-hosted-gateway) 中傳回的 `serverUrl` 屬性。  
**`session-token`**  
`get-managed-endpoint-session-credentials` 命令在 [擷取驗證字符以連接到互動端點](#managed-endpoints-self-hosted-auth) 中傳回的 `session-token` 屬性。  
**`KERNEL_LAUNCH_TIMEOUT`**  
互動端點等待核心進入 **RUNNING** 狀態的時間 (以秒為單位)。將核心啟動逾時設定為適當的值 (最多 400 秒)，以確保有足夠的時間來完成核心啟動。  
**`KERNEL_EXTRA_SPARK_OPTS`**  
或者，可以為 Spark 核心傳遞額外的 Spark 組態。將具有值的此環境變數設定為 Spark 組態屬性，如以下範例所示：  

   ```
   - name: KERNEL_EXTRA_SPARK_OPTS
     value: "--conf spark.driver.cores=2
             --conf spark.driver.memory=2G
             --conf spark.executor.instances=2
             --conf spark.executor.cores=2
             --conf spark.executor.memory=2G
             --conf spark.dynamicAllocation.enabled=true
             --conf spark.dynamicAllocation.shuffleTracking.enabled=true
             --conf spark.dynamicAllocation.minExecutors=1
             --conf spark.dynamicAllocation.maxExecutors=5
             --conf spark.dynamicAllocation.initialExecutors=1
             "
   ```

1. 將 Pod 規範部署至 Amazon EKS 叢集。

   ```
   kubectl apply -f notebook.yaml -n namespace
   ```

   這將啟動已連接到 Amazon EMR on EKS 互動端點的最小 JupyterLab 筆記本。請等待，直到 Pod 處於 **RUNNING** 狀態。可以使用下列命令來檢查其狀態：

   ```
   kubectl get pod jupyter-notebook -n namespace
   ```

   當 Pod 準備就緒時，`get pod` 命令會傳回類似以下輸出：

   ```
   NAME              READY  STATUS   RESTARTS  AGE
   jupyter-notebook  1/1    Running  0         46s
   ```

1. 將筆記本安全群組附接至排程筆記本所在的節點。

   1. 首先，使用 `describe pod` 命令識別在其中排程 `jupyter-notebook` Pod 的節點。

      ```
      kubectl describe pod jupyter-notebook -n namespace
      ```

   1. 在以下網址開啟 Amazon EKS 主控台：[https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters)。

   1. 導覽至 Amazon EKS 叢集的**運算**索引標籤，然後選取 `describe pod` 命令識別的節點。選取節點的執行個體 ID。

   1. 從**動作**功能表中，選取**安全性** > **變更安全群組**，以附接您在 [建立安全群組](#managed-endpoints-self-hosted-security) 中建立的安全群組。

   1. 如果您要在 上部署 Jupyter 筆記本 Pod AWS Fargate，請建立 []() 以套用到具有角色標籤的 Jupyter 筆記本 Pod：

      ```
      cat >my-security-group-policy.yaml <<EOF
      apiVersion: vpcresources.k8s.aws/v1beta1
      kind: SecurityGroupPolicy
      metadata:
        name: example-security-group-policy-name
        namespace: default
      spec:
        podSelector:
          matchLabels:
            role: example-role-name-label
        securityGroups:
          groupIds:
            - your-notebook-security-group-id
      EOF
      ```

1. 現在，執行 port-forward，以便您可以在本機存取 JupyterLab 介面：

   ```
   kubectl port-forward jupyter-notebook 8888:8888 -n namespace
   ```

   執行後，導覽至您的本機瀏覽器並造訪 `localhost:8888` 以查看 JupyterLab 介面：  
![\[JupyterLab 開始畫面的螢幕擷取畫面。\]](http://docs.aws.amazon.com/zh_tw/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1. 從 JupyterLab 中建立新的 Scala 筆記本。以下是程式碼片段範例，您可以執行它以接近 Pi 的值：

   ```
   import scala.math.random
   import org.apache.spark.sql.SparkSession
   
   /** Computes an approximation to pi */
   val session = SparkSession
     .builder
     .appName("Spark Pi")
     .getOrCreate()
   
   val slices = 2
   // avoid overflow
   val n = math.min(100000L * slices, Int.MaxValue).toInt 
    
   val count = session.sparkContext
   .parallelize(1 until n, slices)
   .map { i =>
     val x = random * 2 - 1
     val y = random * 2 - 1
     if (x*x + y*y <= 1) 1 else 0
   }.reduce(_ + _)
   
   println(s"Pi is roughly ${4.0 * count / (n - 1)}")
   session.stop()
   ```  
![\[JupyterLab 中 Scala 筆記本程式碼範例的熒幕擷取畫面。\]](http://docs.aws.amazon.com/zh_tw/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)

## 刪除自助託管的 Jupyter 筆記本
<a name="managed-endpoints-self-hosted-cleanup"></a>

當您準備好刪除自助託管的筆記本時，也可以刪除互動端點和安全群組。請依下列順序執行動作：

1. 使用下列命令來刪除 `jupyter-notebook` Pod：

   ```
   kubectl delete pod jupyter-notebook -n namespace
   ```

1. 然後，使用 `delete-managed-endpoint` 命令刪除互動端點。如需有關刪除互動端點的步驟，請參閱 [刪除互動端點](delete-managed-endpoint.md)。最初，您的端點將處於 **TERMINATING** 狀態。清除所有資源後，它會轉換為 **TERMINATED** 狀態。

1. 如果不打算將您在 [建立安全群組](#managed-endpoints-self-hosted-security) 中建立的筆記本安全群組用於其他 Jupyter 筆記本部署，則可以將其刪除。如需詳細資訊，請參閱《Amazon EC2 使用者指南》中的[刪除安全群組](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group)。

# 使用 CLI 命令取得互動式端點的相關資訊
<a name="other-operations"></a>

本主題涵蓋除了 [`create-managed-endpoint`](create-managed-endpoint.md) 之外的互動端點上的受支援操作。

## 擷取互動端點詳細資訊
<a name="fetch-details"></a>

建立互動式端點之後，您可以使用 `describe-managed-endpoint` AWS CLI 命令擷取其詳細資訊。插入您自己的 *managed-endpoint-id*、*virtual-cluster-id* 以及 *region* 的值：

```
aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \
 ‐‐virtual-cluster-id virtual-cluster-id ‐‐region region
```

輸出看起來類似於以下內容，包含指定的端點，例如 ARN、ID 和名稱。

```
{
   "id": "as3ys2xxxxxxx",
   "name": "endpoint-name",
    "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx",
    "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx",
    "type": "JUPYTER_ENTERPRISE_GATEWAY",
    "state": "ACTIVE",
    "releaseLabel": "emr-6.9.0-latest",
   "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName",
    "certificateAuthority": {
        "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb",
        "certificateData": "certificate-data"
    },
    "configurationOverrides": {
        "applicationConfiguration": [
            {
                "classification": "spark-defaults",
                "properties": {
                    "spark.driver.memory": "8G"
                }
            }
        ],
        "monitoringConfiguration": {
            "persistentAppUI": "ENABLED",
            "cloudWatchMonitoringConfiguration": {
                "logGroupName": "log-group-name",
                "logStreamNamePrefix": "log-stream-name-prefix"
            },
            "s3MonitoringConfiguration": {
                "logUri": "s3-bucket-name"
            }
        }
    },
   "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)",
    "createdAt": "2022-09-19T12:37:49+00:00",
    "securityGroup": "sg-aaaaaaaaaaaaaa",
    "subnetIds": [
        "subnet-11111111111",
        "subnet-22222222222",
        "subnet-33333333333"
    ],
    "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds",
    "tags": {}
 }
```

## 列出與虛擬叢集關聯的所有互動端點
<a name="list-all-managed-endpoints"></a>

使用 `list-managed-endpoints` AWS CLI 命令來擷取與指定虛擬叢集相關聯的所有互動式端點清單。將 `virtual-cluster-id` 取代為虛擬叢集 ID。

```
aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id
```

`list-managed-endpoint` 命令的輸出如下所示：

```
{
    "endpoints": [{
        "id": "as3ys2xxxxxxx",
        "name": "endpoint-name",
        "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx",
        "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx",
        "type": "JUPYTER_ENTERPRISE_GATEWAY",
        "state": "ACTIVE",
        "releaseLabel": "emr-6.9.0-latest",
        "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName",
        "certificateAuthority": {
            "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb",
            "certificateData": "certificate-data"
        },
        "configurationOverrides": {
            "applicationConfiguration": [{
                "classification": "spark-defaults",
                "properties": {
                    "spark.driver.memory": "8G"
                }
            }],
            "monitoringConfiguration": {
                "persistentAppUI": "ENABLED",
                "cloudWatchMonitoringConfiguration": {
                    "logGroupName": "log-group-name",
                    "logStreamNamePrefix": "log-stream-name-prefix"
                },
                "s3MonitoringConfiguration": {
                    "logUri": "s3-bucket-name"
                }
            }
        },
        "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)",
        "createdAt": "2022-09-19T12:37:49+00:00",
        "securityGroup": "sg-aaaaaaaaaaaaaa",
        "subnetIds": [
            "subnet-11111111111",
            "subnet-22222222222",
            "subnet-33333333333"
        ],
        "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds",
        "tags": {}
    }]
}
```

# 刪除互動端點
<a name="delete-managed-endpoint"></a>

若要刪除與 Amazon EMR on EKS 虛擬叢集相關聯的互動式端點，請使用 `delete-managed-endpoint` AWS CLI 命令。刪除互動端點時，Amazon EMR on EKS 會移除為該端點建立的預設安全群組。

為命令指定下列參數的值：
+ **‐‐id:** 您要刪除之互動端點的識別符。
+ **‐‐virtual-cluster-id** – 與您要刪除之互動端點相關聯的虛擬叢集識別符。這與建立互動端點時指定的虛擬叢集 ID 相同。

```
aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id
```

該命令會傳回類似以下內容的輸出，以確認您已刪除互動端點：

```
{
    "id":"8gai4l4exxxxx",
    "virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx"
}
```