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

# Menggunakan notebook Jupyter yang dihosting sendiri
<a name="managed-endpoints-self-hosted"></a>

*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
<a name="managed-endpoints-self-hosted-security"></a>

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
<a name="managed-endpoints-self-hosted-create-me"></a>

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
<a name="managed-endpoints-self-hosted-gateway"></a>

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
<a name="managed-endpoints-self-hosted-auth"></a>

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
<a name="managed-endpoints-self-hosted-example"></a>

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\#/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 <<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. Sekarang, port-forward sehingga Anda dapat mengakses antarmuka secara lokal: JupyterLab 

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

   Setelah berjalan, navigasikan ke browser lokal Anda dan kunjungi `localhost:8888` untuk melihat JupyterLab antarmuka:  
![Screenshot dari layar JupyterLab mulai.](http://docs.aws.amazon.com/id_id/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1. Dari JupyterLab, buat notebook Scala baru. Berikut adalah contoh cuplikan kode yang dapat Anda jalankan untuk memperkirakan nilai 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()
   ```  
![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
<a name="managed-endpoints-self-hosted-cleanup"></a>

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.