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.
# Verwendung von Volcano als benutzerdefiniertem Scheduler für Apache Spark auf Amazon EMR in EKS
Mit Amazon EMR in EKS können Sie Spark-Operator oder Spark-Submit verwenden, um Spark-Aufträge mit benutzerdefinierten Kubernetes-Planern auszuführen. In diesem Tutorial erfahren Sie, wie Sie Spark-Aufträge mit einem Volcano-Planer in einer benutzerdefinierten Warteschlange ausführen.
## -Übersicht
[Volcano](https://volcano.sh/en/) kann Sie bei der Verwaltung der Spark-Planung mit erweiterten Funktionen wie Warteschlangenplanung, Fair-Share-Planung und Ressourcenreservierung unterstützen. Weitere Informationen zu den Vorteilen von Volcano finden Sie in [Warum Spark Volcano als integrierten Batch-Planer auf Kubernetes auswählt](https://www.cncf.io/blog/2022/06/30/why-spark-chooses-volcano-as-built-in-batch-scheduler-on-kubernetes/) im *CNCF-Blog* der Linux Foundation.
## Installieren und einrichten von Volcano
1. Wählen Sie einen der folgenden kubectl-Befehle, um Volcano je nach Ihrem architektonischen Bedarf zu installieren:
```
# x86_64
kubectl apply -f https://raw.githubusercontent.com/volcano-sh/volcano/v1.5.1/installer/volcano-development.yaml
# arm64:
kubectl apply -f https://raw.githubusercontent.com/volcano-sh/volcano/v1.5.1/installer/volcano-development-arm64.yaml
```
1. Bereiten Sie eine Volcano-Beispielwarteschlange vor. Eine Warteschlange ist eine Sammlung von [PodGroups](https://volcano.sh/en/docs/podgroup/). Die Warteschlange verwendet FIFO und ist die Grundlage für die Aufteilung der Ressourcen.
```
cat << EOF > volcanoQ.yaml
apiVersion: scheduling.volcano.sh/v1beta1
kind: Queue
metadata:
name: sparkqueue
spec:
weight: 4
reclaimable: false
capability:
cpu: 10
memory: 20Gi
EOF
kubectl apply -f volcanoQ.yaml
```
1. Laden Sie ein PodGroup Mustermanifest auf Amazon S3 hoch. PodGroup ist eine Gruppe von Pods mit starker Assoziation. Normalerweise verwenden Sie a PodGroup für die Batch-Planung. Senden Sie das folgende Beispiel PodGroup an die Warteschlange, die Sie im vorherigen Schritt definiert haben.
```
cat << EOF > podGroup.yaml
apiVersion: scheduling.volcano.sh/v1beta1
kind: PodGroup
spec:
# Set minMember to 1 to make a driver pod
minMember: 1
# Specify minResources to support resource reservation.
# Consider the driver pod resource and executors pod resource.
# The available resources should meet the minimum requirements of the Spark job
# to avoid a situation where drivers are scheduled, but they can't schedule
# sufficient executors to progress.
minResources:
cpu: "1"
memory: "1Gi"
# Specify the queue. This defines the resource queue that the job should be submitted to.
queue: sparkqueue
EOF
aws s3 mv podGroup.yaml s3://bucket-name
```
## Führen Sie eine Spark-Anwendung mit Volcano Scheduler und dem Spark-Operator aus
1. Sofern noch nicht geschehen, stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:
1. [Installieren und einrichten von Volcano](#tutorial-volcano-install)
1. [Einrichten des Spark-Operators für Amazon EMR in EKS](spark-operator-setup.md)
1. [Den Spark-Operator installieren](spark-operator-gs.md#spark-operator-install)
Geben Sie bei der Ausführung des `helm install spark-operator-demo`-Befehls die folgenden Argumente an:
```
--set batchScheduler.enable=true
--set webhook.enable=true
```
1. Erstellen Sie eine `SparkApplication`-Definitionsdatei `spark-pi.yaml` mit der `batchScheduler`-Konfiguration.
```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
name: spark-pi
namespace: spark-operator
spec:
type: Scala
mode: cluster
image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
imagePullPolicy: Always
mainClass: org.apache.spark.examples.SparkPi
mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
sparkVersion: "3.3.1"
batchScheduler: "volcano" #Note: You must specify the batch scheduler name as 'volcano'
restartPolicy:
type: Never
volumes:
- name: "test-volume"
hostPath:
path: "/tmp"
type: Directory
driver:
cores: 1
coreLimit: "1200m"
memory: "512m"
labels:
version: 3.3.1
serviceAccount: emr-containers-sa-spark
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
executor:
cores: 1
instances: 1
memory: "512m"
labels:
version: 3.3.1
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
```
1. Senden Sie die Spark-Anwendung mit dem folgenden Befehl. Dadurch wird auch ein `SparkApplication`-Objekt mit dem Namen `spark-pi` erstellt:
```
kubectl apply -f spark-pi.yaml
```
1. Überprüfen Sie die Ereignisse für das `SparkApplication`-Objekt mit dem folgenden Befehl:
```
kubectl describe pods spark-pi-driver --namespace spark-operator
```
Das erste Pod-Ereignis zeigt, dass Volcano die Pods geplant hat:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```
## Führen Sie eine Spark-Anwendung mit Volcano Scheduler mit `spark-submit` aus
1. Führen Sie zunächst die Schritte in diesem [Einrichten von spark-submit für Amazon EMR in EKS](spark-submit-setup.md)-Abschnitt durch. Sie müssen Ihre `spark-submit` Distribution mit Volcano-Unterstützung erstellen. Weitere Informationen finden Sie im **Abschnitt Erstellung** unter [Verwendung von Volcano als benutzerdefinierter Planer für Spark in Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html#build) in der *Apache-Spark-Dokumentation.*
1. Legen Sie die Werte der folgenden Umgebungsvariablen fest:
```
export SPARK_HOME=spark-home
export MASTER_URL=k8s://Amazon-EKS-cluster-endpoint
```
1. Senden Sie die Spark-Anwendung mit dem folgenden Befehl:
```
$SPARK_HOME/bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master $MASTER_URL \
--conf spark.kubernetes.container.image=895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest \
--conf spark.kubernetes.authenticate.driver.serviceAccountName=spark \
--deploy-mode cluster \
--conf spark.kubernetes.namespace=spark-operator \
--conf spark.kubernetes.scheduler.name=volcano \
--conf spark.kubernetes.scheduler.volcano.podGroupTemplateFile=/path/to/podgroup-template.yaml \
--conf spark.kubernetes.driver.pod.featureSteps=org.apache.spark.deploy.k8s.features.VolcanoFeatureStep \
--conf spark.kubernetes.executor.pod.featureSteps=org.apache.spark.deploy.k8s.features.VolcanoFeatureStep \
local:///usr/lib/spark/examples/jars/spark-examples.jar 20
```
1. Überprüfen Sie die Ereignisse für das `SparkApplication`-Objekt mit dem folgenden Befehl:
```
kubectl describe pod spark-pi --namespace spark-operator
```
Das erste Pod-Ereignis zeigt, dass Volcano die Pods geplant hat:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```