As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando YuniKorn como um programador personalizado para o Apache Spark no Amazon EMR no EKS
Com o Amazon EMR no EKS, você pode usar o operador do Spark ou o spark-submit para executar trabalhos do Spark com programadores personalizados do Kubernetes. Este tutorial aborda como executar trabalhos do Spark com um YuniKorn agendador em uma fila personalizada e o agendamento de grupos.
## Visão geral do
[O Apache YuniKorn](https://yunikorn.apache.org/) pode ajudar a gerenciar o agendamento do Spark com agendamento compatível com aplicativos, para que você possa ter um controle refinado sobre as cotas e prioridades dos recursos. Com o agendamento em grupo, YuniKorn agenda um aplicativo somente quando a solicitação mínima de recursos para o aplicativo pode ser satisfeita. Para obter mais informações, consulte [O que é agendamento de gangues](https://yunikorn.apache.org/docs/user_guide/gang_scheduling/) no site de YuniKorn documentação do Apache.
## Crie seu cluster e prepare-se para YuniKorn
Use as etapas a seguir para implantar um cluster do Amazon EKS. Você pode alterar a Região da AWS (`region`) e as zonas de disponibilidade (`availabilityZones`).
1. Defina o cluster do Amazon EKS:
```
cat <eks-cluster.yaml
---
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: emr-eks-cluster
region: eu-west-1
vpc:
clusterEndpoints:
publicAccess: true
privateAccess: true
iam:
withOIDC: true
nodeGroups:
- name: spark-jobs
labels: { app: spark }
instanceType: m5.xlarge
desiredCapacity: 2
minSize: 2
maxSize: 3
availabilityZones: ["eu-west-1a"]
EOF
```
1. Crie o cluster:
```
eksctl create cluster -f eks-cluster.yaml
```
1. Crie o namespace `spark-job` em que você executará o trabalho do Spark:
```
kubectl create namespace spark-job
```
1. Em seguida, crie um perfil e uma associação de perfis do Kubernetes. Isso é obrigatório para a conta de serviço usada pela execução de trabalho do Spark.
1. Defina a conta de serviço, o perfil e a associação de perfis para os trabalhos do Spark.
```
cat <emr-job-execution-rbac.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: spark-sa
namespace: spark-job
automountServiceAccountToken: false
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: spark-role
namespace: spark-job
rules:
- apiGroups: ["", "batch","extensions"]
resources: ["configmaps","serviceaccounts","events","pods","pods/exec","pods/log","pods/portforward","secrets","services","persistentvolumeclaims"]
verbs: ["create","delete","get","list","patch","update","watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: spark-sa-rb
namespace: spark-job
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: spark-role
subjects:
- kind: ServiceAccount
name: spark-sa
namespace: spark-job
EOF
```
1. Aplique a definição de perfil e de associação de perfis do Kubernetes com o seguinte comando:
```
kubectl apply -f emr-job-execution-rbac.yaml
```
## Instalar e configurar YuniKorn
1. Use o seguinte comando kubectl para criar um namespace `yunikorn` para implantar o programador do Yunikorn:
```
kubectl create namespace yunikorn
```
1. Para instalar o programador, execute os seguintes comandos do Helm:
```
helm repo add yunikorn https://apache.github.io/yunikorn-release
```
```
helm repo update
```
```
helm install yunikorn yunikorn/yunikorn --namespace yunikorn
```
## Execute um aplicativo Spark com YuniKorn agendador com o operador Spark
1. Se ainda não o fez, conclua as etapas apresentadas nas seguintes seções para se preparar para usar:
1. [Crie seu cluster e prepare-se para YuniKorn](#tutorial-yunikorn-setup)
1. [Instalar e configurar YuniKorn](#tutorial-yunikorn-install)
1. [Configuração do operador do Spark para o Amazon EMR no EKS](spark-operator-setup.md)
1. [Instalação do operador do Spark](spark-operator-gs.md#spark-operator-install)
Inclua os seguintes argumentos ao executar o comando `helm install spark-operator-demo`:
```
--set batchScheduler.enable=true
--set webhook.enable=true
```
1. Crie um arquivo de definição `SparkApplication` `spark-pi.yaml`.
Para usar YuniKorn como agendador para seus trabalhos, você deve adicionar certas anotações e rótulos à definição do seu aplicativo. As anotações e os rótulos especificam a fila do seu trabalho e a estratégia de programação que você deseja usar.
No exemplo a seguir, a anotação `schedulingPolicyParameters` determina o agendamento coletivo para a aplicação. Em seguida, o exemplo cria **grupos de tarefas**, ou “coletivos” de tarefas, para especificar a capacidade mínima que deve estar disponível antes da programação dos pods para iniciar a execução do trabalho. E, por fim, é especificado na definição do grupo de tarefas o uso de grupos de nós com o rótulo `"app": "spark"`, conforme definido na seção [Crie seu cluster e prepare-se para YuniKorn](#tutorial-yunikorn-setup).
```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
name: spark-pi
namespace: spark-job
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"
restartPolicy:
type: Never
volumes:
- name: "test-volume"
hostPath:
path: "/tmp"
type: Directory
driver:
cores: 1
coreLimit: "1200m"
memory: "512m"
labels:
version: 3.3.1
annotations:
yunikorn.apache.org/schedulingPolicyParameters: "placeholderTimeoutSeconds=30 gangSchedulingStyle=Hard"
yunikorn.apache.org/task-group-name: "spark-driver"
yunikorn.apache.org/task-groups: |-
[{
"name": "spark-driver",
"minMember": 1,
"minResource": {
"cpu": "1200m",
"memory": "1Gi"
},
"nodeSelector": {
"app": "spark"
}
},
{
"name": "spark-executor",
"minMember": 1,
"minResource": {
"cpu": "1200m",
"memory": "1Gi"
},
"nodeSelector": {
"app": "spark"
}
}]
serviceAccount: spark-sa
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
executor:
cores: 1
instances: 1
memory: "512m"
labels:
version: 3.3.1
annotations:
yunikorn.apache.org/task-group-name: "spark-executor"
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
```
1. Envie a aplicação do Spark com o comando apresentado a seguir. Isso também cria um objeto `SparkApplication` chamado `spark-pi`:
```
kubectl apply -f spark-pi.yaml
```
1. Verifique os eventos do objeto `SparkApplication` com o seguinte comando:
```
kubectl describe sparkapplication spark-pi --namespace spark-job
```
O primeiro evento do pod mostrará que YuniKorn programou os pods:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduling 3m12s yunikorn spark-operator/org-apache-spark-examples-sparkpi-2a777a88b98b8a95-driver is queued and waiting for allocation
Normal GangScheduling 3m12s yunikorn Pod belongs to the taskGroup spark-driver, it will be scheduled as a gang member
Normal Scheduled 3m10s yunikorn Successfully assigned spark
Normal PodBindSuccessful 3m10s yunikorn Pod spark-operator/
Normal TaskCompleted 2m3s yunikorn Task spark-operator/
Normal Pulling 3m10s kubelet Pulling
```
## Execute um aplicativo Spark com YuniKorn agendador com `spark-submit`
1. Primeiro, conclua as etapas na seção [Configuração do spark-submit para o Amazon EMR no EKS](spark-submit-setup.md).
1. Defina os valores para as seguintes variáveis de ambiente:
```
export SPARK_HOME=spark-home
export MASTER_URL=k8s://Amazon-EKS-cluster-endpoint
```
1. Envie a aplicação do Spark com o seguinte comando:
No exemplo a seguir, a anotação `schedulingPolicyParameters` determina o agendamento coletivo para a aplicação. Em seguida, o exemplo cria **grupos de tarefas**, ou “coletivos” de tarefas, para especificar a capacidade mínima que deve estar disponível antes da programação dos pods para iniciar a execução do trabalho. E, por fim, é especificado na definição do grupo de tarefas o uso de grupos de nós com o rótulo `"app": "spark"`, conforme definido na seção [Crie seu cluster e prepare-se para YuniKorn](#tutorial-yunikorn-setup).
```
$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-sa \
--deploy-mode cluster \
--conf spark.kubernetes.namespace=spark-job \
--conf spark.kubernetes.scheduler.name=yunikorn \
--conf spark.kubernetes.driver.annotation.yunikorn.apache.org/schedulingPolicyParameters="placeholderTimeoutSeconds=30 gangSchedulingStyle=Hard" \
--conf spark.kubernetes.driver.annotation.yunikorn.apache.org/task-group-name="spark-driver" \
--conf spark.kubernetes.executor.annotation.yunikorn.apache.org/task-group-name="spark-executor" \
--conf spark.kubernetes.driver.annotation.yunikorn.apache.org/task-groups='[{
"name": "spark-driver",
"minMember": 1,
"minResource": {
"cpu": "1200m",
"memory": "1Gi"
},
"nodeSelector": {
"app": "spark"
}
},
{
"name": "spark-executor",
"minMember": 1,
"minResource": {
"cpu": "1200m",
"memory": "1Gi"
},
"nodeSelector": {
"app": "spark"
}
}]' \
local:///usr/lib/spark/examples/jars/spark-examples.jar 20
```
1. Verifique os eventos do objeto `SparkApplication` com o seguinte comando:
```
kubectl describe pod spark-driver-pod --namespace spark-job
```
O primeiro evento do pod mostrará que YuniKorn programou os pods:
```
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduling 3m12s yunikorn spark-operator/org-apache-spark-examples-sparkpi-2a777a88b98b8a95-driver is queued and waiting for allocation
Normal GangScheduling 3m12s yunikorn Pod belongs to the taskGroup spark-driver, it will be scheduled as a gang member
Normal Scheduled 3m10s yunikorn Successfully assigned spark
Normal PodBindSuccessful 3m10s yunikorn Pod spark-operator/
Normal TaskCompleted 2m3s yunikorn Task spark-operator/
Normal Pulling 3m10s kubelet Pulling
```