Dragi čitatelji, dobar dan. Danas ćemo malo razgovarati o Apache Sparku i njegovim perspektivama razvoja.

U modernom svetu Big Data, Apache Spark je de facto standard za razvoj zadataka obrade podataka. Pored toga, takođe se koristi za kreiranje streaming aplikacija koje funkcionišu u konceptu mikro serija, obrađujući i isporučujući podatke u malim količinama (Spark Structured Streaming). Tradicionalno, bio je deo zajedničkog stoga Hadoop, koristeći YARN kao upravljača resursima (ili, u nekim slučajevima, Apache Mesos). Do 2020. godine, njegovo korišćenje u tradicionalnom smislu za većinu kompanija je pod ozbiljnim znakom pitanja zbog nedostatka pristojnih distribucija Hadoopa — razvoj HDP-a i CDH-a je zaustavljen, CDH nije dovoljno razrađen i ima visoke troškove, dok su ostali ponuđači Hadoopa ili prestali da postoje ili imaju neizvjesnu budućnost. Stoga sve veći interes u zajednici i među velikim kompanijama izaziva pokretanje Apache Sparka pomoću Kubernetes-a — postajući standard za orkestraciju kontejnera i upravljanje resursima u privatnim i javnim oblacima, rešava problem nepraktičnog planiranja resursa zadataka Sparka na YARN-u i pruža stabilno razvijajuću platformu sa brojnim komercijalnim i otvorenim distribucijama za kompanije svih veličina i tipova. Štaviše, na talasu popularnosti, većina ih je uspela da uspostavi par ili tri svoje instalacije i stekne ekspertizu u njegovom korišćenju, što olakšava migraciju.
Počevši od verzije 2.3.0, Apache Spark je dobio zvaničnu podršku za pokretanje zadataka u klasteru Kubernetes i danas ćemo razgovarati o trenutnoj zrelosti tog pristupa, raznim opcijama njegove upotrebe i preprekama na koje će se naići prilikom implementacije.
Prvo ćemo razmotriti postupak razvoja zadataka i aplikacija zasnovanih na Apache Sparku i istaknuti tipične slučajeve u kojima je potrebno pokrenuti zadatak u klasteru Kubernetes. U pripremi ovog posta koristi se OpenShift kao distribucija, a biće navedene komande relevantne za njegov komandni alat (oc). Za druge distribucije Kubernetes-a mogu se koristiti odgovarajuće komande standardnog komandnog alata Kubernetes-a (kubectl) ili njihovi analozi (na primer, za oc adm policy).
Prvi scenarij upotrebe — spark-submit
Tokom razvoja zadataka i aplikacija, programer treba da pokreće zadatke za debugging transformacije podataka. Teorijski, za ove svrhe mogu se koristiti stubovi, ali razvoj uz korišćenje pravih (iako testnih) instanci krajnjih sistema pokazao se bržim i kvalitetnijim za ovu vrstu zadataka. U slučaju da vršimo debugging na pravim instancama krajnjih sistema, mogu se pojaviti dva scenarija rada:
- programer pokreće Spark zadatak lokalno u standalone režimu;

- programer pokreće Spark zadatak na Kubernetes klasteru u testnom okruženju.

