Uso do YuniKorn como um programador personalizado para Apache Spark no Amazon EMR no EKS

Defina o cluster do Amazon EKS:

cat <<EOF >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

Crie o cluster:

eksctl create cluster -f eks-cluster.yaml

Crie o namespace spark-job em que você executará o trabalho do Spark:

kubectl create namespace spark-job

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

2. 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

Use o seguinte comando kubectl para criar um namespace yunikorn para implantar o programador do Yunikorn:

kubectl create namespace yunikorn

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

Se ainda não o fez, conclua as etapas apresentadas nas seguintes seções para se preparar para usar:

1. Criação do cluster e preparação para usar o YuniKorn

2. Instalação e configuração do YuniKorn

3. Configuração do operador do Spark para o Amazon EMR no EKS

4. Instalação do operador do Spark

   Inclua os seguintes argumentos ao executar o comando helm install spark-operator-demo:

   --set batchScheduler.enable=true 
   --set webhook.enable=true

Crie um arquivo de definição SparkApplication spark-pi.yaml.

Para usar o YuniKorn como um programador para os trabalhos, você deve adicionar determinados rótulos e anotações à definição da sua aplicação. 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 Criação do cluster e preparação para usar o YuniKorn.

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"

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

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

Primeiro, conclua as etapas na seção Configuração do spark-submit para o Amazon EMR no EKS.

Defina os valores para as seguintes variáveis ​​de ambiente:

export SPARK_HOME=spark-home
export MASTER_URL=k8s://Amazon-EKS-cluster-endpoint

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 Criação do cluster e preparação para usar o YuniKorn.

$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

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