Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menjalankan beban kerja interaktif di Amazon EMR di EKS
*Endpoint interaktif* adalah gateway yang menghubungkan Amazon EMR Studio ke Amazon EMR di EKS sehingga Anda dapat menjalankan beban kerja interaktif. [Anda dapat menggunakan endpoint interaktif dengan EMR Studio untuk menjalankan analisis interaktif dengan kumpulan data di penyimpanan data seperti Amazon [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) dan Amazon DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/)
**Kasus penggunaan**
+ Buat skrip ETL dengan pengalaman EMR Studio IDE. IDE menyerap data lokal dan menyimpannya di Amazon S3 setelah transformasi untuk analisis selanjutnya.
+ Gunakan buku catatan untuk menjelajahi kumpulan data dan melatih model pembelajaran mesin untuk mendeteksi anomali dalam kumpulan data.
+ Buat skrip yang menghasilkan laporan harian untuk aplikasi analitik seperti dasbor bisnis.
**Topics**
+ [Ikhtisar titik akhir interaktif](how-it-works.md)
+ [Prasyarat untuk membuat titik akhir interaktif di Amazon EMR di EKS](prereqs-for-studio.md)
+ [Membuat endpoint interaktif untuk klaster virtual Anda](create-managed-endpoint.md)
+ [Mengkonfigurasi pengaturan untuk titik akhir interaktif](managed-endpoint-parameters.md)
+ [Memantau titik akhir interaktif](managed-endpoints-customer-metrics.md)
+ [Menggunakan notebook Jupyter yang dihosting sendiri](managed-endpoints-self-hosted.md)
+ [Mendapatkan informasi tentang titik akhir interaktif dengan perintah CLI](other-operations.md)
# Ikhtisar titik akhir interaktif
*Endpoint interaktif* menyediakan kemampuan untuk klien interaktif seperti Amazon EMR Studio untuk terhubung ke Amazon EMR pada kluster EKS untuk menjalankan beban kerja interaktif. Endpoint interaktif didukung oleh Jupyter Enterprise Gateway yang menyediakan kemampuan manajemen siklus hidup kernel jarak jauh yang dibutuhkan klien interaktif. *Kernel* adalah proses khusus bahasa yang berinteraksi dengan klien Amazon EMR Studio berbasis Jupyter untuk menjalankan beban kerja interaktif.
Endpoint interaktif mendukung kernel berikut:
+ Python 3
+ PySpark di Kubernetes
+ Apache Spark dengan Scala
**catatan**
Amazon EMR pada harga EKS berlaku untuk titik akhir dan kernel interaktif. Untuk informasi lebih lanjut, lihat halaman [harga Amazon EMR di EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS).
Entitas berikut diperlukan agar EMR Studio terhubung dengan Amazon EMR di EKS.
+ **Amazon EMR di kluster virtual EKS — Cluster** *virtual* adalah namespace Kubernetes tempat Anda mendaftarkan EMR Amazon. Amazon EMR menggunakan klaster virtual untuk menjalankan tugas dan meng-host titik akhir. Anda dapat mendukung beberapa cluster virtual dengan cluster fisik yang sama. Namun, setiap cluster virtual memetakan ke satu namespace di cluster Amazon EKS. Cluster virtual tidak membuat sumber daya aktif apa pun yang berkontribusi pada tagihan Anda atau yang memerlukan manajemen siklus hidup di luar layanan.
+ **Amazon EMR pada titik akhir interaktif EKS - Titik akhir** *interaktif adalah titik akhir* HTTPS tempat pengguna EMR Studio dapat menghubungkan ruang kerja. Anda hanya dapat mengakses titik akhir HTTPS dari EMR Studio Anda, dan Anda membuatnya di subnet pribadi Amazon Virtual Private Cloud (Amazon VPC) untuk kluster Amazon EKS Anda.
Kernel Python, PySpark, dan Spark Scala menggunakan izin yang ditentukan dalam EMR Amazon Anda pada peran eksekusi pekerjaan EKS untuk memanggil yang lain. Layanan AWS Semua kernel dan pengguna yang terhubung ke endpoint interaktif menggunakan peran yang Anda tentukan saat membuat endpoint. Kami menyarankan Anda membuat titik akhir terpisah untuk pengguna yang berbeda, dan bahwa pengguna memiliki peran AWS Identity and Access Management (IAM) yang berbeda.
+ AWS Pengontrol **Application Load Balancer — Pengontrol AWS ** *Application Load Balancer* mengelola Elastic Load Balancing untuk klaster Amazon EKS Kubernetes. Controller menyediakan Application Load Balancer (ALB) saat Anda membuat resource Kubernetes Ingress. ALB mengekspos layanan Kubernetes, seperti endpoint interaktif, di luar klaster Amazon EKS tetapi dalam VPC Amazon yang sama. Saat Anda membuat titik akhir interaktif, sumber daya Ingress juga digunakan yang mengekspos titik akhir interaktif melalui ALB untuk terhubung dengan klien interaktif. Anda hanya perlu menginstal satu AWS Application Load Balancer controller untuk setiap cluster Amazon EKS.
Diagram berikut menggambarkan arsitektur endpoint interaktif di Amazon EMR di EKS. *Cluster Amazon EKS terdiri dari *komputasi* untuk menjalankan beban kerja analitik, dan titik akhir interaktif.* Pengontrol Application Load Balancer berjalan di `kube-system` namespace; beban kerja dan endpoint interaktif berjalan di namespace yang Anda tentukan saat Anda membuat cluster virtual. Saat Anda membuat titik akhir interaktif, EMR Amazon pada bidang kontrol EKS membuat penerapan titik akhir interaktif di klaster Amazon EKS. Selain itu, instance dari ingress penyeimbang beban aplikasi dibuat oleh pengontrol penyeimbang AWS beban. Penyeimbang beban aplikasi menyediakan antarmuka eksternal untuk klien seperti EMR Studio untuk terhubung ke cluster EMR Amazon dan menjalankan beban kerja interaktif.
![\[Diagram arsitektur titik akhir interaktif\]](http://docs.aws.amazon.com/id_id/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png)
# Prasyarat untuk membuat titik akhir interaktif di Amazon EMR di EKS
Bagian ini menjelaskan prasyarat untuk menyiapkan titik akhir interaktif yang dapat digunakan EMR Studio untuk terhubung ke EMR Amazon di kluster EKS dan menjalankan beban kerja interaktif.
## AWS CLI
Ikuti langkah-langkah di [Instal atau perbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) untuk menginstal versi terbaru dari AWS Command Line Interface (AWS CLI).
## Instalasi eksctl
Ikuti langkah-langkah di [Install kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) untuk menginstal versi terbaru eksctl. Jika Anda menggunakan Kubernetes versi 1.22 atau yang lebih baru untuk klaster Amazon EKS Anda, gunakan versi eksctl yang lebih besar dari 0.117.0.
## Kluster Amazon EKS
Buat klaster Amazon EKS. Daftarkan cluster sebagai cluster virtual dengan Amazon EMR di EKS. Berikut ini adalah persyaratan dan pertimbangan untuk cluster ini:
+ Cluster harus berada di Amazon Virtual Private Cloud (VPC) yang sama dengan EMR Studio Anda.
+ Cluster harus memiliki setidaknya satu subnet pribadi untuk mengaktifkan endpoint interaktif, untuk menautkan repositori berbasis Git, dan untuk meluncurkan Application Load Balancer dalam mode pribadi.
+ Harus ada minimal satu subnet privat yang sama antara EMR Studio Anda dan klaster Amazon EKS yang Anda gunakan untuk mendaftarkan klaster virtual Anda. Ini memastikan bahwa endpoint interaktif Anda muncul sebagai opsi di ruang kerja Studio Anda, dan mengaktifkan konektivitas dari Studio ke Application Load Balancer.
Ada dua metode yang dapat Anda pilih untuk menghubungkan Studio dan kluster Amazon EKS Anda:
+ Buat klaster Amazon EKS dan kaitkan dengan subnet milik EMR Studio Anda.
+ Atau, buat EMR Studio dan tentukan subnet pribadi untuk klaster Amazon EKS Anda.
+ Amazon EKS dioptimalkan ARM Amazon Linux tidak AMIs didukung untuk Amazon EMR pada titik akhir interaktif EKS.
+ Hanya [grup node terkelola Amazon EKS dan node](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html) yang disediakan Karpenter yang didukung.
## Berikan akses Cluster untuk Amazon EMR di EKS
Gunakan langkah-langkah dalam [Grant Cluster Access untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html) untuk memberikan Amazon EMR di EKS akses ke namespace tertentu di cluster Anda.
## Aktifkan IRSA di cluster Amazon EKS
Untuk mengaktifkan peran IAM untuk Akun Layanan (IRSA) di klaster Amazon EKS, ikuti langkah-langkah di [Aktifkan Peran IAM untuk Akun Layanan (](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html)IRSA).
## Buat peran eksekusi pekerjaan IAM
Anda harus membuat peran IAM untuk menjalankan beban kerja di Amazon EMR pada titik akhir interaktif EKS. Kami menyebut peran IAM ini sebagai *peran eksekusi pekerjaan* dalam dokumentasi ini. Peran IAM ini akan ditetapkan ke wadah endpoint interaktif dan kontainer eksekusi aktual yang dibuat saat Anda mengirimkan pekerjaan dengan EMR Studio. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran eksekusi pekerjaan Anda untuk Amazon EMR di EKS. Ada dua langkah yang diperlukan untuk ini:
+ [Buat peran IAM untuk eksekusi pekerjaan.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)
+ [Perbarui kebijakan kepercayaan dari peran eksekusi pekerjaan.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html)
## Memberikan pengguna akses ke Amazon EMR di EKS
Entitas IAM (pengguna atau peran) yang membuat permintaan untuk membuat titik akhir interaktif juga harus memiliki Amazon `emr-containers` EC2 dan izin berikut. Ikuti langkah-langkah yang dijelaskan [Memberikan pengguna akses ke Amazon EMR di EKS](setting-up-iam.md) untuk memberikan izin ini yang memungkinkan Amazon EMR di EKS membuat, mengelola, dan menghapus grup keamanan yang membatasi lalu lintas masuk ke penyeimbang beban titik akhir interaktif Anda.
`emr-containers`Izin berikut memungkinkan pengguna untuk melakukan operasi endpoint interaktif dasar:
```
"ec2:CreateSecurityGroup",
"ec2:DeleteSecurityGroup",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress"
"emr-containers:CreateManagedEndpoint",
"emr-containers:ListManagedEndpoints",
"emr-containers:DescribeManagedEndpoint",
"emr-containers:DeleteManagedEndpoint"
```
## Daftarkan klaster Amazon EKS dengan Amazon EMR
Siapkan cluster virtual dan petakan ke namespace di klaster Amazon EKS tempat Anda ingin menjalankan pekerjaan Anda. Untuk cluster AWS Fargate-only, gunakan namespace yang sama untuk EMR Amazon di klaster virtual EKS dan profil Fargate.
Untuk informasi tentang pengaturan EMR Amazon di kluster virtual EKS, lihat. [Daftarkan klaster Amazon EKS dengan Amazon EMR](setting-up-registration.md)
## Menerapkan AWS Load Balancer Controller ke klaster Amazon EKS
AWS Application Load Balancer diperlukan untuk klaster Amazon EKS Anda. Anda hanya perlu menyiapkan satu pengontrol Application Load Balancer per kluster Amazon EKS. Untuk informasi tentang cara menyiapkan pengontrol AWS Application Load Balancer, lihat [Menginstal add-on Load AWS Balancer Controller di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) Pengguna *Amazon EKS*.
# Membuat endpoint interaktif untuk klaster virtual Anda
Topik ini menjelaskan beberapa cara untuk membuat endpoint interaktif menggunakan AWS Command Line Interface (AWS CLI) dan menyertakan detail tentang parameter konfigurasi yang tersedia.
## Buat endpoint interaktif dengan perintah `create-managed-endpoint`
Tentukan parameter dalam `create-managed-endpoint` perintah sebagai berikut. Amazon EMR di EKS mendukung pembuatan endpoint interaktif dengan Amazon EMR rilis 6.7.0 dan yang lebih tinggi.
```
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"
}
}
}'
```
Untuk informasi selengkapnya, lihat [Parameter untuk membuat endpoint interaktif](#parameters-for-creating).
## Buat endpoint interaktif dengan parameter tertentu dalam file JSON
1. Buat `create-managed-endpoint-request.json` file dan tentukan parameter yang diperlukan untuk titik akhir Anda, seperti yang ditunjukkan pada file JSON berikut:
```
{
"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. Gunakan `create-managed-endpoint` perintah dengan jalur ke `create-managed-endpoint-request.json` file yang disimpan secara lokal atau di Amazon S3.
```
aws emr-containers create-managed-endpoint \
‐‐cli-input-json file://./create-managed-endpoint-request.json ‐‐region AWS-Region
```
## Output dari membuat endpoint interaktif
Anda akan melihat output berikut di terminal. Outputnya mencakup nama dan pengenal titik akhir interaktif baru Anda:
```
{
"id": "1234567890abcdef0",
"name": "example-endpoint-name",
"arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666",
"virtualClusterId": "111122223333xxxxxxxx"
}
```
Running `aws emr-containers create-managed-endpoint` membuat sertifikat yang ditandatangani sendiri yang memungkinkan komunikasi HTTPS antara EMR Studio dan server endpoint interaktif.
Jika Anda menjalankan `create-managed-endpoint` dan belum menyelesaikan prasyarat, Amazon EMR mengembalikan pesan kesalahan dengan tindakan yang harus Anda ambil untuk melanjutkan.
## Parameter untuk membuat endpoint interaktif
**Topics**
+ [Parameter yang diperlukan untuk titik akhir interaktif](#parameters-for-creating-required)
+ [Parameter opsional untuk titik akhir interaktif](#parameters-for-creating-optional)
### Parameter yang diperlukan untuk titik akhir interaktif
Anda harus menentukan parameter berikut saat membuat endpoint interaktif:
**`‐‐type`**
Gunakan `JUPYTER_ENTERPRISE_GATEWAY`. Ini adalah satu-satunya jenis yang didukung.
**`‐‐virtual-cluster-id`**
Pengidentifikasi cluster virtual yang Anda daftarkan dengan Amazon EMR di EKS.
**`‐‐name`**
Nama deskriptif untuk endpoint interaktif yang membantu pengguna EMR Studio memilihnya dari daftar dropdown.
**`‐‐execution-role-arn`**
Nama Sumber Daya Amazon (ARN) dari peran eksekusi pekerjaan IAM Anda untuk Amazon EMR di EKS yang dibuat sebagai bagian dari prasyarat.
**`‐‐release-label`**
Label rilis rilis EMR Amazon untuk digunakan untuk titik akhir. Misalnya, `emr-6.9.0-latest`. Amazon EMR di EKS mendukung endpoint interaktif dengan Amazon EMR rilis 6.7.0 dan lebih tinggi.
### Parameter opsional untuk titik akhir interaktif
Secara opsional, Anda juga dapat menentukan parameter berikut saat membuat endpoint interaktif:
**`‐‐configuration-overrides`**
Untuk mengganti konfigurasi default untuk aplikasi, berikan objek coonfiguration. Anda dapat menggunakan sintaks singkatan untuk menyediakan konfigurasi, atau Anda dapat mereferensikan objek konfigurasi dalam file JSON.
Objek konfigurasi terdiri dari klasifikasi, properti, dan konfigurasi bersarang opsional. Properti terdiri dari pengaturan yang ingin Anda timpa dalam file itu. Anda dapat menentukan beberapa klasifikasi untuk beberapa aplikasi dalam objek JSON tunggal. Klasifikasi konfigurasi yang tersedia bervariasi menurut Amazon EMR pada rilis EKS. Untuk daftar klasifikasi konfigurasi yang tersedia untuk setiap rilis Amazon EMR di EKS, lihat. [Amazon EMR pada rilis EKS](emr-eks-releases.md) Selain klasifikasi konfigurasi yang terdaftar untuk setiap rilis, titik akhir interaktif membawa klasifikasi tambahan. `jeg-config` Untuk informasi selengkapnya, lihat [Opsi konfigurasi Jupyter Enterprise Gateway (JEG)](jeg-config-options.md).
# Mengkonfigurasi pengaturan untuk titik akhir interaktif
Bagian ini berisi serangkaian topik yang mencakup berbagai konfigurasi untuk titik akhir interaktif dan pengaturan pod. Ini memberi Anda kemampuan untuk memantau dan memecahkan masalah kegagalan, mengirim informasi log ke Amazon S3 atau ke, atau Amazon CloudWatch Logs untuk membuat titik akhir interaktif tempat Anda menentukan templat pod kustom.
**Topics**
+ [Lowongan kerja Monitoring Spark](monitoring-spark-jobs.md)
+ [Menentukan template pod kustom dengan endpoint interaktif](custom-pod-templates.md)
+ [Menerapkan pod JEG ke grup node](managed-endpoint-nodegroups-setup.md)
+ [Opsi konfigurasi Jupyter Enterprise Gateway (JEG)](jeg-config-options.md)
+ [Memodifikasi PySpark parameter sesi](modify-pyspark-parameters.md)
+ [Gambar kernel kustom dengan endpoint interaktif](custom-kernel.md)
# Lowongan kerja Monitoring Spark
Agar Anda dapat memantau dan memecahkan masalah kegagalan, konfigurasikan titik akhir interaktif Anda sehingga pekerjaan yang dimulai dengan titik akhir dapat mengirim informasi log ke Amazon S3, Amazon Log, atau keduanya. CloudWatch Bagian berikut menjelaskan cara mengirim log aplikasi Spark ke Amazon S3 untuk pekerjaan Spark yang Anda luncurkan dengan Amazon EMR di titik akhir interaktif EKS.
**Konfigurasikan kebijakan IAM untuk log Amazon S3**
Sebelum kernel Anda dapat mengirim data log ke Amazon S3, kebijakan izin untuk peran eksekusi pekerjaan harus menyertakan izin berikut. Ganti *amzn-s3-demo-destination-bucket* dengan nama bucket logging Anda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Sid": "AllowS3Putobject"
}
]
}
```
------
**catatan**
Amazon EMR di EKS juga dapat membuat bucket S3. Jika bucket S3 tidak tersedia, sertakan `s3:CreateBucket` izin tersebut dalam kebijakan IAM.
Setelah Anda memberikan izin pada peran eksekusi yang diperlukan untuk mengirim log ke bucket S3, data log Anda akan dikirim ke lokasi Amazon S3 berikut. Ini terjadi ketika `s3MonitoringConfiguration` diteruskan di `monitoringConfiguration` bagian `create-managed-endpoint` permintaan.
+ **Log driver** — `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)`
+ **Log pelaksana** — `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-/(stderr.gz/stdout.gz)`
**catatan**
Amazon EMR di EKS tidak mengunggah log titik akhir ke bucket S3 Anda.
# Menentukan template pod kustom dengan endpoint interaktif
Anda dapat membuat endpoint interaktif di mana Anda menentukan template pod kustom untuk driver dan pelaksana. *Template Pod* adalah spesifikasi yang menentukan cara menjalankan setiap pod. Anda dapat menggunakan file template pod untuk menentukan konfigurasi driver atau pod pelaksana yang tidak didukung oleh konfigurasi Spark. Template Pod saat ini didukung di Amazon EMR rilis 6.3.0 dan yang lebih baru.
Untuk informasi selengkapnya tentang template pod, lihat [Menggunakan templat pod](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html) di *Amazon EMR on EKS Development* Guide.
Contoh berikut menunjukkan cara membuat endpoint interaktif dengan template 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"
}
}]
}'
```
# Menerapkan pod JEG ke grup node
Penempatan pod JEG (Jupyter Enterprise Gateway) adalah fitur yang memungkinkan Anda untuk menerapkan endpoint interaktif pada grup node tertentu. Dengan fitur ini, Anda dapat mengonfigurasi pengaturan seperti `instance type` untuk titik akhir interaktif.
## Mengaitkan pod JEG ke grup node terkelola
Properti konfigurasi berikut memungkinkan Anda menentukan nama grup node terkelola di klaster Amazon EKS tempat pod JEG akan di-deploy.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Sebuah grup node harus memiliki label Kubernetes yang `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` melekat pada semua node yang merupakan bagian dari grup node. Untuk membuat daftar semua node dari grup node yang memiliki tag ini, gunakan perintah berikut:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Jika output dari perintah di atas tidak mengembalikan node yang merupakan bagian dari grup node terkelola Anda, maka tidak ada node dalam grup node yang memiliki label `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes terpasang. Dalam hal ini, ikuti langkah-langkah di bawah ini untuk melampirkan label tersebut ke node di grup node Anda.
1. Gunakan perintah berikut untuk menambahkan label `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes ke semua node dalam grup node terkelola: `NodeGroupName`
```
kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
1. Verifikasi bahwa node diberi label dengan benar menggunakan perintah berikut:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Grup node terkelola harus dikaitkan dengan grup keamanan klaster Amazon EKS, yang biasanya terjadi jika Anda membuat cluster dan grup node terkelola menggunakan`eksctl`. Anda dapat memverifikasi ini di AWS konsol menggunakan langkah-langkah berikut.
1. Buka cluster Anda di konsol Amazon EKS.
1. Buka tab jaringan cluster Anda dan catat grup keamanan cluster.
1. Buka tab komputasi klaster Anda dan klik pada nama grup node terkelola.
1. Di bawah tab **Detail** grup node terkelola, verifikasi bahwa grup keamanan klaster yang Anda catat sebelumnya terdaftar di bawah **Grup keamanan**.
Jika grup node terkelola tidak dilampirkan ke grup keamanan klaster Amazon EKS, Anda harus melampirkan `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` tag ke grup keamanan grup node. Gunakan langkah-langkah di bawah ini untuk melampirkan tag ini.
1. Buka konsol Amazon EC2 dan klik grup keamanan di panel navigasi kiri.
1. Pilih grup keamanan grup node terkelola Anda dengan mengklik kotak centang.
1. Di bawah tab **Tag**, tambahkan tag `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` menggunakan tombol **Kelola tag**.
## Mengaitkan pod JEG ke grup node yang dikelola sendiri
Properti konfigurasi berikut memungkinkan Anda menentukan nama grup node yang dikelola sendiri atau tidak dikelola di klaster Amazon EKS tempat pod JEG akan di-deploy.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"self-managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Grup node harus memiliki label `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes yang melekat pada semua node yang merupakan bagian dari grup node. Untuk membuat daftar semua node dari grup node yang memiliki tag ini, gunakan perintah berikut:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Jika output dari perintah di atas tidak mengembalikan node yang merupakan bagian dari grup node yang dikelola sendiri, maka tidak ada node di grup node yang memiliki label `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes yang terpasang. Dalam hal ini, ikuti langkah-langkah di bawah ini untuk melampirkan label tersebut ke node di grup node Anda.
1. Jika Anda membuat grup node yang dikelola sendiri menggunakan`eksctl`, maka gunakan perintah berikut untuk menambahkan label `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes ke semua node dalam grup node yang dikelola sendiri sekaligus. `NodeGroupName`
```
kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Jika Anda tidak menggunakannya `eksctl` untuk membuat grup node yang dikelola sendiri, maka Anda perlu mengganti pemilih pada perintah di atas ke label Kubernetes yang berbeda yang dilampirkan ke semua node dari grup node.
1. Gunakan perintah berikut untuk memverifikasi bahwa node diberi label dengan benar:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Grup keamanan untuk grup node yang dikelola sendiri harus memiliki `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` tag yang dilampirkan. Gunakan langkah-langkah berikut untuk melampirkan tag ke grup keamanan dari Konsol Manajemen AWS.
1. Arahkan ke konsol Amazon EC2. Pilih **Grup keamanan** di panel navigasi kiri.
1. Pilih kotak centang di samping grup keamanan untuk grup node yang dikelola sendiri.
1. Di bawah tab **Tag**, gunakan tombol **Kelola tag** untuk menambahkan tag`for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`. Ganti `ClusterName` dan `NodeGroupName` dengan nilai yang sesuai.
## Mengaitkan pod JEG ke grup node terkelola dengan instans On-Demand
Anda juga dapat menentukan label tambahan, yang dikenal sebagai *pemilih label Kubernetes*, untuk menentukan batasan atau batasan tambahan untuk menjalankan titik akhir interaktif pada node atau grup node tertentu. Contoh berikut menunjukkan cara menggunakan instans Amazon EC2 On-Demand untuk pod JEG.
```
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName,
"node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
}
}
]
}'
```
**catatan**
Anda hanya dapat menggunakan `node-labels` properti dengan `self-managed-nodegroup-name` properti `managed-nodegroup-name` atau properti.
# Opsi konfigurasi Jupyter Enterprise Gateway (JEG)
Amazon EMR di EKS menggunakan Jupyter Enterprise Gateway (JEG) untuk mengaktifkan endpoint interaktif. Anda dapat mengatur nilai berikut untuk konfigurasi JEG yang diizinkan saat Anda membuat titik akhir.
+ **`RemoteMappingKernelManager.cull_idle_timeout`**— Timeout dalam hitungan detik (integer), setelah itu kernel dianggap idle dan siap untuk dimusnahkan. Nilai `0` atau lebih rendah menonaktifkan pemusnahan. Batas waktu yang singkat dapat mengakibatkan kernel dimusnahkan untuk pengguna dengan koneksi jaringan yang buruk.
+ **`RemoteMappingKernelManager.cull_interval`**— Interval dalam detik (integer) untuk memeriksa kernel idle yang melebihi nilai batas waktu pemusnahan.
# Memodifikasi PySpark parameter sesi
Dimulai dengan Amazon EMR pada rilis EKS 6.9.0, di Amazon EMR Studio Anda dapat menyesuaikan konfigurasi Spark yang terkait dengan PySpark sesi dengan menjalankan perintah `%%configure` ajaib di sel notebook EMR.
Contoh berikut menunjukkan payload sampel yang dapat Anda gunakan untuk memodifikasi memori, core, dan properti lainnya untuk driver dan eksekutor Spark. Untuk `conf` pengaturan, Anda dapat mengonfigurasi konfigurasi Spark apa pun yang disebutkan dalam dokumentasi konfigurasi [Apache Spark](https://spark.apache.org/docs/latest/configuration.html).
```
%%configure -f
{
"driverMemory": "16G",
"driverCores": 4,
"executorMemory" : "32G",
"executorCores": 2,
"conf": {
"spark.dynamicAllocation.maxExecutors" : 10,
"spark.dynamicAllocation.minExecutors": 1
}
}
```
Contoh berikut menunjukkan contoh payload yang dapat Anda gunakan untuk menambahkan file, PyFiles, dan dependensi jar ke runtime Spark.
```
%%configure -f
{
"files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt",
"pyFiles": : "path-to-python-files",
"jars" : "path-to-jars
}
```
# Gambar kernel kustom dengan endpoint interaktif
Untuk memastikan bahwa Anda memiliki dependensi yang benar untuk aplikasi saat menjalankan beban kerja interaktif dari Amazon EMR Studio, Anda dapat menyesuaikan gambar Docker untuk titik akhir interaktif dan menjalankan image kernel dasar yang disesuaikan. Untuk membuat endpoint interaktif dan menghubungkannya dengan image Docker kustom, lakukan langkah-langkah berikut.
**catatan**
Anda hanya dapat mengganti gambar dasar. Anda tidak dapat menambahkan jenis gambar kernel baru.
1. **Buat dan publikasikan gambar Docker yang disesuaikan.** Gambar dasar berisi runtime Spark dan kernel notebook yang berjalan dengannya. Untuk membuat gambar, Anda dapat mengikuti langkah 1 hingga 4 in[Cara menyesuaikan gambar Docker](docker-custom-images-steps.md). Pada langkah 1, URI gambar dasar dalam file Docker Anda harus digunakan `notebook-spark` sebagai pengganti. `spark`
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Untuk informasi selengkapnya tentang cara memilih Wilayah AWS dan menampung tag gambar, lihat[Detail untuk memilih URI gambar dasar](docker-custom-images-tag.md).
1. **Buat endpoint interaktif yang dapat digunakan dengan gambar kustom.**
1. Buat file JSON `custom-image-managed-endpoint.json` dengan konten berikut. Contoh ini menggunakan Amazon EMR rilis 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. Buat endpoint interaktif dengan konfigurasi yang ditentukan dalam file JSON seperti yang ditunjukkan pada contoh berikut. Untuk informasi selengkapnya, lihat [Buat endpoint interaktif dengan perintah `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. **Connect ke endpoint interaktif melalui EMR Studio.** Untuk informasi selengkapnya dan langkah-langkah yang harus diselesaikan, lihat [Menghubungkan dari Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html) di bagian Amazon EMR di EKS pada dokumen AWS Workshop Studio.
# Memantau titik akhir interaktif
Dengan Amazon EMR di EKS versi 6.10 dan yang lebih baru, titik akhir interaktif memancarkan metrik CloudWatch Amazon untuk memantau dan memecahkan masalah operasi siklus hidup kernel. Metrik dipicu oleh klien interaktif, seperti EMR Studio atau notebook Jupyter yang dihosting sendiri. Setiap operasi yang didukung oleh endpoint interaktif memiliki metrik yang terkait dengannya. Operasi dimodelkan sebagai dimensi untuk setiap metrik, seperti yang ditunjukkan pada tabel di bawah ini. Metrik yang dipancarkan oleh titik akhir interaktif terlihat di bawah namespace khusus, di akun Anda. EMRContainers
| Metrik | Deskripsi | Unit |
| --- | --- | --- |
| RequestCount | Jumlah kumulatif permintaan operasi yang diproses oleh endpoint interaktif. | Hitungan |
| RequestLatency | Waktu dari ketika permintaan tiba di titik akhir interaktif dan respons dikirim oleh titik akhir interaktif. | Milidetik |
| 4 XXError | Dipancarkan ketika permintaan untuk operasi menghasilkan kesalahan 4xx selama pemrosesan. | Hitungan |
| 5 XXError | Dipancarkan saat permintaan operasi menghasilkan kesalahan sisi server 5Xxx. | Hitungan |
| KernelLaunchSuccess | Hanya berlaku untuk CreateKernel operasi. Ini menunjukkan jumlah kumulatif peluncuran kernel yang berhasil hingga dan termasuk permintaan ini. | Hitungan |
| KernelLaunchFailure | Hanya berlaku untuk CreateKernel operasi. Ini menunjukkan jumlah kumulatif kegagalan peluncuran kernel hingga dan termasuk permintaan ini. | Hitungan |
Setiap metrik endpoint interaktif memiliki dimensi berikut yang melekat padanya:
+ **`ManagedEndpointId`**— Pengidentifikasi untuk titik akhir interaktif
+ **`OperationName`**— Operasi yang dipicu oleh klien interaktif
Nilai yang mungkin untuk **`OperationName`**dimensi ditunjukkan pada tabel berikut:
| `operationName` | Deskripsi operasi |
| --- | --- |
| `CreateKernel` | Minta endpoint interaktif memulai kernel. |
| `ListKernels` | Minta agar titik akhir interaktif mencantumkan kernel yang sebelumnya telah dimulai menggunakan token sesi yang sama. |
| `GetKernel` | Minta agar endpoint interaktif mendapatkan detail tentang kernel tertentu yang telah dimulai sebelumnya. |
| `ConnectKernel` | Minta endpoint interaktif membangun konektivitas antara klien notebook dan kernel. |
| `ConfigureKernel` | Publikasikan `%%configure magic request` pada kernel pyspark. |
| `ListKernelSpecs` | Minta agar titik akhir interaktif mencantumkan spesifikasi kernel yang tersedia. |
| `GetKernelSpec` | Minta agar endpoint interaktif mendapatkan spesifikasi kernel dari kernel yang telah diluncurkan sebelumnya. |
| `GetKernelSpecResource` | Minta agar endpoint interaktif mendapatkan sumber daya spesifik yang terkait dengan spesifikasi kernel yang telah diluncurkan sebelumnya. |
## Contoh
### Untuk mengakses jumlah kernel yang diluncurkan untuk titik akhir interaktif pada hari tertentu:
1. Pilih namespace kustom: `EMRContainers`
1. Pilih Anda`ManagedEndpointId`, `OperationName – CreateKernel`
1. `RequestCount`metrik dengan statistik `SUM` dan periode `1 day` akan memberikan semua permintaan peluncuran kernel yang dibuat dalam 24 jam terakhir.
1. KernelLaunchSuccess metrik dengan statistik `SUM` dan periode `1 day` akan memberikan semua permintaan peluncuran kernel yang berhasil dibuat dalam 24 jam terakhir.
### Untuk mengakses jumlah kegagalan kernel untuk endpoint interaktif pada hari tertentu:
1. Pilih namespace kustom: EMRContainers
1. Pilih Anda`ManagedEndpointId`, `OperationName – CreateKernel`
1. `KernelLaunchFailure`metrik dengan statistik `SUM` dan periode `1 day` akan memberikan semua permintaan peluncuran kernel gagal yang dibuat dalam 24 jam terakhir. Anda juga dapat memilih `5XXError` metrik `4XXError` dan untuk mengetahui jenis kegagalan peluncuran kernel yang terjadi.
# Menggunakan notebook Jupyter yang dihosting sendiri
*Anda dapat meng-host dan mengelola Jupyter atau JupyterLab notebook di instans Amazon EC2 atau di cluster Amazon EKS Anda sendiri sebagai notebook Jupyter yang dihosting sendiri.* Anda kemudian dapat menjalankan beban kerja interaktif dengan notebook Jupyter yang dihosting sendiri. Bagian berikut berjalan melalui proses untuk menyiapkan dan menerapkan notebook Jupyter yang dihosting sendiri di cluster Amazon EKS.
**Topics**
+ [Membuat grup keamanan](#managed-endpoints-self-hosted-security)
+ [Buat EMR Amazon di titik akhir interaktif EKS](#managed-endpoints-self-hosted-create-me)
+ [Ambil URL server gateway dari titik akhir interaktif Anda](#managed-endpoints-self-hosted-gateway)
+ [Ambil token autentikasi untuk terhubung ke titik akhir interaktif](#managed-endpoints-self-hosted-auth)
+ [Contoh: Menyebarkan buku catatan JupyterLab](#managed-endpoints-self-hosted-example)
+ [Menghapus buku catatan Jupyter yang dihosting sendiri](#managed-endpoints-self-hosted-cleanup)
## Membuat grup keamanan
Sebelum Anda dapat membuat endpoint interaktif dan menjalankan Jupyter atau JupyterLab notebook yang dihosting sendiri, Anda harus membuat grup keamanan untuk mengontrol lalu lintas antara buku catatan Anda dan titik akhir interaktif. Untuk menggunakan konsol Amazon EC2 atau Amazon EC2 SDK untuk membuat grup keamanan, lihat langkah-langkah [dalam Membuat grup keamanan di Panduan Pengguna](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) Amazon *EC2*. Anda harus membuat grup keamanan di VPC tempat Anda ingin menyebarkan server notebook Anda.
Untuk mengikuti contoh dalam panduan ini, gunakan VPC yang sama dengan cluster Amazon EKS Anda. Jika Anda ingin meng-host notebook Anda di VPC yang berbeda dari VPC untuk cluster Amazon EKS Anda, Anda mungkin perlu membuat koneksi peering di antara keduanya. VPCs Untuk langkah-langkah untuk membuat koneksi peering di antara keduanya VPCs, lihat [Membuat koneksi peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) di Panduan Memulai VPC Amazon.
Anda memerlukan ID untuk grup keamanan untuk [membuat EMR Amazon di titik akhir interaktif EKS di langkah](https://docs.aws.amazon.com/) berikutnya.
## Buat EMR Amazon di titik akhir interaktif EKS
Setelah Anda membuat grup keamanan untuk buku catatan Anda, gunakan langkah-langkah yang disediakan [Membuat endpoint interaktif untuk klaster virtual Anda](create-managed-endpoint.md) untuk membuat titik akhir interaktif. Anda harus memberikan ID grup keamanan yang Anda buat untuk buku catatan Anda[Membuat grup keamanan](#managed-endpoints-self-hosted-security).
Masukkan ID keamanan sebagai pengganti pengaturan penggantian konfigurasi berikut: *your-notebook-security-group-id*
```
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"notebook-security-group-id": "your-notebook-security-group-id"
}
}
],
"monitoringConfiguration": {
...'
```
## Ambil URL server gateway dari titik akhir interaktif Anda
Setelah Anda membuat endpoint interaktif, ambil URL server gateway dengan `describe-managed-endpoint` perintah di. AWS CLI Anda memerlukan URL ini untuk menghubungkan buku catatan Anda ke titik akhir. URL server gateway adalah titik akhir pribadi.
```
aws emr-containers describe-managed-endpoint \
--region region \
--virtual-cluster-id virtualClusterId \
--id endpointId
```
Awalnya, titik akhir Anda ada di **CREATING**negara bagian. Setelah beberapa menit, ia beralih ke **ACTIVE**negara. Ketika titik akhir **ACTIVE**, siap digunakan.
Perhatikan `serverUrl` atribut yang dikembalikan `aws emr-containers describe-managed-endpoint` perintah dari endpoint aktif. Anda memerlukan URL ini untuk menghubungkan buku catatan Anda ke titik akhir saat [Anda menerapkan Jupyter atau notebook yang dihosting sendiri](https://docs.aws.amazon.com/). JupyterLab
## Ambil token autentikasi untuk terhubung ke titik akhir interaktif
Untuk terhubung ke endpoint interaktif dari Jupyter atau JupyterLab notebook, Anda harus membuat token sesi dengan API. `GetManagedEndpointSessionCredentials` Token bertindak sebagai bukti otentikasi untuk terhubung ke server endpoint interaktif.
Perintah berikut dijelaskan secara lebih rinci dengan contoh output di bawah ini.
```
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 dari titik akhir Anda. Anda dapat menemukan ARN dalam hasil panggilan`describe-managed-endpoint`.
**`virtualClusterArn`**
ARN dari cluster virtual.
**`executionRoleArn`**
ARN dari peran eksekusi.
**`durationInSeconds`**
Durasi dalam detik dimana token valid. Durasi default adalah 15 menit (`900`), dan maksimum adalah 12 jam (`43200`).
**`region` **
Wilayah yang sama dengan titik akhir Anda.
Output Anda harus menyerupai contoh berikut. Catat `session-token` nilai yang akan Anda gunakan saat [menerapkan Jupyter atau notebook yang dihosting sendiri](https://docs.aws.amazon.com/). JupyterLab
```
{
"id": "credentialsId",
"credentials": {
"token": "session-token"
},
"expiresAt": "2022-07-05T17:49:38Z"
}
```
## Contoh: Menyebarkan buku catatan JupyterLab
Setelah Anda menyelesaikan langkah-langkah di atas, Anda dapat mencoba prosedur contoh ini untuk menyebarkan JupyterLab notebook ke cluster Amazon EKS dengan endpoint interaktif Anda.
1. Buat namespace untuk menjalankan server notebook.
1. Buat file secara lokal,`notebook.yaml`, dengan konten berikut. Isi file dijelaskan di bawah ini.
```
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"
```
Jika Anda menerapkan notebook Jupyter ke cluster khusus Fargate, beri label pada pod Jupyter dengan label seperti yang ditunjukkan pada contoh berikut: `role`
```
...
metadata:
name: jupyter-notebook
namespace: default
labels:
role: example-role-name-label
spec:
...
```
**`namespace`**
Namespace Kubernetes yang digunakan notebook.
**`serverUrl`**
`serverUrl`Atribut yang dikembalikan `describe-managed-endpoint` perintah[Ambil URL server gateway dari titik akhir interaktif Anda](#managed-endpoints-self-hosted-gateway).
**`session-token`**
`session-token`Atribut yang dikembalikan `get-managed-endpoint-session-credentials` perintah[Ambil token autentikasi untuk terhubung ke titik akhir interaktif](#managed-endpoints-self-hosted-auth).
**`KERNEL_LAUNCH_TIMEOUT`**
Jumlah waktu dalam hitungan detik titik akhir interaktif menunggu kernel muncul. **RUNNING** Pastikan waktu yang cukup untuk menyelesaikan peluncuran kernel dengan mengatur batas waktu peluncuran kernel ke nilai yang sesuai (maksimum 400 detik).
**`KERNEL_EXTRA_SPARK_OPTS`**
Secara opsional, Anda dapat meneruskan konfigurasi Spark tambahan untuk kernel Spark. Tetapkan variabel lingkungan ini dengan nilai-nilai sebagai properti konfigurasi Spark seperti yang ditunjukkan pada contoh berikut:
```
- 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. Menerapkan spesifikasi pod ke cluster Amazon EKS Anda:
```
kubectl apply -f notebook.yaml -n namespace
```
Ini akan memulai JupyterLab notebook minimal yang terhubung ke EMR Amazon Anda di titik akhir interaktif EKS. Tunggu sampai pod itu **RUNNING**. Anda dapat memeriksa statusnya dengan perintah berikut:
```
kubectl get pod jupyter-notebook -n namespace
```
Ketika pod siap, `get pod` perintah mengembalikan output yang mirip dengan ini:
```
NAME READY STATUS RESTARTS AGE
jupyter-notebook 1/1 Running 0 46s
```
1. Lampirkan grup keamanan notebook ke node tempat notebook dijadwalkan.
1. Pertama, identifikasi node tempat `jupyter-notebook` pod dijadwalkan dengan `describe pod` perintah.
```
kubectl describe pod jupyter-notebook -n namespace
```
1. Buka konsol Amazon EKS di [https://console.aws.amazon.com/eks/rumah\$1/cluster](https://console.aws.amazon.com/eks/home#/clusters).
1. Arahkan ke tab **Compute** untuk cluster Amazon EKS Anda dan pilih node yang diidentifikasi oleh `describe pod` perintah. Pilih ID instance untuk node.
1. Dari menu **Tindakan**, pilih **Keamanan** > **Ubah grup keamanan** untuk melampirkan grup keamanan yang Anda buat[Membuat grup keamanan](#managed-endpoints-self-hosted-security).
1. Jika Anda menerapkan pod notebook Jupyter AWS Fargate, buat a []()to apply ke pod notebook Jupyter dengan label peran:
```
cat >my-security-group-policy.yaml <
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()
```
![\[Screenshot contoh kode notebook Scala di JupyterLab.\]](http://docs.aws.amazon.com/id_id/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)
## Menghapus buku catatan Jupyter yang dihosting sendiri
Saat Anda siap untuk menghapus buku catatan yang dihosting sendiri, Anda juga dapat menghapus titik akhir interaktif dan grup keamanan juga. Lakukan tindakan dengan urutan sebagai berikut:
1. Gunakan perintah berikut untuk menghapus `jupyter-notebook` pod:
```
kubectl delete pod jupyter-notebook -n namespace
```
1. Kemudian, hapus endpoint interaktif Anda dengan `delete-managed-endpoint` perintah. Untuk langkah-langkah menghapus titik akhir interaktif, lihat[Hapus titik akhir interaktif](delete-managed-endpoint.md). Awalnya, titik akhir Anda akan berada di **TERMINATING**negara bagian. Setelah semua sumber daya dibersihkan, ia beralih ke **TERMINATED**negara bagian.
1. Jika Anda tidak berencana untuk menggunakan grup keamanan notebook yang Anda buat [Membuat grup keamanan](#managed-endpoints-self-hosted-security) untuk penerapan notebook Jupyter lainnya, Anda dapat menghapusnya. Lihat [Menghapus grup keamanan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) di Panduan Pengguna Amazon EC2 untuk informasi selengkapnya.
# Mendapatkan informasi tentang titik akhir interaktif dengan perintah CLI
Topik ini mencakup operasi yang didukung pada titik akhir interaktif selain [`create-managed-endpoint`](create-managed-endpoint.md).
## Ambil detail titik akhir interaktif
Setelah Anda membuat endpoint interaktif, Anda dapat mengambil detailnya menggunakan perintah. `describe-managed-endpoint` AWS CLI Masukkan nilai Anda sendiri untuk*managed-endpoint-id*,*virtual-cluster-id*, dan*region*:
```
aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \
‐‐virtual-cluster-id virtual-cluster-id ‐‐region region
```
Outputnya terlihat mirip dengan berikut ini, dengan titik akhir yang ditentukan, seperti ARN, ID, dan nama.
```
{
"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": {}
}
```
## Buat daftar semua titik akhir interaktif yang terkait dengan cluster virtual
Gunakan `list-managed-endpoints` AWS CLI perintah untuk mengambil daftar semua endpoint interaktif yang terkait dengan cluster virtual tertentu. Ganti `virtual-cluster-id` dengan ID cluster virtual Anda.
```
aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id
```
Output dari `list-managed-endpoint` perintah ditunjukkan di bawah ini:
```
{
"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": {}
}]
}
```
# Hapus titik akhir interaktif
Untuk menghapus titik akhir interaktif yang terkait dengan EMR Amazon di kluster virtual EKS, gunakan `delete-managed-endpoint` AWS CLI perintah. Saat Anda menghapus titik akhir interaktif, Amazon EMR di EKS menghapus grup keamanan default yang dibuat untuk titik akhir tersebut.
Tentukan nilai untuk parameter berikut ke perintah:
+ **‐‐id:** Pengenal titik akhir interaktif yang ingin Anda hapus.
+ **‐‐ virtual-cluster-id** — Pengidentifikasi cluster virtual yang terkait dengan titik akhir interaktif yang ingin Anda hapus. Ini adalah ID cluster virtual yang sama yang ditentukan ketika endpoint interaktif dibuat.
```
aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id
```
Perintah mengembalikan output yang mirip dengan berikut ini untuk mengonfirmasi bahwa Anda menghapus titik akhir interaktif:
```
{
"id":"8gai4l4exxxxx",
"virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx"
}
```