Prvi scenarij ima svoje mesto, ali sa sobom nosi niz nedostataka:
- za svakog programera je potrebno obezbediti pristup sa radnog mesta do svih potrebnih instanci krajnjih sistema;
- na radnoj mašini su potrebni dovoljni resursi za pokretanje razvijanog zadatka.
Drugi scenarij je oslobođen ovih nedostataka, pošto korišćenje Kubernetes klastera omogućava dodeljivanje potrebnog bazena resursa za pokretanje zadataka i obezbeđuje potrebne pristupe instancama krajnjih sistema, fleksibilno pružajući pristup kroz model uloga Kubernetes-a svim članovima razvojnog tima. Izdvojimo ga kao prvi scenarij upotrebe — pokretanje Spark zadataka sa lokalnog računara programera na Kubernetes klasteru u testnom okruženju.
Detaljnije ćemo govoriti o procesu podešavanja Sparka za lokalno pokretanje. Da biste počeli koristiti Spark, potrebno ga je instalirati:
mkdir /opt/spark
cd /opt/spark
wget http://mirror.linux-ia64.org/apache/spark/spark-2.4.5/spark-2.4.5.tgz
tar zxvf spark-2.4.5.tgz
rm -f spark-2.4.5.tgz
Sakupljamo potrebne pakete za rad sa Kubernetes-om:
cd spark-2.4.5/
./build/mvn -Pkubernetes -DskipTests clean package
Potpuna izgradnja traje dugo, a za kreiranje Docker slika i njihovo pokretanje na Kubernetes klasteru, u stvarnosti su potrebni samo jar fajlovi iz direktorijuma „assembly/“, tako da možemo izgraditi samo ovaj podprojekt:
./build/mvn -f ./assembly/pom.xml -Pkubernetes -DskipTests clean package
Za pokretanje Spark zadataka u Kubernetes-u, potrebno je kreirati Docker sliku koja će se koristiti kao osnovna. Postoje 2 pristupa:
- Stvorena Docker slika uključuje izvršni kod Spark zadatka;
- Stvoreni imidž uključuje samo Spark i potrebne zavisnosti, izvršni kod se nalazi na udaljenom mestu (na primer, u HDFS-u).
Za početak, kreiraćemo Docker imidž koji sadrži test primer Spark zadatka. Za kreiranje Docker imidža, Spark ima odgovarajući alat pod nazivom "docker-image-tool". Pogledajmo njegovu pomoć:
./bin/docker-image-tool.sh --help
Uz njegovu pomoć može se kreirati Docker imidž i učitati ga u udaljene registre, ali prema zadanim postavkama, on ima niz nedostataka:
- obavezno kreira odmah 3 Docker imidža — za Spark, PySpark i R;
- ne dozvoljava da se odredi ime imidža.
Zato ćemo koristiti modifikovanu verziju ovog alata, koju donosimo u nastavku:
vi bin/docker-image-tool-upd.sh
#!/usr/bin/env bash
function error {
echo "$@" 1>&2
exit 1
}
if [ -z "${SPARK_HOME}" ]; then
SPARK_HOME="$(cd "`dirname "$0"`"/..; pwd)"
fi
. "${SPARK_HOME}/bin/load-spark-env.sh"
function image_ref {
local image="$1"
local add_repo="${2:-1}"
if [ $add_repo = 1 ] && [ -n "$REPO" ]; then
image="$REPO/$image"
fi
if [ -n "$TAG" ]; then
image="$image:$TAG"
fi
echo "$image"
}
function build {
local BUILD_ARGS
local IMG_PATH
if [ ! -f "$SPARK_HOME/RELEASE" ]; then
IMG_PATH=$BASEDOCKERFILE
BUILD_ARGS=(
${BUILD_PARAMS}
--build-arg
img_path=$IMG_PATH
--build-arg
datagram_jars=datagram/runtimelibs
--build-arg
spark_jars=assembly/target/scala-$SPARK_SCALA_VERSION/jars
)
else
IMG_PATH="kubernetes/dockerfiles"
BUILD_ARGS=(${BUILD_PARAMS})
fi
if [ -z "$IMG_PATH" ]; then
error "Cannot find docker image. This script must be run from a runnable distribution of Apache Spark."
fi
if [ -z "$IMAGE_REF" ]; then
error "Cannot find docker image reference. Please add -i arg."
fi
local BINDING_BUILD_ARGS=(
${BUILD_PARAMS}
--build-arg
base_img=$(image_ref $IMAGE_REF)
)
local BASEDOCKERFILE=${BASEDOCKERFILE:-"$IMG_PATH/spark/docker/Dockerfile"}
docker build $NOCACHEARG "${BUILD_ARGS[@]}"
-t $(image_ref $IMAGE_REF)
-f "$BASEDOCKERFILE" .
}
function push {
docker push "$(image_ref $IMAGE_REF)"
}
function usage {
cat <<EOF
Usage: $0 [options] [command]
Builds or pushes the built-in Spark Docker image.
Commands:
build Build image. Requires a repository address to be provided if the image will be
pushed to a different registry.
push Push a pre-built image to a registry. Requires a repository address to be provided.
Options:
-f file Dockerfile to build for JVM based Jobs. By default builds the Dockerfile shipped with Spark.
-p file Dockerfile to build for PySpark Jobs. Builds Python dependencies and ships with Spark.
-R file Dockerfile to build for SparkR Jobs. Builds R dependencies and ships with Spark.
-r repo Repository address.
-i name Image name to apply to the built image, or to identify the image to be pushed.
-t tag Tag to apply to the built image, or to identify the image to be pushed.
-m Use minikube's Docker daemon.
-n Build docker image with --no-cache
-b arg Build arg to build or push the image. For multiple build args, this option needs to
be used separately for each build arg.
Using minikube when building images will do so directly into minikube's Docker daemon.
There is no need to push the images into minikube in that case, they'll be automatically
available when running applications inside the minikube cluster.
Check the following documentation for more information on using the minikube Docker daemon:
https://kubernetes.io/docs/getting-started-guides/minikube/#reusing-the-docker-daemon
Examples:
- Build image in minikube with tag "testing"
$0 -m -t testing build
- Build and push image with tag "v2.3.0" to docker.io/myrepo
$0 -r docker.io/myrepo -t v2.3.0 build
$0 -r docker.io/myrepo -t v2.3.0 push
EOF
}
if [[ "$@" = *--help ]] || [[ "$@" = *-h ]]; then
usage
exit 0
fi
REPO=
TAG=
BASEDOCKERFILE=
NOCACHEARG=
BUILD_PARAMS=
IMAGE_REF=
while getopts f:mr:t:nb:i: option
do
case "${option}"
in
f) BASEDOCKERFILE=${OPTARG};;
r) REPO=${OPTARG};;
t) TAG=${OPTARG};;
n) NOCACHEARG="--no-cache";;
i) IMAGE_REF=${OPTARG};;
b) BUILD_PARAMS=${BUILD_PARAMS}" --build-arg "${OPTARG};;
esac
done
case "${@: -1}" in
build)
build
;;
push)
if [ -z "$REPO" ]; then
usage
exit 1
fi
push
;;
*)
usage
exit 1
;;
esac
Uz njegovu pomoć kreiramo osnovni Spark imidž koji sadrži testni zadatak za izračunavanje broja Pi pomoću Sparka (ovde {docker-registry-url} — URL vašeg Docker registra, {repo} — ime repozitorijuma unutar registra, koje se poklapa sa projektom u OpenShift-u, {image-name} — ime imidža (ako se koristi trostveni razdvajanje imidža, na primer, kao u integrisanom registru imidža Red Hat OpenShift), {tag} — oznaka ove verzije imidža):
./bin/docker-image-tool-upd.sh -f resource-managers/kubernetes/docker/src/main/dockerfiles/spark/Dockerfile -r {docker-registry-url}/{repo} -i {image-name} -t {tag} build
Prijavićemo se u OKD klaster putem konzolnog alata (ovde {OKD-API-URL} — URL API-ja klastera OKD):
oc login {OKD-API-URL}
Dobićemo token trenutnog korisnika za autorizaciju u Docker Registry:
oc whoami -t
Prijavićemo se u unutrašnji Docker Registry klastera OKD (koristeći token dobijen prethodnom komandom kao lozinku):
docker login {docker-registry-url}
Učitaćemo kreirani Docker imidž u Docker Registry OKD:
./bin/docker-image-tool-upd.sh -r {docker-registry-url}/{repo} -i {image-name} -t {tag} push
Proverićemo da li je kreirani imidž dostupan u OKD. Da bismo to uradili, otvorićemo u pretraživaču URL sa listom imidža odgovarajućeg projekta (ovde {project} — ime projekta unutar OpenShift klastera, {OKD-WEBUI-URL} — URL Web konzole OpenShift) — https://{OKD-WEBUI-URL}/console/project/{project}/browse/images/{image-name}.
Za pokretanje zadataka neophodno je kreirati servisni nalog sa privilegijama za pokretanje podova kao root (o toj temi ćemo raspraviti kasnije):
oc create sa spark -n {project}
oc adm policy add-scc-to-user anyuid -z spark -n {project}
Izvršićemo komandu spark-submit za objavljivanje Spark zadatka u OKD klasteru, navedući kreirani servisni nalog i Docker imidž:
/opt/spark/bin/spark-submit --name spark-test --class org.apache.spark.examples.SparkPi --conf spark.executor.instances=3 --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark --conf spark.kubernetes.namespace={project} --conf spark.submit.deployMode=cluster --conf spark.kubernetes.container.image={docker-registry-url}/{repo}/{image-name}:{tag} --conf spark.master=k8s://https://{OKD-API-URL} local:///opt/spark/examples/target/scala-2.11/jars/spark-examples_2.11-2.4.5.jar
Ovdje:
--name — ime zadatka, koje će učestvovati u formiranju imena Kubernetes podova;
—class — klasa izvršnog fajla koji se poziva prilikom pokretanja zadatka;
—conf — konfiguracijski parametri Sparka;
spark.executor.instances — broj aktivnih executor-a Sparka;
spark.kubernetes.authenticate.driver.serviceAccountName — ime Kubernetes servisnog naloga koji se koristi prilikom pokretanja podova (za određivanje sigurnosnog konteksta i mogućnosti pri interakciji s Kubernetes API-jem);
spark.kubernetes.namespace — naziv Kubernetes prostora imena u kojem će se pokretati podovi drajvera i executor-a;
spark.submit.deployMode — način pokretanja Sparka (za standardni spark-submit koristi se „cluster“, za Spark Operator i novije verzije Sparka „client“);
spark.kubernetes.container.image — Docker slika koja se koristi za pokretanje podova;
spark.master — URL API-ja Kubernetes (navodi se spolja kada se pristupa s lokalnog računara);
local:// — putanja do izvršnog fajla Sparka unutar Docker slike.
Prelazimo na odgovarajući OKD projekat i proučavamo kreirane podove — https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods.
Za pojednostavljenje procesa razvoja može se koristiti još jedna opcija, u kojoj se kreira zajednička osnovna slika Sparka koja se koristi za sve zadatke, a snimci izvršnih fajlova se objavljuju u spoljnjem skladištu (na primer, Hadoop) i navode se prilikom poziva spark-submit kao link. U tom slučaju može se pokretati različite verzije zadataka Sparka bez ponovne izgradnje Docker slika, koristeći za objavljivanje slika na primer WebHDFS. Šaljemo zahtev za kreiranje fajla (ovde {host} — host WebHDFS servisa, {port} — port WebHDFS servisa, {path-to-file-on-hdfs} — željena putanja do fajla na HDFS):
curl -i -X PUT "http://{host}:{port}/webhdfs/v1/{path-to-file-on-hdfs}?op=CREATE"
U tom slučaju dobićemo odgovor u formatu (ovde {location} — to je URL koji treba koristiti za preuzimanje fajla):
HTTP/1.1 307 TEMPORARY_REDIRECT
Location: {location}
Content-Length: 0
Preuzimamo izvršni fajl Sparka na HDFS (ovde {path-to-local-file} — putanja do izvršnog fajla Sparka na trenutnom hostu):
curl -i -X PUT -T {path-to-local-file} "{location}"
Nakon toga možemo uraditi spark-submit koristeći fajl Sparka koji je preuzet na HDFS (ovde {class-name} — ime klase koju je potrebno pokrenuti za izvršenje zadatka):
/opt/spark/bin/spark-submit --name spark-test --class {class-name} --conf spark.executor.instances=3 --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark --conf spark.kubernetes.namespace={project} --conf spark.submit.deployMode=cluster --conf spark.kubernetes.container.image={docker-registry-url}/{repo}/{image-name}:{tag} --conf spark.master=k8s://https://{OKD-API-URL} hdfs://{host}:{port}/{path-to-file-on-hdfs}
Treba napomenuti da za pristup HDFS-u i osiguranje rada zadatka može biti potrebno promeniti Dockerfile i skript entrypoint.sh — dodati u Dockerfile direktivu za kopiranje zavisnih biblioteka u direktorijum /opt/spark/jars i uključiti fajl konfiguracije HDFS u SPARK_CLASSPATH u entrypoint.sh.
Drugi način upotrebe — Apache Livy
Nakon što je zadatak razvijen i potrebno je testirati dobijeni rezultat, javlja se pitanje njegove realizacije u okviru CI/CD procesa i praćenja statusa njegove izvršenosti. Naravno, moguće je pokrenuti ga i pomoću lokalnog poziva spark-submit, ali to otežava CI/CD infrastrukturu jer zahteva instalaciju i konfiguraciju Sparka na agentima/radnicima CI servera i postavljanje pristupa API-ju Kubernetesa. Za ovaj slučaj, ciljna realizacija odabrana je upotreba Apache Livy kao REST API-ja za pokretanje Spark zadataka, smeštenog unutar Kubernetesa. Pomoću njega moguće je pokretati Spark zadatke na Kuberneteskim klasterima koristeći obične cURL zahteve, što se lako može implementirati na bazi bilo kog CI rešenja, a njegovo smeštanje unutar Kubernetesa rešava pitanje autentifikacije prilikom interakcije s API-jem Kubernetesa.

