Überwachung von Spark-Aufträgen Benutzerdefinierte Pod-vorlagen Bereitstellen eines JEG Pods in einer Knotengruppe JEGKonfigurationsoptionen PySparkParameter ändern Benutzerdefiniertes Kernel-Image

Konfiguration von Einstellungen für interaktive Endpunkte

Ü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-Jobs, die Sie mit Amazon EMR auf EKS interaktiven Endpunkten starten, an Amazon S3 senden.

IAMRichtlinie für Amazon S3 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. Ersetzen DOC-EXAMPLE-BUCKET-LOGGING mit dem Namen Ihres Logging-Buckets.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING",
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING/*",
            ]
        }
    ]
}

Anmerkung

Amazon EMR on 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-<Number>/(stderr.gz/stdout.gz)

Anmerkung

Amazon EMR on lädt die Endpunktprotokolle EKS 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 EMR Amazon-Versionen 6.3.0 und höher unterstützt.

Weitere Informationen zu Pod-Vorlagen finden Sie unter Verwenden von Pod-Vorlagen im Amazon EMR on EKS Development Guide.

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

JEG(Jupyter Enterprise Gateway) Die Pod-Platzierung ist eine Funktion, mit der 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.

Einen JEG Pod einer verwalteten Knotengruppe zuordnen

Mit der folgenden Konfigurationseigenschaft können Sie den Namen einer verwalteten Knotengruppe in Ihrem EKS Amazon-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.

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

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 EKS Amazon-Clusters zugeordnet werden. Dies ist normalerweise der Fall, wenn Sie Ihren Cluster und Ihre verwaltete Knotengruppe mithilfe von erstellt habeneksctl. Sie können dies in der AWS Konsole anhand der folgenden Schritte überprüfen.

Gehen Sie in der EKS Amazon-Konsole zu Ihrem Cluster.
Gehen Sie zur Registerkarte Netzwerk Ihres Clusters und notieren Sie sich die Cluster-Sicherheitsgruppe.
Gehen Sie zur Registerkarte Compute Ihres Clusters und klicken Sie auf den Namen der verwalteten Knotengruppe.
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 EKS Amazon-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.

Gehen Sie zur EC2 Amazon-Konsole und klicken Sie im linken Navigationsbereich auf Sicherheitsgruppen.
Wählen Sie die Sicherheitsgruppe Ihrer verwalteten Knotengruppe aus, indem Sie auf das Kontrollkästchen klicken.
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.

Einen JEG Pod einer selbstverwalteten Knotengruppe zuordnen

Mit der folgenden Konfigurationseigenschaft können Sie den Namen einer selbstverwalteten oder nicht verwalteten Knotengruppe auf dem EKS Amazon-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.

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.

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 Management Console anzuhängen.

Navigieren Sie zur EC2 Amazon-Konsole. Wählen Sie im linken Navigationsbereich Sicherheitsgruppen.
Aktivieren Sie das Kontrollkästchen neben der Sicherheitsgruppe für Ihre selbstverwaltete Knotengruppe.
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 EC2 On-Demand-Amazon-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 on EKS verwendet Jupyter Enterprise Gateway (JEG), um interaktive Endgeräte 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.

Sitzungsparameter ändern PySpark

Ab EMR Amazon 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 Notebook-Zelle 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 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 Beispiel-Payload, die Sie verwenden könnenpyFiles, um Dateien und JAR-Abhängigkeiten zu einer Spark-Laufzeit hinzuzufügen.


%%configure -f
{
  "files": "s3://test-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.

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 ausführen. In Schritt 1 muss das Basis-Image URI in Ihrer Docker-Datei anstelle von verwendet notebook-spark werden. spark
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Weitere Informationen zur Auswahl AWS-Regionen und zum Containern von Image-Tags finden Sie unterWie wählt man ein Basis-Image aus URI.

Erstellen Sie einen interaktiven Endpunkt, der mit dem benutzerdefinierten Image verwendet werden kann.

Erstellen Sie eine JSON Datei custom-image-managed-endpoint.json mit dem folgenden Inhalt. In diesem Beispiel wird EMR Amazon-Version 6.9.0 verwendet.


{
    "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"
                        }
                    }
                ] 
            }
        ]
    }
}

Erstellen Sie einen interaktiven Endpunkt mit den in der JSON Datei angegebenen Konfigurationen, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter Erstellen Sie einen interaktiven Endpunkt mit dem create-managed-endpoint-Befehl.
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```

Stellen Sie über EMR Studio Connect zum interaktiven Endpunkt her. Weitere Informationen und auszuführende Schritte finden Sie im EKS Abschnitt Connecting from Studio in Amazon EMR on der AWS Workshop Studio-Dokumentation.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen eines interaktiven Schnittstellenendpunkts

Überwachen interaktiver Endpunkte