Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Uso di Volcano come pianificatore personalizzato per Apache Spark in Amazon EMR su EKS
Con Amazon EMR su EKS, puoi utilizzare l'operatore Spark o spark-submit per eseguire processi Spark con pianificatori personalizzati di Kubernetes. Questo tutorial spiega come eseguire processi Spark con un pianificatore Volcano su una coda personalizzata.
## Panoramica di
[Volcano](https://volcano.sh/en/) può aiutarti a gestire la pianificazione di Spark con funzioni avanzate come la pianificazione delle code, la pianificazione della quota equa e la prenotazione delle risorse. Per ulteriori informazioni sui vantaggi di Volcano, consulta [Perché Spark sceglie Volcano come pianificatore in batch integrato su Kubernetes](https://www.cncf.io/blog/2022/06/30/why-spark-chooses-volcano-as-built-in-batch-scheduler-on-kubernetes/) nel *blog CNCF* di Linux Foundation.
## Installazione e configurazione di Volcano
1. Scegli uno dei comandi kubectl seguenti per installare Volcano, a seconda delle tue esigenze architettoniche:
```
# 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. Prepara una coda Volcano campione. Una coda è una raccolta di. [PodGroups](https://volcano.sh/en/docs/podgroup/) La coda adotta FIFO ed è la base per la divisione delle risorse.
```
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. Carica un PodGroup manifesto di esempio su Amazon S3. PodGroup è un gruppo di pod con forti associazioni. In genere si utilizza un PodGroup per la pianificazione in batch. Inviate il seguente esempio PodGroup alla coda definita nel passaggio precedente.
```
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
```
## Esecuzione di un'applicazione Spark con pianificatore Volcano con l'operatore Spark
1. Se non l'hai già fatto, completa la procedura nelle seguenti sezioni per effettuare la configurazione:
1. [Installazione e configurazione di Volcano](#tutorial-volcano-install)
1. [Configurazione dell'operatore Spark per Amazon EMR su EKS](spark-operator-setup.md)
1. [Installazione dell'operatore Spark](spark-operator-gs.md#spark-operator-install)
Quando esegui il comando `helm install spark-operator-demo`, includi gli argomenti seguenti:
```
--set batchScheduler.enable=true
--set webhook.enable=true
```
1. Crea un file di definizione `SparkApplication` `spark-pi.yaml` con la configurazione di `batchScheduler`.
```
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. Invia l'applicazione Spark con il comando seguente. Questa operazione crea anche un oggetto `SparkApplication` denominato `spark-pi`:
```
kubectl apply -f spark-pi.yaml
```
1. Controlla gli eventi dell'oggetto `SparkApplication` con il comando seguente:
```
kubectl describe pods spark-pi-driver --namespace spark-operator
```
Il primo evento di pod mostrerà che Volcano ha programmato i pod:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```
## Esecuzione di un'applicazione Spark con pianificatore Volcano con `spark-submit`
1. Per prima cosa, completa le fasi indicate nella sezione [Configurazione di spark-submit per Amazon EMR su EKS](spark-submit-setup.md). Devi creare la tua distribuzione `spark-submit` con il supporto di Volcano. Per ulteriori informazioni, consulta la **sezione Creazione** di [Uso di Volcano come pianificatore personalizzato per Spark su Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html#build) nella *documentazione di Apache Spark.*
1. Imposta i valori delle seguenti variabili di ambiente:
```
export SPARK_HOME=spark-home
export MASTER_URL=k8s://Amazon-EKS-cluster-endpoint
```
1. Invia l'applicazione Spark con il comando seguente:
```
$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. Controlla gli eventi dell'oggetto `SparkApplication` con il comando seguente:
```
kubectl describe pod spark-pi --namespace spark-operator
```
Il primo evento di pod mostrerà che Volcano ha programmato i pod:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 23s volcano Successfully assigned default/spark-pi-driver to integration-worker2
```