Istaknimo ga kao drugi način upotrebe — pokretanje Spark zadataka u okviru CI/CD procesa na Kuberneteskog klastera u testnom okruženju.
Malo o Apache Livy — on funkcioniše kao HTTP server, pružajući Web interfejs i RESTful API, koji omogućava daljinsko pokretanje spark-submit sa potrebnim parametrima. Tradicionalno je bio isporučen u okviru HDP distribucije, ali se može takođe implementirati u OKD ili bilo kojoj drugoj instalaciji Kubernetesa uz pomoć odgovarajuće manifestacije i skupa Docker slika, na primer, ovog — . Za naš slučaj, sagrađena je slična Docker slika, koja uključuje Spark verzije 2.4.5 iz sledećeg Dockerfile-a:
FROM java:8-alpine
ENV SPARK_HOME=/opt/spark
ENV LIVY_HOME=/opt/livy
ENV HADOOP_CONF_DIR=/etc/hadoop/conf
ENV SPARK_USER=spark
WORKDIR /opt
RUN apk add --update openssl wget bash &&
wget -P /opt https://downloads.apache.org/spark/spark-2.4.5/spark-2.4.5-bin-hadoop2.7.tgz &&
tar xvzf spark-2.4.5-bin-hadoop2.7.tgz &&
rm spark-2.4.5-bin-hadoop2.7.tgz &&
ln -s /opt/spark-2.4.5-bin-hadoop2.7 /opt/spark
RUN wget http://mirror.its.dal.ca/apache/incubator/livy/0.7.0-incubating/apache-livy-0.7.0-incubating-bin.zip &&
unzip apache-livy-0.7.0-incubating-bin.zip &&
rm apache-livy-0.7.0-incubating-bin.zip &&
ln -s /opt/apache-livy-0.7.0-incubating-bin /opt/livy &&
mkdir /var/log/livy &&
ln -s /var/log/livy /opt/livy/logs &&
cp /opt/livy/conf/log4j.properties.template /opt/livy/conf/log4j.properties
ADD livy.conf /opt/livy/conf
ADD spark-defaults.conf /opt/spark/conf/spark-defaults.conf
ADD entrypoint.sh /entrypoint.sh
ENV PATH="/opt/livy/bin:${PATH}"
EXPOSE 8998
ENTRYPOINT ["/entrypoint.sh"]
CMD ["livy-server"]
Kreirani obraz može biti sastavljen i učitan u vaš postojeći Docker repozitorij, kao što je interni repozitorij OKD. Za njegovo implementiranje koristi se sljedeći manifest ({registry-url} — URL Docker repozitorija, {image-name} — ime Docker slike, {tag} — oznaka Docker slike, {livy-url} — željeni URL pod kojim će poslužitelj Livy biti dostupan; manifest 'Route' se primjenjuje ako se kao distribucija Kubernetes koristi Red Hat OpenShift, inače se koristi odgovarajući manifest Ingress ili Service tipa NodePort):
---
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
component: livy
name: livy
spec:
progressDeadlineSeconds: 600
replicas: 1
revisionHistoryLimit: 10
selector:
matchLabels:
component: livy
strategy:
rollingUpdate:
maxSurge: 25%
maxUnavailable: 25%
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
component: livy
spec:
containers:
- command:
- livy-server
env:
- name: K8S_API_HOST
value: localhost
- name: SPARK_KUBERNETES_IMAGE
value: 'gnut3ll4/spark:v1.0.14'
image: '{registry-url}/{image-name}:{tag}'
imagePullPolicy: Always
name: livy
ports:
- containerPort: 8998
name: livy-rest
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
volumeMounts:
- mountPath: /var/log/livy
name: livy-log
- mountPath: /opt/.livy-sessions/
name: livy-sessions
- mountPath: /opt/livy/conf/livy.conf
name: livy-config
subPath: livy.conf
- mountPath: /opt/spark/conf/spark-defaults.conf
name: spark-config
subPath: spark-defaults.conf
- command:
- /usr/local/bin/kubectl
- proxy
- '--port'
- '8443'
image: 'gnut3ll4/kubectl-sidecar:latest'
imagePullPolicy: Always
name: kubectl
ports:
- containerPort: 8443
name: k8s-api
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
dnsPolicy: ClusterFirst
restartPolicy: Always
schedulerName: default-scheduler
securityContext: {}
serviceAccount: spark
serviceAccountName: spark
terminationGracePeriodSeconds: 30
volumes:
- emptyDir: {}
name: livy-log
- emptyDir: {}
name: livy-sessions
- configMap:
defaultMode: 420
items:
- key: livy.conf
path: livy.conf
name: livy-config
name: livy-config
- configMap:
defaultMode: 420
items:
- key: spark-defaults.conf
path: spark-defaults.conf
name: livy-config
name: spark-config
---
apiVersion: v1
kind: ConfigMap
metadata:
name: livy-config
data:
livy.conf: |-
livy.spark.deploy-mode=cluster
livy.file.local-dir-whitelist=/opt/.livy-sessions/
livy.spark.master=k8s://http://localhost:8443
livy.server.session.state-retain.sec = 8h
spark-defaults.conf: 'spark.kubernetes.container.image "gnut3ll4/spark:v1.0.14"'
---
apiVersion: v1
kind: Service
metadata:
labels:
app: livy
name: livy
spec:
ports:
- name: livy-rest
port: 8998
protocol: TCP
targetPort: 8998
selector:
component: livy
sessionAffinity: None
type: ClusterIP
---
apiVersion: route.openshift.io/v1
kind: Route
metadata:
labels:
app: livy
name: livy
spec:
host: {livy-url}
port:
targetPort: livy-rest
to:
kind: Service
name: livy
weight: 100
wildcardPolicy: None
Nakon njegove primjene i uspješnog pokretanja poda, grafičko sučelje Livy dostupno je na linku: http://{livy-url}/ui. Uz pomoć Livy možemo objaviti našu Spark zadatak koristeći REST zahtjev, na primjer, iz Postmana. Primjer kolekcije sa zahtjevima представлен je ispod (u nizu „args“ mogu biti proslijeđeni konfiguracijski argumenti s varijablama potrebnim za rad pokretane zadaće):
{
"info": {
"_postman_id": "be135198-d2ff-47b6-a33e-0d27b9dba4c8",
"name": "Spark Livy",
"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
},
"item": [
{
"name": "1 Submit job with jar",
"request": {
"method": "POST",
"header": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"body": {
"mode": "raw",
"raw": "{nt\"file\": \"local:///opt/spark/examples/target/scala-2.11/jars/spark-examples_2.11-2.4.5.jar\", nt\"className\": \"org.apache.spark.examples.SparkPi\",nt\"numExecutors\":1,nt\"name\": \"spark-test-1\",nt\"conf\": {ntt\"spark.jars.ivy\": \"/tmp/.ivy\",ntt\"spark.kubernetes.authenticate.driver.serviceAccountName\": \"spark\",ntt\"spark.kubernetes.namespace\": \"{project}\",ntt\"spark.kubernetes.container.image\": \"{docker-registry-url}/{repo}/{image-name}:{tag}\"nt}n}"
},
"url": {
"raw": "http://{livy-url}/batches",
"protocol": "http",
"host": [
"{livy-url}"
],
"path": [
"batches"
]
}
},
"response": []
},
{
"name": "2 Submit job without jar",
"request": {
"method": "POST",
"header": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"body": {
"mode": "raw",
"raw": "{nt\"file\": \"hdfs://{host}:{port}/{path-to-file-on-hdfs}\", nt\"className\": \"{class-name}\",nt\"numExecutors\":1,nt\"name\": \"spark-test-2\",nt\"proxyUser\": \"0\",nt\"conf\": {ntt\"spark.jars.ivy\": \"/tmp/.ivy\",ntt\"spark.kubernetes.authenticate.driver.serviceAccountName\": \"spark\",ntt\"spark.kubernetes.namespace\": \"{project}\",ntt\"spark.kubernetes.container.image\": \"{docker-registry-url}/{repo}/{image-name}:{tag}\"nt},nt\"args\": [ntt\"HADOOP_CONF_DIR=/opt/spark/hadoop-conf\",ntt\"MASTER=k8s://https://kubernetes.default.svc:8443\"nt]n}"
},
"url": {
"raw": "http://{livy-url}/batches",
"protocol": "http",
"host": [
"{livy-url}"
],
"path": [
"batches"
]
}
},
"response": []
}
],
"event": [
{
"listen": "prerequest",
"script": {
"id": "41bea1d0-278c-40c9-ad42-bf2e6268897d",
"type": "text/javascript",
"exec": [
""
]
}
},
{
"listen": "test",
"script": {
"id": "3cdd7736-a885-4a2d-9668-bd75798f4560",
"type": "text/javascript",
"exec": [
""
]
}
}
],
"protocolProfileBehavior": {}
}
Izvršavamo prvi zahtjev iz kolekcije, prelazimo na sučelje OKD i provjeravamo jesu li zadaci uspješno pokrenuti — https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods. U isto vrijeme, u sučelju Livy (http://{livy-url}/ui) će se pojaviti sesija, u okviru koje putem API-a Livy ili grafičkog sučelja možemo pratiti napredak izvršavanja zadatka i pregledati logove sesije.
Sada ćemo prikazati mehanizam rada Livy. Da bismo to uradili, proučićemo dnevnike Livy kontejnera unutar pod-a sa Livy serverom — https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods/{livy-pod-name}?tab=logs. Iz njih se može videti da se prilikom poziva REST API Livy u kontejneru imenom „livy“ izvršava spark-submit, sličan onom koji smo koristili ranije (ovde {livy-pod-name} je ime stvorenog pod-a sa Livy serverom). U kolekciji je takođe predstavljen drugi zahtev koji omogućava pokretanje zadataka sa daljinskim postavljanjem izvršnog fajla Spark pomoću Livy servera.
Treća opcija korišćenja — Spark Operator
Sada, kada je zadatak testiran, postavlja se pitanje njegovog redovnog pokretanja. Nativni način za redovno pokretanje zadataka u Kubernetes klasteru je entitet CronJob i može se koristiti, ali trenutno je veća popularnost zabeležena korišćenjem operatora za upravljanje aplikacijama u Kubernetesu i postoji dovoljno zreo operator za Spark, koji se, između ostalog, koristi u rešenjima na Enterprise nivou (na primer, Lightbend FastData Platform). Preporučujemo njegovo korišćenje — trenutna stabilna verzija Sparka (2.4.5) ima prilično ograničene mogućnosti za konfiguraciju pokretanja zadataka Spark u Kubernetesu, dok je u sledećoj major verziji (3.0.0) najavljena potpuna podrška za Kubernetes, ali datum njenog izlaska ostaje nepoznat. Spark Operator nadoknađuje ovaj nedostatak dodavanjem važnih parametara konfiguracije (na primer, montiranje ConfigMap sa konfiguracijom pristupa Hadoop-u u Spark pod-ove) i mogućnost redovnog pokretanja zadatka po rasporedu.

Izdvojimo ga kao treću opciju korišćenja — redovno pokretanje Spark zadataka u Kubernetes klasteru u produkcionom okruženju.
Spark Operator ima otvoreni izvorni kod i razvija se u okviru Google Cloud Platform — . Njegova instalacija može se izvršiti na 3 načina:
- Kroz instalaciju Lightbend FastData Platform/Cloudflow;
- Pomoću Helma:
helm repo add incubator http://storage.googleapis.com/kubernetes-charts-incubator helm install incubator/sparkoperator --namespace spark-operator - Korištenje manifesta iz službenog repozitorija (https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/tree/master/manifest). Treba napomenuti da u sastav Cloudflow ulazi operator s verzijom API v1beta1. Ako se koristi ova vrsta instalacije, opisi manifesta aplikacija Spark trebaju se temeljiti na primjerima iz tagova u Gitu s odgovarajućom verzijom API, na primjer, „v1beta1-0.9.0-2.4.0“. Verziju operatora možete pogledati u opisu CRD-a koji je dio operatora u rječniku „versions“:
oc get crd sparkapplications.sparkoperator.k8s.io -o yaml
Ako je operator ispravno instaliran, u odgovarajućem projektu će se pojaviti aktivni pod s operatorom Spark (na primjer, cloudflow-fdp-sparkoperator u prostoru Cloudflow za instalaciju Cloudflow) i odgovarajući tip resursa Kubernetes s imenom „sparkapplications“. Postojeće aplikacije Spark možete proučiti sljedećom komandom:
oc get sparkapplications -n {project}
Za pokretanje zadataka pomoću Spark Operatora potrebno je učiniti tri stvari:
- stvoriti Docker sliku koja uključuje sve potrebne biblioteke, kao i konfiguracijske i izvršne datoteke. U ciljnoj slici to je slika koja je stvorena u CI/CD fazi i testirana na testnom klasteru;
- objaviti Docker sliku u registar, koji je dostupan iz Kubernetes klastera;
- konstruirati manifest s tipom „SparkApplication“ i opisom pokretane zadatka. Primjeri manifesta dostupni su u službenom repozitoriju (na primjer, ). Važno je napomenuti bitne aspekte vezane uz manifest:
- u rječniku „apiVersion“ trebala bi biti navedena verzija API koja odgovara verziji operatora;
- u rječniku „metadata.namespace“ treba biti navedeno ime prostora u kojem će se aplikacija pokrenuti;
- u rječniku „spec.image“ trebala bi biti navedena adresa stvorene Docker slike u dostupnom registru;
- u rječniku „spec.mainClass“ treba biti naveden glavni razred Spark zadatka koji treba pokrenuti tijekom procesa;
- u rječniku „spec.mainApplicationFile“ treba biti navedena putanja do izvršne jar datoteke;
- u rječniku „spec.sparkVersion“ trebala bi biti navedena korištena verzija Sparka;
- u rječniku „spec.driver.serviceAccount“ treba biti navedena usluga računa unutar odgovarajućeg prostora Kubernetes-a koja će se koristiti za pokretanje aplikacije;
- u rječniku „spec.executor“ treba biti navedena količina resursa dodijeljenih aplikaciji;
- U rječniku «spec.volumeMounts» mora biti navedena lokalna mapa u kojoj će se stvarati lokalne datoteke zadatka Spark.
Primjer formiranja manifesta (ovdje je {spark-service-account} — servisni račun unutar Kubernetes klastera za pokretanje Spark zadataka):
apiVersion: "sparkoperator.k8s.io/v1beta1"
kind: SparkApplication
metadata:
name: spark-pi
namespace: {project}
spec:
type: Scala
mode: cluster
image: "gcr.io/spark-operator/spark:v2.4.0"
imagePullPolicy: Always
mainClass: org.apache.spark.examples.SparkPi
mainApplicationFile: "local:////opt/spark/examples/jars/spark-examples_2.11-2.4.0.jar"
sparkVersion: "2.4.0"
restartPolicy:
type: Never
volumes:
- name: "test-volume"
hostPath:
path: "/tmp"
type: Directory
driver:
cores: 0.1
coreLimit: "200m"
memory: "512m"
labels:
version: 2.4.0
serviceAccount: {spark-service-account}
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
executor:
cores: 1
instances: 1
memory: "512m"
labels:
version: 2.4.0
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
U ovom manifestu je naveden servisni račun za koji je potrebno stvoriti potrebne uloge prije objavljivanja manifesta, koje daju potrebne privilegije za interakciju Spark aplikacije s API-jem Kubernetes (ako je potrebno). U našem slučaju aplikaciji su potrebna prava za stvaranje podova. Stvaramo potrebnu vezu uloge:
oc adm policy add-role-to-user edit system:serviceaccount:{project}:{spark-service-account} -n {project}
Također treba napomenuti da u especifici ovog manifesta može biti naveden parametar «hadoopConfigMap», koji omogućava definiranje ConfigMap s Hadoop konfiguracijom bez potrebe da se odgovarajuća datoteka unaprijed smjesti u Docker sliku. Također je pogodna za redovito pokretanje zadataka — pomoću parametra «schedule» može se odrediti raspored pokretanja ovog zadatka.
Nakon toga sačuvamo naš manifest u datoteku spark-pi.yaml i primjenjujemo ga na naš Kubernetes klaster:
oc apply -f spark-pi.yaml
Pri tome će se stvoriti objekt tipa «sparkapplications»:
oc get sparkapplications -n {project}
> NAME AGE
> spark-pi 22h
Pri tome će se stvoriti pod s aplikacijom, čiji će status biti prikazan u stvorenom «sparkapplications». Može se pogledati sljedećom komandom:
oc get sparkapplications spark-pi -o yaml -n {project}
Po završetku zadatka POD će prijeći u status «Completed», koji će se također ažurirati u «sparkapplications». Logove aplikacije može se pogledati u pregledniku ili putem sljedeće komande (ovdje je {sparkapplications-pod-name} — ime poda pokrenutog zadatka):
oc logs {sparkapplications-pod-name} -n {project}
Također, upravljanje zadacima Spark može se vršiti pomoću specijalizirane korisničke alatke sparkctl. Za njenu instalaciju kloniramo repozitorij sa njenim izvorno kodom, instaliramo Go i sastavimo ovaj alat.
git clone https://github.com/GoogleCloudPlatform/spark-on-k8s-operator.git
cd spark-on-k8s-operator/
wget https://dl.google.com/go/go1.13.3.linux-amd64.tar.gz
tar -xzf go1.13.3.linux-amd64.tar.gz
sudo mv go /usr/local
mkdir $HOME/Projects
export GOROOT=/usr/local/go
export GOPATH=$HOME/Projects
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH
go -version
cd sparkctl
go build -o sparkctl
sudo mv sparkctl /usr/local/bin
Istražimo listu pokrenutih zadataka Spark:
sparkctl list -n {project}
Kreirajmo opis za zadatak Spark:
vi spark-app.yaml
apiVersion: "sparkoperator.k8s.io/v1beta1"
kind: SparkApplication
metadata:
name: spark-pi
namespace: {project}
spec:
type: Scala
mode: cluster
image: "gcr.io/spark-operator/spark:v2.4.0"
imagePullPolicy: Always
mainClass: org.apache.spark.examples.SparkPi
mainApplicationFile: "local:///opt/spark/examples/jars/spark-examples_2.11-2.4.0.jar"
sparkVersion: "2.4.0"
restartPolicy:
type: Never
volumes:
- name: "test-volume"
hostPath:
path: "/tmp"
type: Directory
driver:
cores: 1
coreLimit: "1000m"
memory: "512m"
labels:
version: 2.4.0
serviceAccount: spark
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
executor:
cores: 1
instances: 1
memory: "512m"
labels:
version: 2.4.0
volumeMounts:
- name: "test-volume"
mountPath: "/tmp"
Pokrenimo opisani zadatak pomoću sparkctl:
sparkctl create spark-app.yaml -n {project}
Istražimo listu pokrenutih zadataka Spark:
sparkctl list -n {project}
Istražimo listu događaja pokrenutog zadatka Spark:
sparkctl event spark-pi -n {project} -f
Istražimo status pokrenutog zadatka Spark:
sparkctl status spark-pi -n {project}
Na kraju, želimo razmotriti otkrivene nedostatke korištenja trenutne stabilne verzije Sparka (2.4.5) u Kubernetesu:
- Prvi i, možda, glavni nedostatak je nedostatak lokalnosti podataka. Iako je YARN imao svoje nedostatke, postojale su i prednosti u njegovom korištenju, kao što je princip dostave koda do podataka (a ne podataka do koda). Zahvaljujući ovom principu, Spark zadaci su se izvršavali na čvorovima gdje su se nalazili podaci u procesima, čime se značajno smanjilo vrijeme prenosa podataka preko mreže. Pri korištenju Kubernetesa, suočavamo se s potrebom prenosa podataka preko mreže koji su uključeni u rad zadatka. U slučaju da su ti podaci dovoljno veliki, vrijeme izvršenja zadatka se može znatno povećati, a također može biti potrebno dovoljno veliko diskovno prostorije dodijeljeno instancama Spark zadataka za njihovo privremeno skladištenje. Ovaj nedostatak može biti smanjen korištenjem specijalizovanih softverskih alata koji omogućavaju lokalnost podataka u Kubernetessu (kao što je Alluxio), ali to zapravo znači potrebu za skladištenjem pune kopije podataka na čvorovima Kubernet klastera.
- Drugi važan nedostatak je sigurnost. Po defaultu, funkcije povezane s osiguranjem sigurnosti prilikom pokretanja Spark zadataka su onemogućene, a korištenje Kerberosa u zvaničnoj dokumentaciji nije pokriveno (iako su odgovarajući parametri uvedeni u verziji 3.0.0, što će zahtijevati dodatnu obradu), a u dokumentaciji o sigurnosti prilikom korištenja Sparka (https://spark.apache.org/docs/2.4.5/security.html) kao spremišta ključeva navedeni su samo YARN, Mesos i Samostalni Klaster. Pri tome, korisnik pod kojim se izvršavaju Spark zadaci ne može biti direktno specificiran — mi samo postavljamo servisni račun pod kojim će raditi pod, a korisnik se bira na osnovu postavljenih sigurnosnih politika. U tom smislu, ili se koristi root korisnik, što nije sigurno u produkcijskom okruženju, ili korisnik sa slučajnim UID-om, što je nepraktično prilikom raspodjele prava pristupa podacima (što se može riješiti kreiranjem PodSecurityPolicies i njihovo vezivanje za odgovarajuće servisne račune). Trenutno se to rješava ili smještanjem svih potrebnih datoteka direktno u Docker sliku, ili modifikacijom skripte za pokretanje Sparka kako bi koristila mehanizam skladištenja i preuzimanja tajni koji je usvojen u vašoj organizaciji.
- Pokretanje zadataka Spark uz pomoć Kubernetesa još uvek je u eksperimentalnom režimu, i u budućnosti su moguće značajne promene u korišćenim artefaktima (konfiguracionim datotekama, osnovnim Docker slikama i skriptama za pokretanje). Zaista — tokom pripreme materijala testirane su verzije 2.3.0 i 2.4.5, a ponašanje se značajno razlikovalo.
Čekamo ažuriranja — nedavno je objavljena nova verzija Sparka (3.0.0), koja je donela značajne promene u radu Sparka na Kubernetesu, ali je zadržala eksperimentalni status podrške za ovog menadžera resursa. Moguće je da će sledeća ažuriranja zaista omogućiti preporučivanje odricanja od YARN-a i pokretanje zadataka Sparka na Kubernetesu, bez brige o bezbednosti vašeg sistema i bez potrebe za samostalnim doradama funkcionalnih komponenti.
Kraj.
Izvor: habr.com


