

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 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 Notebook 사용](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
+ Kubernetes 기반 PySpark
+ 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 대화형 엔드포인트** - *대화형 엔드포인트*는 EMR Studio 사용자가 Workspace를 연결할 수 있는 HTTPS 엔드포인트입니다. EMR Studio에서만 HTTPS 엔드포인트에 액세스할 수 있으며, Amazon EKS 클러스터에 대한 Amazon Virtual Private Cloud(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는 대화형 엔드포인트와 같은 Kubernetes 서비스를 Amazon EKS 클러스터 외부에서 동일한 Amazon VPC 내에 노출합니다. 대화형 엔드포인트를 생성하면 대화형 클라이언트가 연결할 수 있도록 ALB를 통해 대화형 엔드포인트를 노출하는 Ingress 리소스도 배포됩니다. 각 Amazon EKS 클러스터에 대해 하나의 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/ko_kr/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 이상을 사용하는 경우 0.117.0 이상의 eksctl 버전을 사용합니다.

## 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 Workspace에 옵션으로 나타나고 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 EMR on 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>

Amazon EMR on EKS 대화형 엔드포인트에서 워크로드를 실행하려면 IAM 역할을 생성해야 합니다. 이 설명서에서는 이 IAM 역할을 *작업 실행 역할*이라고 합니다. 이 IAM 역할은 대화형 엔드포인트 컨테이너와 EMR Studio에서 작업을 제출할 때 생성되는 실제 실행 컨테이너 모두에 할당됩니다. Amazon EMR on EKS 클러스터에 대해 작업 실행 역할의 Amazon 리소스 이름(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 클러스터에는 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. 다음 JSON 파일에 표시된 대로 `create-managed-endpoint-request.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. 로컬로 저장되었거나 Amazon S3에 저장된 `create-managed-endpoint-request.json` 파일 경로와 함께 `create-managed-endpoint` 명령을 사용합니다.

   ```
   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 리소스 이름(ARN)입니다.

**`‐‐release-label`**  
엔드포인트에 사용할 Amazon EMR 릴리스의 릴리스 레이블입니다. 예를 들어 `emr-6.9.0-latest`입니다. Amazon EMR on EKS는 Amazon EMR 릴리스 6.7.0 이상에서 대화형 엔드포인트를 지원합니다.

### 대화형 엔드포인트의 선택적 파라미터
<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>

이 섹션에는 대화형 엔드포인트 및 포드 설정에 대한 다양한 구성을 다루는 일련의 주제가 포함되어 있습니다. 이를 통해 장애를 모니터링하고 문제를 해결하거나, Amazon S3 또는 로 로그 정보를 보내거나 Amazon CloudWatch Logs, 사용자 지정 포드 템플릿을 지정하는 대화형 엔드포인트를 생성할 수 있습니다.

**Topics**
+ [Spark 작업 모니터링](monitoring-spark-jobs.md)
+ [대화형 엔드포인트가 있는 사용자 지정 포드 템플릿 지정](custom-pod-templates.md)
+ [JEG 포드를 노드 그룹에 배포](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 대화형 엔드포인트에서 Amazon EMR로 시작하는 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 버킷에 업로드하지 않습니다.

# 대화형 엔드포인트가 있는 사용자 지정 포드 템플릿 지정
<a name="custom-pod-templates"></a>

드라이버와 실행기의 사용자 지정 포드 템플릿을 지정하는 대화형 엔드포인트를 생성할 수 있습니다. *포드 템플릿*은 각 포드의 실행 방법을 결정하는 사양입니다. 포드 템플릿 파일을 사용하여 Spark 구성이 지원하지 않는 드라이버 또는 실행기 포드 구성을 정의할 수 있습니다. 포드 템플릿은 현재 Amazon EMR 릴리스 6.3.0 이상에서 지원됩니다.

포드 템플릿에 대한 자세한 내용은 *Amazon EMR on EKS 개발 안내서*에서 [포드 템플릿 사용](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html)을 참조하세요.

다음 예제에서는 포드 템플릿을 사용해 대화형 엔드포인트를 생성하는 방법을 보여줍니다.

```
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 포드를 노드 그룹에 배포
<a name="managed-endpoint-nodegroups-setup"></a>

Jupyter Enterprise Gateway(JEG) 포드 배치는 특정 노드 그룹에 대화형 엔드포인트를 배포할 수 있는 기능입니다. 이 기능을 사용하여 대화형 엔드포인트에 대해 `instance type`과 같은 설정을 구성할 수 있습니다.

## 관리형 노드 그룹에 JEG 포드 연결
<a name="associate-jegpod-to-nodegroup"></a>

다음 구성 속성을 사용하면 JEG 포드가 배포될 Amazon EKS 클러스터의 관리형 노드 그룹 이름을 지정할 수 있습니다.

```
//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "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. 다음 명령을 사용하여 관리형 노드 그룹 `NodeGroupName`의 모든 노드에 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 레이블을 추가합니다.

   ```
   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 포드 연결
<a name="associate-jegpod-to-self-managed-nodegroup"></a>

다음 구성 속성을 사용하면 JEG 포드가 배포될 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`을 사용하여 자체 관리형 노드 그룹을 생성한 경우 다음 명령을 사용하여 자체 관리형 노드 그룹 `NodeGroupName`의 모든 노드에 `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes 레이블을 한 번에 추가합니다.

   ```
   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 Management Console에서 보안 그룹에 태그를 연결합니다.

1. Amazon EC2 콘솔로 이동합니다. 왼쪽 탐색 창에서 **보안 그룹**을 선택합니다.

1. 자체 관리형 노드 그룹의 보안 그룹 옆에 있는 확인란을 선택합니다.

1. **태그** 탭에서 **태그 관리** 버튼을 사용하여 `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` 태그를 추가합니다. `ClusterName` 및 `NodeGroupName`을 적절한 값으로 바꿉니다.

## 온디맨드 인스턴스가 있는 관리형 노드 그룹에 JEG 포드 연결
<a name="associate-jegpod-to-on-demand-instances"></a>

또한 *Kubernetes 레이블 선택기*라고 하는 추가 레이블을 정의하여 지정된 노드 또는 노드 그룹에서 대화형 엔드포인트를 실행하기 위한 추가 제약 또는 제한을 지정할 수 있습니다. 다음 예제에서는 JEG 포드에 대한 온디맨드 Amazon EC2 인스턴스를 사용하는 방법을 보여줍니다.

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

**참고**  
`managed-nodegroup-name` 또는 `self-managed-nodegroup-name` 속성 중 하나와 함께만 `node-labels` 속성을 사용할 수 있습니다.

# 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부터 Amazon EMR Studio에서는 EMR 노트북 셀에서 `%%configure` 매직 명령을 실행하여 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
  }
}
```

다음 예제에서는 Spark 런타임에 파일, pyFiles 및 jar 종속 항목을 추가하는 데 사용할 수 있는 샘플 페이로드를 보여줍니다.

```
%%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에서 대화형 워크로드를 실행할 때 애플리케이션에 대한 올바른 종속 항목을 확보하기 위해 대화형 엔드포인트에 맞게 도커 이미지를 사용자 지정하고 사용자 지정된 기본 커널 이미지를 실행할 수 있습니다. 대화형 엔드포인트를 나열하려면 사용자 지정 도커 이미지에 연결하려면 다음 단계를 수행합니다.

**참고**  
기본 이미지만 재정의할 수 있습니다. 새 커널 이미지 유형을 추가할 수 없습니다.

1. **사용자 지정된 도커 이미지를 생성 및 게시**합니다. 기본 이미지에는 Spark 런타임 및 이와 함께 실행되는 노트북 커널이 포함되어 있습니다. 이미지를 생성하려면 [도커 이미지를 사용자 지정하는 방법](docker-custom-images-steps.md)의 1단계\$14단계를 수행하면 됩니다. 1단계에서는 Docker 파일의 기본 이미지 URI는 `spark` 대신 `notebook-spark`를 사용해야 합니다.

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

    AWS 리전 및 컨테이너 이미지 태그를 선택하는 방법에 대한 자세한 내용은 섹션을 참조하세요[기본 이미지 URI 선택에 관한 세부 정보](docker-custom-images-tag.md).

1. **사용자 지정 이미지와 함께 사용할 수 있는 대화형 엔드포인트를 생성합니다.**

   1. 다음 콘텐츠를 포함하는 `custom-image-managed-endpoint.json` 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 Notebook과 같은 대화형 클라이언트에 의해 트리거됩니다. 대화형 엔드포인트에서 지원하는 각 작업에는 연결된 지표가 있습니다. 작업은 아래 테이블에서와 같이 각 지표에 대한 차원으로 모델링됩니다. 대화형 엔드포인트에서 생성된 지표는 계정의 사용자 지정 네임스페이스인 EMRContainers에서 볼 수 있습니다.


| 지표 | 설명 | 단위 | 
| --- | --- | --- | 
|  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 Notebook 사용
<a name="managed-endpoints-self-hosted"></a>

Jupyter 또는 JupyterLab 노트북을 Amazon EC2 인스턴스 또는 자체 Amazon EKS 클러스터에서 *자체 호스팅 Jupyter Notebook*으로 호스팅하고 관리할 수 있습니다. 그런 다음 자체 호스팅 Jupyter Notebook으로 대화형 워크로드를 실행할 수 있습니다. 다음 섹션에서는 Amazon EKS 클러스터에 자체 호스팅 Jupyter Notebook을 설정하고 배포하는 프로세스를 안내합니다.



**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 Notebook 삭제](#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)을 참조하세요.

다음 단계에서 [Amazon EMR on EKS 대화형 엔드포인트를 생성](https://docs.aws.amazon.com/)하려면 보안 그룹의 ID가 필요합니다.

## Amazon EMR on EKS 대화형 엔드포인트 생성
<a name="managed-endpoints-self-hosted-create-me"></a>

노트북용 보안 그룹을 생성한 후에는 [가상 클러스터의 대화형 엔드포인트 생성](create-managed-endpoint.md)에 제공된 단계를 사용하여 대화형 엔드포인트를 생성합니다. [보안 그룹 생성](#managed-endpoints-self-hosted-security)에서 노트북용으로 생성한 보안 그룹 ID를 제공해야 합니다.

다음 구성 재정의 설정에서 *your-notebook-security-group-id* 위치에 보안 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>

위 단계를 완료했으면 이 예제 절차를 시도하여 대화형 엔드포인트가 있는 Amazon EKS 클러스터에 JupyterLab 노트북을 배포할 수 있습니다.

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 Notebook을 FarGate 전용 클러스터에 배포하는 경우 다음 예제와 같이 Jupyter 포드에 `role` 레이블을 지정합니다.

   ```
   ...
   metadata:
     name: jupyter-notebook
     namespace: default
     labels:
       role: example-role-name-label
   spec:
               ...
   ```  
**`namespace`**  
노트북을 배포할 Kubernetes 네임스페이스.  
**`serverUrl`**  
[대화형 엔드포인트의 게이트웨이 서버 URL 검색](#managed-endpoints-self-hosted-gateway)에서 `describe-managed-endpoint` 명령이 반환한 `serverUrl` 속성.  
**`session-token`**  
[인증 토큰을 검색하여 대화형 엔드포인트에 연결](#managed-endpoints-self-hosted-auth)에서 `get-managed-endpoint-session-credentials` 명령이 반환한 `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. Amazon EKS 클러스터에 포드 사양을 배포합니다.

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

   그러면 Amazon EMR on EKS 대화형 엔드포인트에 연결된 최소 JupyterLab Notebook이 시작됩니다. 포드가 **RUNNING** 상태가 될 때까지 기다립니다. 다음 명령을 실행하여 상태를 확인할 수 있습니다.

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

   포드가 준비되면 `get pod` 명령은 다음과 비슷한 출력을 반환합니다.

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

1. 노트북 보안 그룹을 노트북이 예약된 노드에 연결합니다.

   1. 먼저 `describe pod` 명령을 사용하여 `jupyter-notebook` 포드가 예약된 노드를 식별합니다.

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

   1. [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters)에서 Amazon EKS 콘솔을 엽니다.

   1. Amazon EKS 클러스터의 **컴퓨팅** 탭으로 이동하여 `describe pod` 명령으로 식별되는 노드를 선택합니다. 노드의 인스턴스 ID를 선택합니다.

   1. **작업** 메뉴에서 **보안** > **보안 그룹 변경**을 선택하여 [보안 그룹 생성](#managed-endpoints-self-hosted-security)에서 생성한 보안 그룹을 연결합니다.

   1. Jupyter 노트북 포드를 배포[]()하는 경우 역할 레이블을 사용하여 Jupyter 노트북 포드에 적용할를 AWS Fargate생성합니다.

      ```
      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. 이제 JupyterLab 인터페이스에 로컬로 액세스할 수 있도록 포트 전달을 수행합니다.

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

   실행이 완료되면 로컬 브라우저로 이동하여 `localhost:8888`에서 JupyterLab 인터페이스를 확인합니다.  
![\[JupyterLab 시작 화면 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)

## 자체 호스팅 Jupyter Notebook 삭제
<a name="managed-endpoints-self-hosted-cleanup"></a>

자체 호스팅 노트북을 삭제할 준비가 되면 대화형 엔드포인트와 보안 그룹도 삭제할 수 있습니다. 다음 순서대로 작업을 수행합니다.

1. 다음 명령을 사용하여 `jupyter-notebook` 포드를 삭제합니다.

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

1. 그런 다음 `delete-managed-endpoint` 명령을 사용하여 대화형 엔드포인트를 삭제합니다. 대화형 엔드포인트를 삭제하는 단계는 [대화형 엔드포인트 삭제](delete-managed-endpoint.md) 섹션을 참조하세요. 처음에는 엔드포인트가 **TERMINATING** 상태가 됩니다. 모든 리소스가 정리되면 **TERMINATED** 상태로 전환됩니다.

1. [보안 그룹 생성](#managed-endpoints-self-hosted-security)에서 생성한 노트북 보안 그룹을 다른 Jupyter Notebook 배포에 사용할 계획이 없다면 삭제할 수 있습니다. 자세한 내용은 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"
}
```