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.
# Ausführen interaktiver Workloads auf Amazon EMR in EKS
Ein *interaktiver Endpunkt* ist ein Gateway, das Amazon EMR Studio mit Amazon EMR in EKS verbindet, sodass Sie interaktive Workloads ausführen können. Sie können interaktive Endpunkte mit EMR Studio verwenden, um interaktive Analysen mit Datensätzen in Datenspeichern wie [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) und [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) durchzuführen.
**Anwendungsfälle**
+ Erstellen Sie ein ETL-Skript mit der EMR-Studio-IDE-Erfahrung. Die IDE nimmt On-Premises-Daten auf und speichert sie nach Transformationen zur späteren Analyse in Amazon S3.
+ Verwenden Sie Notebooks, um Datensätze zu untersuchen und ein Machine-Learning-Modell zu trainieren, um Anomalien in den Datensätzen zu erkennen.
+ Erstellen Sie Skripts, die tägliche Berichte für Analyseanwendungen wie Geschäfts-Dashboards generieren.
**Topics**
+ [Übersicht über interaktive Endpunkte](how-it-works.md)
+ [Voraussetzungen für die Erstellung eines interaktiven Endpunkts auf Amazon EMR in EKS](prereqs-for-studio.md)
+ [Einen interaktiven Endpunkt für Ihren virtuellen Cluster erstellen](create-managed-endpoint.md)
+ [Konfiguration von Einstellungen für interaktive Endpunkte](managed-endpoint-parameters.md)
+ [Überwachen interaktiver Endpunkte](managed-endpoints-customer-metrics.md)
+ [Verwenden von selbst gehosteten Jupyter Notebooks](managed-endpoints-self-hosted.md)
+ [Informationen zu interaktiven Endpunkten mit CLI-Befehlen abrufen](other-operations.md)
# Übersicht über interaktive Endpunkte
Ein *interaktiver Endpunkt* bietet interaktiven Clients wie Amazon EMR Studio die Möglichkeit, sich mit Amazon EMR in EKS-Clustern zu verbinden, um interaktive Workloads auszuführen. Der interaktive Endpunkt wird von einem Jupyter Enterprise Gateway unterstützt, das die Funktionen zur Verwaltung des Kernel-Lebenszyklus per Fernzugriff bereitstellt, die interaktive Clients benötigen. *Kernel* sind sprachspezifische Prozesse, die mit dem auf Jupyter basierenden Amazon-EMR-Studio-Client interagieren, um interaktive Workloads auszuführen.
Interaktive Endpunkte unterstützen die folgenden Kernel:
+ Python 3
+ PySpark auf Kubernetes
+ Apache Spark mit Scala
**Anmerkung**
Die Preise für Amazon EMR in EKS gelten für die interaktiven Endpunkte und Kernel. Weitere Informationen finden Sie auf der [Preisseite für Amazon EMR in EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS).
Die folgenden Entitäten sind erforderlich, damit EMR Studio eine Verbindung mit Amazon EMR in EKS herstellen kann.
+ **Virtueller Amazon EMR in EKS-Cluster** – Ein *virtueller Cluster* ist ein Kubernetes-Namespace, bei dem Sie Amazon EMR registrieren. Amazon EMR verwendet virtuelle Cluster, um Aufträge auszuführen und Endpunkte zu hosten. Sie können mehrere virtuelle Cluster mit demselben physischen Cluster sichern. Jeder virtuelle Cluster ist jedoch einem Namespace auf einem Amazon-EKS-Cluster zugeordnet. Virtuelle Cluster erzeugen keine aktiven Ressourcen, die zu Ihrer Rechnung beitragen oder für die ein Lebenszyklus-Management außerhalb des Services erforderlich ist.
+ **Interaktiver Endpunkt von Amazon EMR in EKS** – Ein *interaktiver Endpunkt* ist ein HTTPS-Endpunkt, mit dem EMR-Studio-Benutzer eine Verbindung zu einem Workspace herstellen können. Sie können nur von Ihrem EMR Studio aus auf die HTTPS-Endpunkte zugreifen und sie in einem privaten Subnetz der Amazon Virtual Private Cloud (Amazon VPC) für Ihren Amazon-EKS-Cluster erstellen.
Die Python- PySpark, und Spark-Scala-Kernel verwenden die in Ihrer Amazon EMR on EKS-Jobausführungsrolle definierten Berechtigungen, um andere aufzurufen. AWS-Services Alle Kernel und Benutzer, die eine Verbindung zum interaktiven Endpunkt herstellen, verwenden die Rolle, die Sie bei der Erstellung des Endpunkts angegeben haben. Wir empfehlen, separate Endpoints für verschiedene Benutzer zu erstellen und dafür zu sorgen, dass die Benutzer unterschiedliche Rollen (IAM) haben. AWS Identity and Access Management
+ **AWS Application Load Balancer Balancer-Controller** — Der *AWS Application Load Balancer Balancer-Controller* verwaltet Elastic Load Balancing für einen Amazon EKS Kubernetes-Cluster. Der Controller stellt einen Application Load Balancer (ALB) bereit, wenn Sie eine Kubernetes-Ingress-Ressource erstellen. Ein ALB macht einen Kubernetes-Service, z. B. einen interaktiven Endpunkt, außerhalb des Amazon-EKS-Clusters, aber innerhalb derselben Amazon VPC verfügbar. Wenn Sie einen interaktiven Endpunkt erstellen, wird auch eine Ingress-Ressource bereitgestellt, die den interaktiven Endpunkt über die ALB verfügbar macht, damit interaktive Clients eine Verbindung herstellen können. Sie müssen nur einen AWS Application Load Balancer Balancer-Controller für jeden Amazon EKS-Cluster installieren.
Das folgende Diagramm zeigt die interaktive Endpunktarchitektur in Amazon EMR in EKS. Ein Amazon-EKS-Cluster umfasst die *Rechenleistung* zur Ausführung der analytischen Workloads und den *interaktiven Endpunkt.* Der Application-Load-Balancer-Controller wird im `kube-system`-Namespace ausgeführt. Die Workloads und interaktiven Endpunkte werden in dem Namespace ausgeführt, den Sie bei der Erstellung des virtuellen Clusters angeben. Wenn Sie einen interaktiven Endpunkt erstellen, erstellt die Amazon EMR in EKS-Kontrollebene die interaktive Endpunktbereitstellung im Amazon-EKS-Cluster. Darüber hinaus wird vom Load Balancer-Controller eine Instance des Application Load Balancer-Eingangs AWS erstellt. Der Application Load Balancer stellt die externe Schnittstelle für Clients wie EMR Studio bereit, um eine Verbindung zum Amazon-EMR-Cluster herzustellen und interaktive Workloads auszuführen.
![\[Diagramm der interaktiven Endpunktarchitektur\]](http://docs.aws.amazon.com/de_de/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png)
# Voraussetzungen für die Erstellung eines interaktiven Endpunkts auf Amazon EMR in EKS
In diesem Abschnitt werden die Voraussetzungen für die Einrichtung eines interaktiven Endpunkts beschrieben, mit dem EMR Studio eine Verbindung zu einem Amazon EMR in EKS-Cluster herstellen und interaktive Workloads ausführen kann.
## AWS CLI
Folgen Sie den Schritten unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI, um die](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) neueste Version von AWS Command Line Interface ()AWS CLI zu installieren.
## Installation von eksctl
Folgen Sie den Schritten unter [Kubectl installieren, um die neueste Version von eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) zu installieren. Wenn Sie Kubernetes-Version 1.22 oder höher für Ihren Amazon-EKS-Cluster verwenden, verwenden Sie eine eksctl-Version größer als 0.117.0.
## Amazon-EKS-Cluster
Erstellen Sie einen Amazon-EKS-Cluster. Im folgenden Beispiel wird gezeigt, wie Sie einen Amazon EMR in EKS-Cluster erstellen. Nachfolgend werden Anforderungen und Überlegungen für diesen Cluster aufgeführt:
+ Der Cluster muss sich in derselben Amazon Virtual Private Cloud (VPC) befinden wie Ihr EMR Studio.
+ Der Cluster muss über mindestens ein privates Subnetz verfügen, um interaktive Endpunkte zu aktivieren, Git-basierte Repositorys zu verknüpfen und den Application Load Balancer im privaten Modus zu starten.
+ Es muss mindestens ein gemeinsames privates Subnetz zwischen Ihrem EMR Studio und dem Amazon-EKS-Cluster geben, den Sie für die Registrierung Ihres virtuellen Clusters verwenden. Dadurch wird sichergestellt, dass Ihr interaktiver Endpunkt als Option in Ihren Studio-Workspaces angezeigt wird, und die Konnektivität von Studio zum Application Load Balancer aktiviert.
Sie können zwischen zwei Methoden wählen, um Ihr Studio und Ihren Amazon-EKS-Cluster zu verbinden:
+ Erstellen Sie einen Amazon-EKS-Cluster und verknüpfen Sie ihn mit den Subnetzen, die zu Ihrem EMR Studio gehören.
+ Alternativ können Sie ein EMR Studio erstellen und die privaten Subnetze für Ihren Amazon-EKS-Cluster angeben.
+ Amazon EKS-optimiertes ARM Amazon Linux AMIs wird für Amazon EMR auf interaktiven EKS-Endpunkten nicht unterstützt.
+ Nur von [Amazon EKS verwaltete Knotengruppen](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html) und von Karpenter bereitgestellte Knoten werden unterstützt.
## Gewähren eines Clusterzugriff für Amazon EMR in EKS
Verwenden Sie die Schritte unter [Clusterzugriff für Amazon EMR in EKS gewähren](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html), um Amazon EMR in EKS Zugriff auf einen bestimmten Namespace in Ihrem Cluster zu gewähren.
## IRSA im Amazon-EKS-Cluster aktivieren
Um IAM-Rollen für Servicekonten (IRSA) auf dem Amazon-EKS-Cluster zu aktivieren, folgen Sie den Schritten unter [Aktivieren von IAM-Rollen für Servicekonten (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html).
## Eine IAM-Auftragausführungsrolle erstellen
Sie müssen eine IAM-Rolle erstellen, um Workloads auf Amazon EMR auf interaktiven EKS-Endpunkten auszuführen. In dieser Dokumentation wird diese IAM-Rolle als *Auftragsausausführungsrolle* bezeichnet. Diese IAM-Rolle wird sowohl dem interaktiven Endpunkt-Container als auch den eigentlichen Ausführungscontainern zugewiesen, die erstellt werden, wenn Sie Aufträge mit EMR Studio einreichen. Sie benötigen den Amazon-Ressourcennamen (ARN) Ihrer Aufgabenausführungsrolle für Amazon EMR auf EKS. Dazu sind zwei Schritte erforderlich:
+ [Erstellen einer IAM-Rollen-Auftragsausführung.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)
+ [Aktualisieren Sie die Vertrauensrichtlinie der Auftragsausführungsrolle.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html)
## Gewähren Sie Benutzern Zugriff auf Amazon EMR in EKS
Die IAM-Entität (Benutzer oder Rolle), die die Anfrage zur Erstellung eines interaktiven Endpunkts stellt, muss außerdem über die folgenden Amazon-EC2- und `emr-containers`-Berechtigungen verfügen. Folgen Sie den unter [Gewähren Sie Benutzern Zugriff auf Amazon EMR in EKS](setting-up-iam.md) beschriebenen Schritten, um diese Berechtigungen zu gewähren, die es Amazon EMR in EKS ermöglichen, die Sicherheitsgruppen zu erstellen, zu verwalten und zu löschen, die den eingehenden Datenverkehr auf den Load Balancer Ihres interaktiven Endpunkts beschränken.
Die folgenden `emr-containers`-Berechtigungen ermöglichen es dem Benutzer, grundlegende interaktive Endpunktoperationen durchzuführen:
```
"ec2:CreateSecurityGroup",
"ec2:DeleteSecurityGroup",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress"
"emr-containers:CreateManagedEndpoint",
"emr-containers:ListManagedEndpoints",
"emr-containers:DescribeManagedEndpoint",
"emr-containers:DeleteManagedEndpoint"
```
## Den Amazon-EKS-Cluster mit Amazon EMR registrieren
Richten Sie einen virtuellen Cluster ein und ordnen Sie ihn dem Namespace im Amazon-EKS-Cluster zu, in dem Sie Ihre Aufträge ausführen möchten. Verwenden Sie für AWS Fargate reine Cluster denselben Namespace sowohl für den virtuellen Amazon EMR on EKS-Cluster als auch für das Fargate-Profil.
Informationen zur Einrichtung eines virtuellen Amazon EMR auf einem EKS-Cluster finden Sie unter [Den Amazon-EKS-Cluster mit Amazon EMR registrieren](setting-up-registration.md).
## AWS Load Balancer Controller im Amazon EKS-Cluster bereitstellen
Für Ihren Amazon EKS-Cluster ist ein AWS Application Load Balancer erforderlich. Sie müssen nur einen Application-Load-Balancer-Controller pro Amazon-EKS-Cluster einrichten. Informationen zur Einrichtung des AWS Application Load Balancer Balancer-Controllers finden Sie unter [Installation des Load AWS Balancer Controller-Add-ons](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) im *Amazon EKS-Benutzerhandbuch*.
# Einen interaktiven Endpunkt für Ihren virtuellen Cluster erstellen
Dieses Thema beschreibt einige Möglichkeiten, einen interaktiven Endpunkt mithilfe der AWS Befehlszeilenschnittstelle (AWS CLI) zu erstellen, und enthält Einzelheiten zu verfügbaren Konfigurationsparametern.
## Erstellen Sie einen interaktiven Endpunkt mit dem `create-managed-endpoint`-Befehl
Geben Sie die Parameter im `create-managed-endpoint`-Befehl wie folgt an. Amazon EMR in EKS unterstützt die Erstellung interaktiver Endpunkte mit Amazon-EMR-Versionen 6.7.0 und später.
```
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"
}
}
}'
```
Weitere Informationen finden Sie unter [Parameter für die Erstellung eines interaktiven Endpunkts](#parameters-for-creating).
## Erstellen Sie einen interaktiven Endpunkt mit angegebenen Parametern in einer JSON-Datei
1. Erstellen Sie eine `create-managed-endpoint-request.json`-Datei und geben Sie die erforderlichen Parameter für Ihren Endpunkt an, wie in der folgenden JSON-Datei gezeigt:
```
{
"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. Verwenden Sie den `create-managed-endpoint`-Befehl mit einem Pfad zu der lokal gespeicherten `create-managed-endpoint-request.json`-Datei in Amazon S3.
```
aws emr-containers create-managed-endpoint \
‐‐cli-input-json file://./create-managed-endpoint-request.json ‐‐region AWS-Region
```
## Ausgabe von interaktivem Endpunkt erstellen
Die Ausgabe sollte im Terminal folgendermaßen aussehen. Die Ausgabe enthält den Namen und die Kennung Ihres neuen interaktiven Endpunkts:
```
{
"id": "1234567890abcdef0",
"name": "example-endpoint-name",
"arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666",
"virtualClusterId": "111122223333xxxxxxxx"
}
```
Beim Ausführen von `aws emr-containers create-managed-endpoint` wird ein selbstsigniertes Zertifikat erstellt, das die HTTPS-Kommunikation zwischen EMR Studio und dem interaktiven Endpunktserver ermöglicht.
Wenn Sie `create-managed-endpoint` ausführen und die Voraussetzungen nicht erfüllt haben, gibt Amazon EMR eine Fehlermeldung mit den Maßnahmen zurück, die Sie ergreifen müssen, um fortzufahren.
## Parameter für die Erstellung eines interaktiven Endpunkts
**Topics**
+ [Erforderliche Parameter für interaktive Endpunkte](#parameters-for-creating-required)
+ [Optionale Parameter für interaktive Endpunkte](#parameters-for-creating-optional)
### Erforderliche Parameter für interaktive Endpunkte
Sie müssen die folgenden Parameter angeben, wenn Sie einen interaktiven Endpunkt erstellen:
**`‐‐type`**
Verwenden Sie `JUPYTER_ENTERPRISE_GATEWAY`. Dies ist der einzige unterstützte Typ.
**`‐‐virtual-cluster-id`**
Die ID des virtuellen Clusters, den Sie bei Amazon EMR in EKS registriert haben.
**`‐‐name`**
Ein aussagekräftiger Name für den interaktiven Endpunkt, der EMR-Studio-Benutzern hilft, ihn aus der Dropdownliste auszuwählen.
**`‐‐execution-role-arn`**
Der Amazon-Ressourcenname (ARN) Ihrer IAM-Aufgabenausführungsrolle für Amazon EMR in EKS, die als Teil der Voraussetzungen erstellt wurde.
**`‐‐release-label`**
Die Versionskennung der Amazon-EMR-Version, die für den Endpunkt verwendet werden soll. Beispiel, `emr-6.9.0-latest`. Amazon EMR in EKS unterstützt interaktive Endpunkte mit Amazon-EMR-Versionen 6.7.0 und höher.
### Optionale Parameter für interaktive Endpunkte
Optional können Sie beim Erstellen eines interaktiven Endpunkts auch die folgenden Parameter angeben:
**`‐‐configuration-overrides`**
Um die Standardkonfigurationen für Anwendungen zu überschreiben, geben Sie ein Konfigurationsobjekt an. Sie können eine Syntax-Kurznotation verwenden, um die Konfiguration anzugeben oder Sie können auf die Konfiguration in einer JSON-Datei zu verweisen.
Konfigurationsobjekte bestehen aus einer Klassifizierung, Eigenschaften und optionalen verschachtelten Konfigurationen. Eigenschaften bestehen aus den Einstellungen, die Sie in dieser Datei überschreiben möchten. Sie können mehrere Klassifizierungen für mehrere Anwendungen in einem einzigen JSON-Objekt angeben. Die verfügbaren Konfigurationsklassifizierungen variieren je nach Amazon EMR in EKS-Version. Eine Liste der Konfigurationsklassifizierungen, die für jede Version von Amazon EMR in EKS verfügbar sind, finden Sie unter [Versionen von Amazon EMR in EKS](emr-eks-releases.md). Zusätzlich zu den Konfigurationsklassifizierungen, die für jede Version aufgeführt sind, bieten interaktive Endpunkte zusätzliche `jeg-config`-Klassifizierungen. Weitere Informationen finden Sie unter [Konfigurationsoptionen für Jupyter Enterprise Gateway (JEG)](jeg-config-options.md).
# Konfiguration von Einstellungen für interaktive Endpunkte
Dieser Abschnitt enthält eine Reihe von Themen, die verschiedene Konfigurationen für interaktive Endpunkte und Pod-Einstellungen behandeln. Diese bieten Ihnen die Möglichkeit, Fehler zu überwachen und zu beheben, Protokollinformationen an Amazon S3 oder an Amazon S3 zu senden oder interaktive Endpunkte zu erstellen Amazon CloudWatch Logs, an denen Sie benutzerdefinierte Pod-Vorlagen angeben.
**Topics**
+ [Überwachung von -Spark-Aufträgen](monitoring-spark-jobs.md)
+ [Spezifizierung von benutzerdefinierten Pod-Vorlagen mit interaktiven Endpunkten](custom-pod-templates.md)
+ [Bereitstellen eines JEG-Pods in einer Knotengruppe](managed-endpoint-nodegroups-setup.md)
+ [Konfigurationsoptionen für Jupyter Enterprise Gateway (JEG)](jeg-config-options.md)
+ [PySpark Sitzungsparameter ändern](modify-pyspark-parameters.md)
+ [Benutzerdefiniertes Kernel-Image mit interaktivem Endpunkt](custom-kernel.md)
# Überwachung von -Spark-Aufträgen
Damit Sie Fehler überwachen und beheben können, konfigurieren Sie Ihre interaktiven Endpunkte so, dass die mit dem Endpunkt initiierten Jobs Protokollinformationen an Amazon S3, Amazon CloudWatch Logs oder beide senden können. In den folgenden Abschnitten wird beschrieben, wie Sie Spark-Anwendungsprotokolle für die Spark-Aufträge, die Sie mit Amazon EMR auf interaktiven EKS-Endpunkten starten, an Amazon S3 senden.
**IAM-Richtlinie für Amazon-S3-Protokolle konfigurieren**
Bevor Ihre Kernel Protokolldaten an Amazon S3 senden können, muss die Berechtigungsrichtlinie für die Auftragausführungsrolle die folgenden Berechtigungen enthalten. *amzn-s3-demo-destination-bucket*Ersetzen Sie es durch den Namen Ihres Logging-Buckets.
------
#### [ 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"
}
]
}
```
------
**Anmerkung**
Amazon EMR in EKS kann auch einen S3-Bucket erstellen. Wenn ein S3-Bucket nicht verfügbar ist, nehmen Sie die `s3:CreateBucket`-Erlaubnis in die IAM-Richtlinie auf.
Nachdem Sie Ihrer Ausführungsrolle die erforderlichen Berechtigungen zum Senden von Protokollen an den S3-Bucket erteilt haben, werden Ihre Protokolldaten an die folgenden Amazon-S3-Speicherorte gesendet. Dies geschieht, wenn `s3MonitoringConfiguration` im `monitoringConfiguration`-Abschnitt einer `create-managed-endpoint`-Anfrage übergeben wird.
+ **Treiberprotokolle** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)`
+ **Ausführungsprotokolle** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-/(stderr.gz/stdout.gz)`
**Anmerkung**
Amazon EMR in EKS lädt die Endpunktprotokolle nicht in Ihren S3-Bucket hoch.
# Spezifizierung von benutzerdefinierten Pod-Vorlagen mit interaktiven Endpunkten
Sie können interaktive Endpunkte erstellen, in denen Sie benutzerdefinierte Pod-Vorlagen für Treiber und Ausführer angeben. *Pod-Vorlagen* sind Spezifikationen, die bestimmen, wie jeder Pod ausgeführt wird. Sie können Pod-Vorlagendateien verwenden, um die Konfigurationen von Treiber- oder Ausführer-Pods zu definieren, die von Spark-Konfigurationen nicht unterstützt werden. Pod-Vorlagen werden derzeit in Amazon-EMR-Versionen 6.3.0 und höher unterstützt.
Weitere Informationen zu Pod-Vorlagen finden Sie unter [Verwenden von Pod-Vorlagen](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html) im *Entwicklerhandbuch zu Amazon EMR in EKS*.
Das folgende Beispiel zeigt, wie Sie einen interaktiven Endpunkt mit Pod-Vorlagen erstellen:
```
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"
}
}]
}'
```
# Bereitstellen eines JEG-Pods in einer Knotengruppe
Die Platzierung von JEG-Pods (Jupyter Enterprise Gateway) ist ein Feature, mit dem Sie einen interaktiven Endpunkt auf einer bestimmten Knotengruppe bereitstellen können. Mit diesem Feature können Sie Einstellungen wie `instance type` für den interaktiven Endpunkt konfigurieren.
## Zuordnen eines JEG-Pods zu einer verwalteten Knotengruppe
Mit der folgenden Konfigurationseigenschaft können Sie den Namen einer verwalteten Knotengruppe auf Ihrem Amazon-EKS-Cluster angeben, in der der JEG-Pod bereitgestellt wird.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Bei einer Knotengruppe muss die Kubernetes-Kennung `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` an alle Knoten angehängt sein, die Teil der Knotengruppe sind. Um alle Knoten einer Knotengruppe aufzulisten, die dieses Tag haben, verwenden Sie den folgenden Befehl:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Wenn die Ausgabe des obigen Befehls keine Knoten zurückgibt, die Teil Ihrer verwalteten Knotengruppe sind, dann gibt es in der Knotengruppe keine Knoten, denen die `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName`-Kubernetes-Kennzeichnung zugewiesen ist. Führen Sie in diesem Fall die folgenden Schritte aus, um diese Kennzeichnung den Knoten in Ihrer Knotengruppe zuzuordnen.
1. Verwenden Sie den folgenden Befehl, um die `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName`-Kubernetes-Kennzeichnung allen Knoten in einer verwalteten Knotengruppe `NodeGroupName` hinzuzufügen:
```
kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
1. Um alle verfügbaren Befehle aufzulisten, führen Sie den folgenden Befehl aus:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Eine verwaltete Knotengruppe muss der Sicherheitsgruppe eines Amazon-EKS-Clusters zugeordnet sein. Dies ist normalerweise der Fall, wenn Sie Ihren Cluster und Ihre verwaltete Knotengruppe mithilfe von `eksctl` erstellt haben. Sie können dies in der AWS Konsole anhand der folgenden Schritte überprüfen.
1. Gehen Sie in der Amazon-EKS-Konsole zu Ihrem Cluster.
1. Gehen Sie zur Registerkarte Netzwerk Ihres Clusters und notieren Sie sich die Cluster-Sicherheitsgruppe.
1. Gehen Sie zur Registerkarte Compute Ihres Clusters und klicken Sie auf den Namen der verwalteten Knotengruppe.
1. Vergewissern Sie sich auf der Registerkarte **Details** der verwalteten Knotengruppe, dass die Cluster-Sicherheitsgruppe, die Sie zuvor notiert haben, unter **Sicherheitsgruppen** aufgeführt ist.
Wenn die verwaltete Knotengruppe nicht an die Amazon-EKS-Cluster-Sicherheitsgruppe angehängt ist, müssen Sie das `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`-Tag an die Sicherheitsgruppe der Knotengruppe anhängen. Führen Sie die unten folgenden Schritte aus, um diesen Tag anzuhängen.
1. Gehen Sie zur Amazon-EC2-Konsole und klicken Sie im linken Navigationsbereich auf Sicherheitsgruppen.
1. Wählen Sie die Sicherheitsgruppe Ihrer verwalteten Knotengruppe aus, indem Sie auf das Kontrollkästchen klicken.
1. Fügen Sie auf der Registerkarte **Tags** das Tag `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` mithilfe der Schaltfläche **Tags verwalten** hinzu.
## Zuordnen eines JEG-Pods zu einer selbstverwalteten Knotengruppe
Mit der folgenden Konfigurationseigenschaft können Sie den Namen einer selbstverwalteten oder nicht verwalteten Knotengruppe auf dem Amazon-EKS-Cluster angeben, auf dem der JEG-Pod bereitgestellt wird.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"self-managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Bei einer Knotengruppe muss die Kubernetes-Kennung `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` an alle Knoten angehängt sein, die Teil der Knotengruppe sind. Um alle verfügbaren Parameter aufzulisten, verwenden Sie den folgenden Befehl:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Wenn die Ausgabe des obigen Befehls keine Knoten zurückgibt, die Teil Ihrer selbstverwalteten Knotengruppe sind, dann gibt es in der Knotengruppe keine Knoten, denen die `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` Kubernetes-Kennzeichnung zugewiesen ist. Führen Sie in diesem Fall die folgenden Schritte aus, um diese Kennzeichnung den Knoten in Ihrer Knotengruppe zuzuordnen.
1. Wenn Sie die selbstverwaltete Knotengruppe mit `eksctl` erstellt haben, verwenden Sie den folgenden Befehl, um das `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName`-Kubernetes-Label allen Knoten in der selbstverwalteten Knotengruppe `NodeGroupName` auf einmal hinzuzufügen.
```
kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Wenn Sie `eksctl` nicht zum Erstellen der selbstverwalteten Knotengruppe verwendet haben, müssen Sie den Selektor im obigen Befehl durch eine andere Kubernetes-Kennzeichnung ersetzen, die allen Knoten der Knotengruppe zugeordnet ist.
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob die Knoten korrekt beschriftet wurden:
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Der Sicherheitsgruppe für die selbstverwaltete Knotengruppe muss das `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`-Tag zugeordnet sein. Gehen Sie wie folgt vor, um das Tag an die Sicherheitsgruppe von AWS-Managementkonsole anzuhängen.
1. Navigieren Sie zur Amazon-EC2-Konsole. Wählen Sie im linken Navigationsbereich **Sicherheitsgruppen**.
1. Aktivieren Sie das Kontrollkästchen neben der Sicherheitsgruppe für Ihre selbstverwaltete Knotengruppe.
1. Verwenden Sie auf der Registerkarte **Tags** die Schaltfläche **Tags verwalten**, um das Tag `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` hinzuzufügen. Ersetzen Sie `ClusterName` und `NodeGroupName` durch entsprechende Werte.
## Zuordnen eines JEG-Pods zu einer verwalteten Knotengruppe mit On-Demand-Instances
Sie können auch zusätzliche Kennzeichnungen, sogenannte *Kubernetes-Kennzeichnungsselektoren*, definieren, um zusätzliche Einschränkungen oder Einschränkungen für die Ausführung eines interaktiven Endpunkts auf einem bestimmten Knoten oder einer bestimmten Knotengruppe festzulegen. Das folgende Beispiel zeigt, wie On-Demand-Amazon-EC2-Instances für einen JEG-Pod verwendet werden.
```
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName,
"node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
}
}
]
}'
```
**Anmerkung**
Sie können die Eigenschaft `node-labels` nur zusammen mit der Eigenschaft `managed-nodegroup-name` oder `self-managed-nodegroup-name` verwenden.
# Konfigurationsoptionen für Jupyter Enterprise Gateway (JEG)
Amazon EMR in EKS verwendet Jupyter Enterprise Gateway (JEG), um interaktive Endpunkte zu aktivieren. Sie können die folgenden Werte für die JEG-Konfigurationen auf der Zulassungsliste festlegen, wenn Sie den Endpunkt erstellen.
+ **`RemoteMappingKernelManager.cull_idle_timeout`** – Timeout in Sekunden (Ganzzahl), nach dessen Ablauf ein Kernel als inaktiv betrachtet wird und bereit ist, gelöscht zu werden. Werte von `0` oder niedriger deaktivieren das Culling. Kurze Timeouts können dazu führen, dass Kernel für Benutzer mit schlechten Netzwerkverbindungen entfernt werden.
+ **`RemoteMappingKernelManager.cull_interval`** – Das Intervall in Sekunden (Ganzzahl), in dem nach Kerneln im Leerlauf gesucht werden soll, die den Wert für das Cull-Timeout überschreiten.
# PySpark Sitzungsparameter ändern
Ab Amazon EMR auf EKS-Version 6.9.0 können Sie in Amazon EMR Studio die mit einer PySpark Sitzung verknüpfte Spark-Konfiguration anpassen, indem Sie den `%%configure` magischen Befehl in der EMR-Notebookzelle ausführen.
Das folgende Beispiel zeigt eine Beispielnutzlast, mit der Sie Speicher, Kerne und andere Eigenschaften für den Spark-Treiber und Executor ändern können. Für die `conf`-Einstellungen können Sie jede Spark-Konfiguration konfigurieren, die in der [Apache-Spark-Konfigurationsdokumentation](https://spark.apache.org/docs/latest/configuration.html) erwähnt wird.
```
%%configure -f
{
"driverMemory": "16G",
"driverCores": 4,
"executorMemory" : "32G",
"executorCores": 2,
"conf": {
"spark.dynamicAllocation.maxExecutors" : 10,
"spark.dynamicAllocation.minExecutors": 1
}
}
```
Das folgende Beispiel zeigt eine Beispielnutzlast, die Sie verwenden können, um Dateien, PyFiles und JAR-Abhängigkeiten zu einer Spark-Laufzeit hinzuzufügen.
```
%%configure -f
{
"files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt",
"pyFiles": : "path-to-python-files",
"jars" : "path-to-jars
}
```
# Benutzerdefiniertes Kernel-Image mit interaktivem Endpunkt
Um sicherzustellen, dass Sie die richtigen Abhängigkeiten für Ihre Anwendung haben, wenn Sie interaktive Workloads von Amazon EMR Studio aus ausführen, können Sie Docker-Images für interaktive Endpunkte anpassen und benutzerdefinierte Basis-Kernel-Images ausführen. Um einen interaktiven Endpunkt zu erstellen und ihn mit einem benutzerdefinierten Docker-Image zu verbinden, führen Sie die folgenden Schritte aus.
**Anmerkung**
Sie können nur Basis-Images überschreiben. Sie können keine neuen Kernel-Image-Typen hinzufügen.
1. **Erstellen und veröffentlichen Sie ein benutzerdefiniertes Docker-Image.** Das Basis-Image enthält die Spark-Laufzeit und die Notebook-Kernel, die damit ausgeführt werden. Um das Image zu erstellen, können Sie die Schritte 1 bis 4 unter [Wie passen Sie Docker-Images an](docker-custom-images-steps.md) ausführen. In Schritt 1 muss der Basis-Image-URI in Ihrer Docker-Datei `notebook-spark` anstelle von `spark` verwendet werden.
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Weitere Informationen zur Auswahl AWS-Regionen und Speicherung von Image-Tags finden Sie unter. [Details zur Auswahl einer Basis-Image-URI](docker-custom-images-tag.md)
1. **Erstellen Sie einen interaktiven Endpunkt, der mit dem benutzerdefinierten Image verwendet werden kann.**
1. Erstellen Sie eine JSON Datei mit dem Namen `custom-image-managed-endpoint.json` und dem folgenden Inhalt. In diesem Beispiel wird Amazon-EMR-Version 6.9.0 verwendet.
**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. Erstellen Sie einen interaktiven Endpunkt mit den in der JSON-Datei angegebenen Konfigurationen, wie das folgende Beispiel zeigt. Weitere Informationen finden Sie unter [Erstellen Sie einen interaktiven Endpunkt mit dem `create-managed-endpoint`-Befehl](create-managed-endpoint.md#create-using-json-file).
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```
1. **Stellen Sie über EMR Studio eine Verbindung zum interaktiven Endpunkt her.** Weitere Informationen und auszuführende Schritte finden Sie unter [Von Studio aus verbinden](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html) im Abschnitt Amazon EMR on EKS der AWS Workshop Studio-Dokumente.
# Überwachen interaktiver Endpunkte
Mit Amazon EMR auf EKS-Version 6.10 und höher senden interaktive Endpunkte CloudWatch Amazon-Metriken zur Überwachung und Fehlerbehebung von Kernel-Lebenszyklusvorgängen aus. Metriken werden durch interaktive Clients wie EMR Studio oder selbst gehostete Jupyter Notebooks ausgelöst. Jedem Vorgang, der von interaktiven Endpunkten unterstützt wird, sind Metriken zugeordnet. Die Vorgänge werden als Dimensionen für jede Metrik modelliert, wie in der folgenden Tabelle dargestellt. Von interaktiven Endpunkten ausgegebene Metriken sind in Ihrem Konto unter einem benutzerdefinierten Namespace sichtbar. EMRContainers
| Metrik | Description | Einheit |
| --- | --- | --- |
| RequestCount | Gesamtzahl der Anfragen eines Vorgangs, die vom interaktiven Endpunkt verarbeitet wurden. | Anzahl |
| RequestLatency | Der Zeitpunkt, zu dem eine Anfrage am interaktiven Endpunkt eingetroffen ist und eine Antwort vom interaktiven Endpunkt gesendet wurde. | Millisekunde |
| 4 XXError | Wird ausgegeben, wenn eine Anforderung für einen Vorgang bei der Verarbeitung zu einem 4xx-Fehler führt. | Anzahl |
| 5XXError | Wird ausgegeben, wenn eine Anforderung für einen Vorgang zu einem serverseitigen 5XXX-Fehler führt. | Anzahl |
| KernelLaunchSuccess | Gilt nur für die CreateKernel Operation. Es gibt die Gesamtzahl der Kernelstarts an, die bis einschließlich dieser Anforderung erfolgreich waren. | Anzahl |
| KernelLaunchFailure | Gilt nur für die CreateKernel Operation. Es gibt die Gesamtzahl der Fehler beim Starten des Kernels bis einschließlich dieser Anforderung an. | Anzahl |
Jeder interaktiven Endpunktmetrik sind die folgenden Dimensionen zugeordnet:
+ **`ManagedEndpointId`** – Bezeichner für den interaktiven Endpunkt
+ **`OperationName`** – Der vom interaktiven Client ausgelöste Vorgang
Mögliche Werte für die **`OperationName`**-Dimension werden in der folgenden Tabelle aufgeführt:
| `operationName` | Beschreibung des Vorgangs |
| --- | --- |
| `CreateKernel` | Fordert an, dass der interaktive Endpunkt einen Kernel startet. |
| `ListKernels` | Fordern Sie an, dass der interaktive Endpunkt die Kernel auflistet, die zuvor mit demselben Sitzungstoken gestartet wurden. |
| `GetKernel` | Fordern Sie an, dass der interaktive Endpunkt Details zu einem bestimmten Kernel erhält, der zuvor gestartet wurde. |
| `ConnectKernel` | Fordert den interaktiven Endpunkt auf, die Konnektivität zwischen dem Notebook-Client und dem Kernel herzustellen. |
| `ConfigureKernel` | Veröffentlichen Sie `%%configure magic request` auf einem Pyspark-Kernel. |
| `ListKernelSpecs` | Fordern Sie an, dass der interaktive Endpunkt die verfügbaren Kernel-Spezifikationen auflistet. |
| `GetKernelSpec` | Fordern Sie an, dass der interaktive Endpunkt die Kernel-Spezifikationen eines Kernels erhält, der zuvor gestartet wurde. |
| `GetKernelSpecResource` | Fordern Sie an, dass der interaktive Endpunkt spezifische Ressourcen erhält, die mit den zuvor gestarteten Kernel-Spezifikationen verknüpft sind. |
## Beispiele
### Um auf die Gesamtzahl der Kernel zuzugreifen, die an einem bestimmten Tag für einen interaktiven Endpunkt gestartet wurden, gehen Sie wie folgt vor:
1. Wählen Sie den benutzerdefinierten Namespace aus: `EMRContainers`
1. Wählen Sie `ManagedEndpointId`, `OperationName – CreateKernel`
1. `RequestCount`-Metrik mit der Statistik `SUM` und dem Zeitraum `1 day` liefert alle Kernel-Startanfragen der letzten 24 Stunden.
1. KernelLaunchSuccess Die Metrik mit Statistik `SUM` und Zeitraum `1 day` liefert alle erfolgreichen Kernel-Startanfragen der letzten 24 Stunden.
### Um auf die Anzahl der Kernelfehler für einen interaktiven Endpunkt an einem bestimmten Tag zuzugreifen:
1. Wählen Sie den benutzerdefinierten Namespace aus: EMRContainers
1. Wählen Sie `ManagedEndpointId`, `OperationName – CreateKernel`
1. `KernelLaunchFailure`-Metrik mit der Statistik `SUM` und dem Zeitraum `1 day` liefert alle fehlgeschlagenen Kernel-Startanfragen der letzten 24 Stunden. Sie können auch die `4XXError`- und `5XXError`-Metrik auswählen, um zu erfahren, welche Art von Kernelstartfehler aufgetreten ist.
# Verwenden von selbst gehosteten Jupyter Notebooks
*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
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
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
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
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
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 <
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
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.
# Informationen zu interaktiven Endpunkten mit CLI-Befehlen abrufen
Dieses Thema behandelt die unterstützten Operationen auf einem anderen interaktiven Endpunkt als [`create-managed-endpoint`](create-managed-endpoint.md).
## Rufen Sie interaktive Endpunktdetails ab
Nachdem Sie einen interaktiven Endpunkt erstellt haben, können Sie dessen Details mit dem `describe-managed-endpoint` AWS CLI Befehl abrufen. Fügen Sie Ihre eigenen Werte für *managed-endpoint-id**virtual-cluster-id*, und ein*region*:
```
aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \
‐‐virtual-cluster-id virtual-cluster-id ‐‐region region
```
Die Ausgabe sieht mit dem angegebenen Endpunkt, wie ARN, ID und Name, in etwa wie folgt aus.
```
{
"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": {}
}
```
## Listen Sie alle interaktiven Endpunkte auf, die einem virtuellen Cluster zugeordnet sind
Verwenden Sie den `list-managed-endpoints` AWS CLI Befehl, um eine Liste aller interaktiven Endpunkte abzurufen, die einem bestimmten virtuellen Cluster zugeordnet sind. Ersetzen Sie `virtual-cluster-id` mit dem ID Ihres virtuellen Clusters.
```
aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id
```
Die Ausgabe des `list-managed-endpoint` Befehls ist unten dargestellt:
```
{
"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": {}
}]
}
```
# Löschen eines interaktiven Endpunkts
Verwenden Sie den `delete-managed-endpoint` AWS CLI Befehl, um einen interaktiven Endpunkt zu löschen, der mit einem virtuellen Amazon EMR auf einem EKS-Cluster verknüpft ist. Wenn Sie einen interaktiven Endpunkt löschen, entfernt Amazon EMR in EKS die Standardsicherheitsgruppen, die für diesen Endpunkt erstellt wurden.
Geben Sie Werte für die folgenden Parameter für den Befehl an:
+ **‐‐id:** Die Kennung des interaktiven Endpunkts, den Sie löschen möchten.
+ **‐‐ virtual-cluster-id** — Die ID des virtuellen Clusters, der dem interaktiven Endpunkt zugeordnet ist, den Sie löschen möchten. Dies ist dieselbe virtuelle Cluster-ID, die bei der Erstellung des interaktiven Endpunkts angegeben wurde.
```
aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id
```
Der Befehl gibt eine Ausgabe ähnlich der folgenden zurück, um zu bestätigen, dass Sie den interaktiven Endpunkt gelöscht haben:
```
{
"id":"8gai4l4exxxxx",
"virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx"
}
```