Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden von selbst gehosteten Jupyter Notebooks
<a name="managed-endpoints-self-hosted"></a>

*Sie können Jupyter oder JupyterLab Notebooks auf einer Amazon EC2 EC2-Instance oder in Ihrem eigenen Amazon EKS-Cluster als selbst gehostetes Jupyter-Notebook hosten und verwalten.* Anschließend können Sie interaktive Workloads mit Ihren selbstgehosteten Jupyter-Notebooks ausführen. In den folgenden Abschnitten wird der Prozess zur Einrichtung und Bereitstellung eines selbst gehosteten Jupyter Notebooks auf einem Amazon-EKS-Cluster beschrieben.



**Topics**
+ [Eine Sicherheitsgruppe erstellen](#managed-endpoints-self-hosted-security)
+ [Einen interaktiven Endpunkt für Amazon EMR in EKS erstellen](#managed-endpoints-self-hosted-create-me)
+ [Abrufen der Gateway-Server-URL Ihres interaktiven Endpunkts](#managed-endpoints-self-hosted-gateway)
+ [Rufen Sie ein Authentifizierungstoken ab, um eine Verbindung zum interaktiven Endpunkt herzustellen](#managed-endpoints-self-hosted-auth)
+ [Beispiel: Stellen Sie ein Notebook bereit JupyterLab](#managed-endpoints-self-hosted-example)
+ [Löschen Sie ein selbst gehostetes Jupyter Notebook](#managed-endpoints-self-hosted-cleanup)

## Eine Sicherheitsgruppe erstellen
<a name="managed-endpoints-self-hosted-security"></a>

Bevor Sie einen interaktiven Endpunkt erstellen und einen selbst gehosteten Jupyter oder ein selbst gehostetes Notebook ausführen können, müssen Sie eine Sicherheitsgruppe erstellen, um den Verkehr zwischen Ihrem JupyterLab Notebook und dem interaktiven Endpunkt zu kontrollieren. Informationen zur Verwendung der Amazon EC2-Konsole oder des Amazon EC2-SDK zum Erstellen der Sicherheitsgruppe finden Sie in den Schritten unter [Sicherheitsgruppe erstellen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) im *Amazon EC2 EC2-Benutzerhandbuch*. Sie sollten die Sicherheitsgruppe in der VPC erstellen, in der Sie Ihren Notebook-Server bereitstellen möchten.

Um dem Beispiel in diesem Handbuch zu folgen, verwenden Sie dieselbe VPC wie Ihr Amazon-EKS-Cluster. Wenn Sie Ihr Notebook in einer VPC hosten möchten, die sich von der VPC für Ihren Amazon EKS-Cluster unterscheidet, müssen Sie möglicherweise eine Peering-Verbindung zwischen diesen beiden herstellen. VPCs Schritte zum Herstellen einer Peering-Verbindung zwischen zwei VPCs Personen finden Sie unter [Erstellen einer VPC-Peering-Verbindung im Amazon VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) Getting Started Guide.

Sie benötigen die ID für die Sicherheitsgruppe, um im nächsten Schritt [einen interaktiven Endpunkt für Amazon EMR in EKS zu erstellen](https://docs.aws.amazon.com/).

## Einen interaktiven Endpunkt für Amazon EMR in EKS erstellen
<a name="managed-endpoints-self-hosted-create-me"></a>

Nachdem Sie die Sicherheitsgruppe für Ihr Notebook erstellt haben, gehen Sie wie unter [Einen interaktiven Endpunkt für Ihren virtuellen Cluster erstellen](create-managed-endpoint.md) beschrieben vor, um einen interaktiven Endpunkt zu erstellen. Sie müssen die Sicherheitsgruppen-ID angeben, die Sie für Ihr Notebook unter [Eine Sicherheitsgruppe erstellen](#managed-endpoints-self-hosted-security) erstellt haben. 

Geben Sie die Sicherheits-ID anstelle von *your-notebook-security-group-id* in den folgenden Einstellungen zur Änderung der Konfiguration ein:

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

## Abrufen der Gateway-Server-URL Ihres interaktiven Endpunkts
<a name="managed-endpoints-self-hosted-gateway"></a>

Nachdem Sie einen interaktiven Endpunkt erstellt haben, rufen Sie die Gateway-Server-URL mit dem `describe-managed-endpoint`-Befehl in AWS CLI ab. Sie benötigen diese URL, um Ihr Notebook mit dem Endpunkt zu verbinden. Die Gateway-Server-URL ist ein privater Endpunkt.

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

Der Endpunkt befindet sich zunächst im Status **CREATING**. Nach einigen Minuten wechselt er in den **ACTIVE**-Status. Wenn der Endpunkt **ACTIVE** ist, kann er verwendet werden.

Notieren Sie sich das `serverUrl`-Attribut, das der `aws emr-containers describe-managed-endpoint`-Befehl vom aktiven Endpunkt zurückgibt. Sie benötigen diese URL, um Ihr Notebook mit dem Endpunkt zu verbinden, wenn Sie Ihren [selbst gehosteten Jupyter oder Ihr selbst gehostetes Notebook bereitstellen](https://docs.aws.amazon.com/). JupyterLab 

## Rufen Sie ein Authentifizierungstoken ab, um eine Verbindung zum interaktiven Endpunkt herzustellen
<a name="managed-endpoints-self-hosted-auth"></a>

Um von einem Jupyter oder JupyterLab Notebook aus eine Verbindung zu einem interaktiven Endpunkt herzustellen, müssen Sie mit der API ein Sitzungstoken generieren. `GetManagedEndpointSessionCredentials` Das Token dient als Authentifizierungsnachweis für die Verbindung zum interaktiven Endpunktserver. 

Der folgende Befehl wird anhand eines Ausgabebeispiels weiter unten ausführlicher erklärt.

```
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`**  
Der ARN Ihres Endpunkts. Sie finden den ARN im Ergebnis eines `describe-managed-endpoint`-Aufrufs.

**`virtualClusterArn`**  
Die ARN des virtuellen Clusters.

**`executionRoleArn`**  
Die ARN der Ausführungsrolle.

**`durationInSeconds`**  
Die Dauer in Sekunden, für die das Token gültig ist. Die Standarddauer beträgt 15 Minuten (`900`) und die Höchstdauer 12 Stunden (`43200`).

**`region` **  
Dieselbe Region wie Ihr Endpunkt.

Die Ausgabe sollte etwa wie das folgende Beispiel aussehen. Notieren Sie sich den `session-token` Wert, den Sie verwenden werden, wenn Sie Ihren selbst gehosteten Jupyter [oder Ihr selbst gehostetes Notebook bereitstellen](https://docs.aws.amazon.com/). JupyterLab 

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

## Beispiel: Stellen Sie ein Notebook bereit JupyterLab
<a name="managed-endpoints-self-hosted-example"></a>

Nachdem Sie die obigen Schritte abgeschlossen haben, können Sie dieses Beispielverfahren ausprobieren, um ein JupyterLab Notebook mit Ihrem interaktiven Endpunkt im Amazon EKS-Cluster bereitzustellen.

1. Erstellen Sie einen Namespace, um den Notebook-Server auszuführen.

1. Erstellen Sie lokal eine Datei `notebook.yaml` und den folgenden Inhalten. Der Inhalt der Datei wird im Folgenden beschrieben.

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

   Wenn Sie das Jupyter-Notebook in einem reinen Fargate-Cluster bereitstellen, kennzeichnen Sie den Jupyter-Pod mit einer `role`-Kennzeichnung, wie im folgenden Beispiel gezeigt:

   ```
   ...
   metadata:
     name: jupyter-notebook
     namespace: default
     labels:
       role: example-role-name-label
   spec:
               ...
   ```  
**`namespace`**  
Der Kubernetes-Namespace, in dem das Notebook bereitgestellt wird.  
**`serverUrl`**  
Das `serverUrl`-Attribut, in dem der `describe-managed-endpoint`-Befehl in [Abrufen der Gateway-Server-URL Ihres interaktiven Endpunkts](#managed-endpoints-self-hosted-gateway) zurückgegeben wurde.  
**`session-token`**  
Das `session-token`-Attribut, in dem der `get-managed-endpoint-session-credentials`-Befehl in [Rufen Sie ein Authentifizierungstoken ab, um eine Verbindung zum interaktiven Endpunkt herzustellen](#managed-endpoints-self-hosted-auth) zurückgegeben wurde.  
**`KERNEL_LAUNCH_TIMEOUT`**  
Die Zeit in Sekunden, die der interaktive Endpunkt darauf wartet, dass der Kernel den **RUNNING**-Status erreicht. Stellen Sie sicher, dass genügend Zeit bis zum Abschluss des Kernelstarts vergangen ist, indem Sie das Timeout für den Kernelstart auf einen geeigneten Wert setzen (maximal 400 Sekunden).  
**`KERNEL_EXTRA_SPARK_OPTS`**  
Optional können Sie zusätzliche Spark-Konfigurationen für die Spark-Kernel übergeben. Legen Sie diese Umgebungsvariable mit den Werten als Spark-Konfigurationseigenschaft fest, wie im folgenden Beispiel gezeigt:  

   ```
   - 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. Stellen Sie die Pod-Spezifikation in Ihrem Amazon-EKS-Cluster bereit:

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

   Dadurch wird ein minimales JupyterLab Notizbuch gestartet, das mit Ihrem interaktiven Endpunkt Amazon EMR auf EKS verbunden ist. Warten Sie, bis der Pod **RUNNING** ist. Sie können den Status mit dem folgenden Befehl überprüfen:

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

   Wenn der Pod bereit ist, gibt der `get pod`-Befehl eine Ausgabe zurück, die der folgenden ähnelt:

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

1. Ordnen Sie die Notebook-Sicherheitsgruppe dem Knoten zu, für den das Notebook geplant ist.

   1. Identifizieren Sie zunächst mit dem `describe pod`-Befehl den Knoten, für den der `jupyter-notebook`-Pod geplant ist.

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

   1. Öffnen Sie die Amazon EKS-Konsole unter [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters).

   1. Navigieren Sie zur Registerkarte **Datenverarbeitung** für Ihren Amazon-EKS-Cluster und wählen Sie den durch den `describe pod`-Befehl identifizierten Knoten aus. Wählen Sie die Instance-ID für den Knoten aus.

   1. Wählen Sie im Menü **Aktionen** die Option **Sicherheit** > **Sicherheitsgruppen ändern** aus, um die Sicherheitsgruppe anzuhängen, die Sie in [Eine Sicherheitsgruppe erstellen](#managed-endpoints-self-hosted-security) erstellt haben.

   1. Wenn Sie den Jupyter-Notebook-Pod bereitstellen AWS Fargate, erstellen Sie einen [](), der auf den Jupyter-Notebook-Pod angewendet werden soll, mit der Rollenbezeichnung:

      ```
      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. Führen Sie nun einen Port-Forward durch, sodass Sie lokal auf die Schnittstelle zugreifen können: JupyterLab 

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

   Sobald das läuft, navigieren Sie zu Ihrem lokalen Browser und besuchen `localhost:8888` Sie die JupyterLab Benutzeroberfläche:  
![\[Screenshot des JupyterLab Startbildschirms.\]](http://docs.aws.amazon.com/de_de/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1. Erstellen Sie von aus JupyterLab ein neues Scala-Notizbuch. Hier ist ein Beispielcodeausschnitt, den Sie ausführen können, um den Wert von Pi zu approximieren:

   ```
   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 eines Beispielcodes für ein Scala-Notizbuch in. JupyterLab\]](http://docs.aws.amazon.com/de_de/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)

## Löschen Sie ein selbst gehostetes Jupyter Notebook
<a name="managed-endpoints-self-hosted-cleanup"></a>

Wenn Sie bereit sind, Ihr selbst gehostetes Notebook zu löschen, können Sie auch den interaktiven Endpunkt und die Sicherheitsgruppe löschen. Führen Sie die Aktionen in der folgenden Reihenfolge aus:

1. Verwenden Sie den folgenden -Befehl, um den `jupyter-notebook` Pod zu löschen:

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

1. Löschen Sie dann Ihren interaktiven Endpunkt mit dem `delete-managed-endpoint`-Befehl. Schritte zum Löschen eines interaktiven Endpunkts finden Sie unter [Löschen eines interaktiven Endpunkts](delete-managed-endpoint.md). Zu Beginn befindet sich Ihr Endpunkt im **TERMINATING**-Status. Sobald alle Ressourcen bereinigt wurden, wechselt er in den **TERMINATED**-Status.

1. Wenn Sie nicht vorhaben, die Notebook-Sicherheitsgruppe, in der Sie [Eine Sicherheitsgruppe erstellen](#managed-endpoints-self-hosted-security) erstellt haben, für andere Jupyter-Notebook-Bereitstellungen zu verwenden, können Sie sie löschen. Weitere Informationen finden Sie unter [Löschen einer Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) im Amazon-EC2-Benutzerhandbuch.