Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de Volcano comme planificateur personnalisé pour Apache Spark sur Amazon EMR on EKS
Avec Amazon EMR on EKS, vous avez la possibilité d'utiliser l'opérateur Spark ou la commande spark-submit pour lancer des tâches Spark en utilisant des planificateurs personnalisés Kubernetes. Ce didacticiel explique comment exécuter des tâches Spark avec un planificateur Volcano sur une file d'attente personnalisée.
## Présentation de
[Volcano](https://volcano.sh/en/) peut aider à gérer la planification Spark grâce à des fonctions avancées telles que la planification des files d'attente, la planification du partage équitable et la réservation de ressources. *Pour plus d'informations sur les avantages de Volcano, consultez l'article [Pourquoi Spark choisit Volcano comme planificateur de lots intégré sur Kubernetes](https://www.cncf.io/blog/2022/06/30/why-spark-chooses-volcano-as-built-in-batch-scheduler-on-kubernetes/) sur le blog CNCF* de Linux Foundation.
## Installation et configuration de Volcano
1. Choisissez l'une des commandes kubectl ci-dessous pour installer Volcano, en fonction de vos besoins architecturaux :
```
# 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. Préparez un exemple de file d'attente Volcano. Une file d'attente est un ensemble de [PodGroups](https://volcano.sh/en/docs/podgroup/). La file d'attente utilise le principe FIFO et constitue la base de la répartition des ressources.
```
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. Téléchargez un exemple de PodGroup manifeste sur Amazon S3. PodGroup est un groupe de capsules fortement associées. Vous utilisez généralement un PodGroup pour la planification par lots. Soumettez l'exemple suivant PodGroup à la file d'attente que vous avez définie à l'étape précédente.
```
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
```
## Exécution d'une application Spark avec le planificateur Volcano à l'aide de l'opérateur Spark
1. Si vous ne l'avez pas encore fait, suivez les étapes indiquées dans les sections ci-dessous pour vous préparer :
1. [Installation et configuration de Volcano](#tutorial-volcano-install)
1. [Configuration de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-setup.md)
1. [Installation de l'opérateur Spark](spark-operator-gs.md#spark-operator-install)
Incluez les arguments suivants lorsque vous exécutez la commande `helm install spark-operator-demo` :
```
--set batchScheduler.enable=true
--set webhook.enable=true
```
1. Créez un fichier de définition `SparkApplication` `spark-pi.yaml` avec `batchScheduler` configuré.
```
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. Soumettez l'application Spark à l'aide de la commande suivante. Cela crée également un objet `SparkApplication` appelé `spark-pi` :
```
kubectl apply -f spark-pi.yaml
```
1. Vérifiez les événements de l'objet `SparkApplication` à l'aide de la commande suivante :
```
kubectl describe pods spark-pi-driver --namespace spark-operator
```
Le premier événement du pod montrera que Volcano a programmé les pods :
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```
## Exécution d'une application Spark avec le planificateur Volcano à l'aide de `spark-submit`
1. Effectuez d'abord les étapes décrites dans la section [Configuration de spark-submit pour Amazon EMR on EKS](spark-submit-setup.md). Vous devez créer votre distribution `spark-submit` en y incluant la prise en charge de Volcano. Pour plus d'informations, consultez la **section Création** de la rubrique [Utilisation de Volcano comme planificateur personnalisé pour Spark sur Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html#build) dans la *documentation Apache Spark*.
1. Définissez les valeurs des variables d'environnement suivantes :
```
export SPARK_HOME=spark-home
export MASTER_URL=k8s://Amazon-EKS-cluster-endpoint
```
1. Soumettez l'application Spark à l'aide de la commande suivante :
```
$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. Vérifiez les événements de l'objet `SparkApplication` à l'aide de la commande suivante :
```
kubectl describe pod spark-pi --namespace spark-operator
```
Le premier événement du pod montrera que Volcano a programmé les pods :
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```