A leughadairean gràdhach, feasgar math. An-diugh bruidhnidh sinn beagan mu Apache Spark agus na cothroman leasachaidh aige.
Ann an saoghal an latha an-diugh de Dàta Mòr, is e Apache Spark an inbhe de facto airson gnìomhan giollachd dàta baidse a leasachadh. A bharrachd air an sin, tha e cuideachd air a chleachdadh gus tagraidhean sruthadh a chruthachadh a bhios ag obair anns a’ bhun-bheachd meanbh-batch, a ’giullachd agus a’ lìbhrigeadh dàta ann an cuibhreannan beaga (Spark Structured Streaming). Agus gu traidiseanta tha e air a bhith na phàirt den stac Hadoop iomlan, a’ cleachdadh YARN (no ann an cuid de chùisean Apache Mesos) mar mhanaidsear ghoireasan. Ro 2020, tha a chleachdadh san fhoirm thraidiseanta aige fo cheist airson a’ mhòr-chuid de chompanaidhean air sgàth dìth sgaoilidhean reusanta Hadoop - tha leasachadh HDP agus CDH air stad, chan eil CDH air a dheagh leasachadh agus tha cosgais àrd aige, agus tha na solaraichean Hadoop a tha air fhàgail air stad. an dara cuid sguir a bhith ann no le droch àm ri teachd. Mar sin, tha cur air bhog Apache Spark a’ cleachdadh Kubernetes a’ togail ùidh am measg na coimhearsnachd agus companaidhean mòra - a’ fàs na ìre àbhaisteach ann an orchestration container agus riaghladh ghoireasan ann an sgòthan prìobhaideach is poblach, bidh e a’ fuasgladh na duilgheadas le clàradh ghoireasan mì-ghoireasach de ghnìomhan Spark air YARN agus a’ toirt seachad àrd-ùrlar a tha a’ sìor leasachadh le mòran sgaoilidhean malairteach is fosgailte do chompanaidhean de gach meud is strì. A bharrachd air an sin, mar thoradh air a bhith mòr-chòrdte, tha a ’mhòr-chuid air faighinn a-mach mu thràth air dhà de na h-ionadan aca fhèin fhaighinn agus tha iad air an eòlas air a chleachdadh a mheudachadh, a tha a’ sìmpleachadh a ’ghluasaid.
A’ tòiseachadh le dreach 2.3.0, fhuair Apache Spark taic oifigeil airson a bhith a’ ruith ghnìomhan ann an cruinneachadh Kubernetes agus an-diugh, bruidhnidh sinn mu inbheachd gnàthach an dòigh-obrach seo, diofar roghainnean airson a chleachdadh agus na duilgheadasan a thig orra nuair a thèid a bhuileachadh.
An toiseach, leig dhuinn sùil a thoirt air a’ phròiseas airson gnìomhan agus tagraidhean a leasachadh stèidhichte air Apache Spark agus comharraich cùisean àbhaisteach anns am feum thu gnìomh a ruith air buidheann Kubernetes. Ann a bhith ag ullachadh na dreuchd seo, thèid OpenShift a chleachdadh mar sgaoileadh agus thèid òrdughan a tha buntainneach don ghoireas loidhne-àithne (oc) aige a thoirt seachad. Airson sgaoilidhean Kubernetes eile, faodar na h-òrdughan co-fhreagarrach bho ghoireas loidhne-àithne àbhaisteach Kubernetes (kubectl) no an analogues (mar eisimpleir, airson poileasaidh oc adm) a chleachdadh.
Cùis cleachdaidh sa chiad àite - cuir a-steach spark
Rè leasachadh ghnìomhan agus thagraidhean, feumaidh an leasaiche gnìomhan a ruith gus cruth-atharrachadh dàta a dheasbad. Gu teòiridheach, faodar stubs a chleachdadh airson na h-adhbharan sin, ach tha leasachadh le com-pàirt fìor (ged a tha deuchainn) de shiostaman crìochnachaidh air a bhith nas luaithe agus nas fheàrr anns a’ chlas seo de ghnìomhan. Anns a ’chùis nuair a bhios sinn a’ deasbad air fìor eisimpleirean de shiostaman crìochnachaidh, tha dà shuidheachadh comasach:
- bidh an leasaiche a’ ruith gnìomh Spark gu h-ionadail ann am modh leis fhèin;
- bidh leasaiche a’ ruith gnìomh Spark air cruinneachadh Kubernetes ann an lùb deuchainn.
Tha còir aig a’ chiad roghainn a bhith ann, ach tha grunn eas-bhuannachdan ann:
- Feumaidh cothrom a thoirt do gach leasaiche bhon àite-obrach gu gach suidheachadh de na siostaman crìochnachaidh a dh’ fheumas e;
- tha feum air tòrr ghoireasan air an inneal obrach gus an obair a thathar a’ leasachadh a ruith.
Chan eil na h-eas-bhuannachdan sin aig an dàrna roghainn, leis gu bheil cleachdadh cruinneachadh Kubernetes a’ toirt cothrom dhut an stòras ghoireasan riatanach a riarachadh airson gnìomhan a ruith agus an ruigsinneachd riatanach a thoirt dha gu suidheachaidhean siostam crìochnachaidh, a’ toirt cothrom sùbailte air a’ cleachdadh modal dreuchd Kubernetes airson. gach ball den sgioba leasachaidh. Nach comharraich sinn e mar a’ chiad chùis cleachdaidh - a’ cur air bhog gnìomhan Spark bho inneal leasaiche ionadail air cruinneachadh Kubernetes ann an lùb deuchainn.
Bruidhnidh sinn barrachd mun phròiseas airson Spark a stèidheachadh airson a ruith gu h-ionadail. Gus tòiseachadh air Spark a chleachdadh feumaidh tu a stàladh:
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
Bidh sinn a’ cruinneachadh na pacaidean riatanach airson a bhith ag obair le Kubernetes:
cd spark-2.4.5/
./build/mvn -Pkubernetes -DskipTests clean package
Bheir togail slàn tòrr ùine, agus gus ìomhaighean Docker a chruthachadh agus an ruith air cruinneachadh Kubernetes, chan fheum thu ach faidhlichean jar bhon eòlaire “seanadh /”, gus nach urrainn dhut ach am fo-phròiseact seo a thogail:
./build/mvn -f ./assembly/pom.xml -Pkubernetes -DskipTests clean package
Gus obraichean Spark a ruith air Kubernetes, feumaidh tu ìomhaigh Docker a chruthachadh airson a chleachdadh mar ìomhaigh bunaiteach. Tha dà dhòigh-obrach comasach an seo:
- Tha an ìomhaigh Docker a chaidh a chruthachadh a’ toirt a-steach an còd gnìomh Spark so-ghnìomhaichte;
- Tha an ìomhaigh cruthaichte a’ toirt a-steach dìreach Spark agus na h-eisimeileachdan riatanach, tha an còd so-ghnìomhaichte air a chumail air astar (mar eisimpleir, ann an HDFS).
An toiseach, togaidh sinn ìomhaigh Docker anns a bheil eisimpleir deuchainn de ghnìomh Spark. Gus ìomhaighean Docker a chruthachadh, tha goireas aig Spark ris an canar “docker-image-tool”. Nì sinn sgrùdadh air a’ chuideachadh air:
./bin/docker-image-tool.sh --help
Le a chuideachadh, faodaidh tu ìomhaighean Docker a chruthachadh agus an luchdachadh suas gu clàran iomallach, ach gu gnàthach tha grunn eas-bhuannachdan ann:
- gun fhàilligeadh a’ cruthachadh 3 ìomhaighean Docker aig an aon àm - airson Spark, PySpark agus R;
- cha leig e leat ainm ìomhaigh a shònrachadh.
Mar sin, cleachdaidh sinn dreach atharraichte den ghoireas seo air a thoirt seachad gu h-ìosal:
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
Le a chuideachadh, bidh sinn a’ cruinneachadh ìomhaigh bunaiteach Spark anns a bheil gnìomh deuchainn airson Pi a’ cleachdadh Spark (an seo tha {docker-registry-url} URL do chlàr dhealbhan Docker, is e {repo} ainm an stòrais taobh a-staigh a’ chlàr, a tha a’ freagairt ris a’ phròiseact ann an OpenShift , {image-name} - ainm na h-ìomhaigh (ma chleachdar sgaradh trì-ìre de dhealbhan, mar eisimpleir, mar a tha sa chlàr amalaichte de dhealbhan Red Hat OpenShift), {tag} - taga seo dreach den dealbh):
./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
Log a-steach don bhuidheann OKD a’ cleachdadh goireas a’ chonsail (an seo tha {OKD-API-URL} URL API brabhsair OKD):
oc login {OKD-API-URL}
Faigh sinn comharra an neach-cleachdaidh gnàthach airson cead ann an Clàr an Docker:
oc whoami -t
Log a-steach don Chlàr Docker a-staigh den bhuidheann OKD (bidh sinn a’ cleachdadh an tòcan a fhuaireadh a’ cleachdadh an àithne roimhe mar am facal-faire):
docker login {docker-registry-url}
Nach luchdaich sinn suas an dealbh Docker cruinnichte gu Clàr an Docker OKD:
./bin/docker-image-tool-upd.sh -r {docker-registry-url}/{repo} -i {image-name} -t {tag} push
Feuch an dèan sinn cinnteach gu bheil an ìomhaigh cruinnichte ri fhaighinn ann an OKD. Gus seo a dhèanamh, fosgail an URL sa bhrobhsair le liosta de dhealbhan den phròiseact co-fhreagarrach (an seo tha {project} ainm a’ phròiseict taobh a-staigh brabhsair OpenShift, is e {OKD-WEBUI-URL} URL a’ chonsail lìn OpenShift). ) - https://{OKD-WEBUI-URL}/console /project/{project}/browse/images/{image-name}.
Gus gnìomhan a ruith, feumar cunntas seirbheis a chruthachadh leis na sochairean gus pods a ruith mar fhreumh (bruidhnidh sinn air a’ phuing seo nas fhaide air adhart):
oc create sa spark -n {project}
oc adm policy add-scc-to-user anyuid -z spark -n {project}
Feuch an ruith sinn an àithne spark-submit gus gnìomh Spark fhoillseachadh don bhuidheann OKD, a ’sònrachadh a’ chunntas seirbheis cruthaichte agus ìomhaigh Docker:
/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
An seo:
-name - ainm na h-obrach a bhios a 'gabhail pàirt ann an cruthachadh ainm nan Kubernetes pods;
-class - clas den fhaidhle so-ghnìomhaichte, ris an canar nuair a thòisicheas an obair;
-conf - paramadairean rèiteachaidh Spark;
spark.executor.instances — an àireamh de luchd-tiomnaidh Spark ri chur air bhog;
spark.kubernetes.authenticate.driver.serviceAccountName - ainm a’ chunntais seirbheis Kubernetes a chaidh a chleachdadh nuair a thathar a’ cur pods air bhog (gus an co-theacs tèarainteachd agus na comasan a mhìneachadh nuair a bhios tu ag eadar-obrachadh leis an Kubernetes API);
spark.kubernetes.namespace — Àite-ainm Kubernetes anns an tèid pods draibhear is neach-tiomnaidh a chuir air bhog;
spark.submit.deployMode - dòigh air Spark a chuir air bhog (airson “cluster” àbhaisteach cuir a-steach sradag air a chleachdadh, airson Spark Operator agus dreachan nas fhaide air adhart de Spark “client”);
spark.kubernetes.container.image - Ìomhaigh docker air a chleachdadh gus pods a chuir air bhog;
spark.master - Kubernetes API URL (tha taobh a-muigh air a shònrachadh gus am bi ruigsinneachd bhon inneal ionadail);
local: // a bheil an t-slighe chun an Spark a ghabhas coileanadh taobh a-staigh ìomhaigh an Docker.
Thèid sinn chun phròiseact iomchaidh OKD agus nì sinn sgrùdadh air na pods a chaidh a chruthachadh - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods.
Gus am pròiseas leasachaidh a dhèanamh nas sìmplidhe, faodar roghainn eile a chleachdadh, anns a bheil ìomhaigh bunaiteach cumanta de Spark air a chruthachadh, air a chleachdadh leis a h-uile gnìomh airson a ruith, agus dealbhan de fhaidhlichean so-ghnìomhaichte air am foillseachadh gu stòradh taobh a-muigh (mar eisimpleir, Hadoop) agus air an sònrachadh nuair a bhios iad a’ gairm spark-cuir a-steach mar cheangal. Anns a 'chùis seo, faodaidh tu dreachan eadar-dhealaichte de ghnìomhan Spark a ruith gun a bhith ag ath-thogail ìomhaighean Docker, a' cleachdadh, mar eisimpleir, WebHDFS gus ìomhaighean fhoillseachadh. Cuiridh sinn iarrtas airson faidhle a chruthachadh (seo {host} is e aoigheachd seirbheis WebHDFS, is e {port} port na seirbheis WebHDFS, is e {path-to-file-on-hdfs} an t-slighe dhan fhaidhle a thathar ag iarraidh air HDFS):
curl -i -X PUT "http://{host}:{port}/webhdfs/v1/{path-to-file-on-hdfs}?op=CREATE
Gheibh thu freagairt mar seo (Seo {location} an URL a dh’ fheumar a chleachdadh gus am faidhle a luchdachadh sìos):
HTTP/1.1 307 TEMPORARY_REDIRECT
Location: {location}
Content-Length: 0
Luchdaich am faidhle so-ghnìomhaichte Spark gu HDFS (an seo tha {path-to-local-file} an t-slighe chun fhaidhle so-ghnìomhaichte Spark air an òstair gnàthach):
curl -i -X PUT -T {path-to-local-file} "{location}"
Às deidh seo, is urrainn dhuinn spark-submit a dhèanamh a’ cleachdadh am faidhle Spark a chaidh a luchdachadh suas gu HDFS (Seo {name-class} ainm a’ chlas a dh’ fheumar a chuir air bhog gus an obair a choileanadh):
/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}
Bu chòir a thoirt fa-near, gus faighinn gu HDFS agus dèanamh cinnteach gu bheil an gnìomh ag obair, is dòcha gum feum thu an Dockerfile agus an sgriobt entrypoint.sh atharrachadh - cuir stiùireadh ris an Dockerfile gus leabharlannan eisimeileach a chopaigeadh chun eòlaire / opt/spark/jars agus cuir a-steach am faidhle rèiteachaidh HDFS ann an SPARK_CLASSPATH anns an àite inntrigidh.sh.
An dàrna cùis cleachdaidh - Apache Livy
A bharrachd air an sin, nuair a thèid gnìomh a leasachadh agus feumar an toradh a dhearbhadh, tha a’ cheist ag èirigh mu bhith ga chuir air bhog mar phàirt den phròiseas CI / CD agus a’ cumail sùil air inbhe a coileanadh. Gu dearbh, faodaidh tu a ruith le bhith a ’cleachdadh gairm cuir a-steach sradag ionadail, ach tha seo a’ dèanamh duilgheadas don bhun-structar CI / CD leis gu feum e stàladh agus rèiteachadh Spark air riochdairean / luchd-ruithidh an fhrithealaiche CI agus a ’stèidheachadh ruigsinneachd don Kubernetes API. Airson a ’chùis seo, tha am buileachadh targaid air roghnachadh Apache Livy a chleachdadh mar REST API airson gnìomhan Spark a ruith taobh a-staigh buidheann Kubernetes. Le a chuideachadh, faodaidh tu gnìomhan Spark a ruith air cruinneachadh Kubernetes a’ cleachdadh iarrtasan cURL cunbhalach, a tha furasta an cur an gnìomh stèidhichte air fuasgladh CI sam bith, agus tha a shuidheachadh taobh a-staigh cruinneachadh Kubernetes a’ fuasgladh cùis dearbhaidh nuair a bhios tu ag eadar-obrachadh leis an Kubernetes API.
Nach comharraich sinn e mar dhàrna cùis cleachdaidh - a’ ruith gnìomhan Spark mar phàirt de phròiseas CI / CD air cruinneachadh Kubernetes ann an lùb deuchainn.
Beagan mu Apache Livy - bidh e ag obair mar fhrithealaiche HTTP a bheir seachad eadar-aghaidh lìn agus API RESTful a leigeas leat spark-submit a chuir air bhog air astar le bhith a ’dol seachad air na paramadairean riatanach. Gu traidiseanta chaidh a chuir air falbh mar phàirt de chuairteachadh HDP, ach faodar cuideachd a chuir gu OKD no stàladh Kubernetes sam bith eile a’ cleachdadh am foillseachadh iomchaidh agus seata de dhealbhan Docker, leithid am fear seo - . Airson ar cùise, chaidh ìomhaigh Docker coltach ris a thogail, a ’toirt a-steach dreach Spark 2.4.5 bhon Dockerfile a leanas:
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"]
Faodar an ìomhaigh a chaidh a chruthachadh a thogail agus a luchdachadh suas chun stòr Docker a th’ agad mu thràth, leithid an stòr OKD a-staigh. Gus a chleachdadh, cleachd am foillseachadh a leanas ({registry-url} - URL clàr dhealbhan an Docker, {image-name} - Ainm ìomhaigh an Docker, {tag} - Tag ìomhaigh Docker, {livy-url} - URL a tha thu ag iarraidh far a bheil an bidh am frithealaiche ruigsinneach Livy; tha am foillseachadh “Route” air a chleachdadh ma thèid Red Hat OpenShift a chleachdadh mar an cuairteachadh Kubernetes, air neo thèid am foillseachadh Ingress no Seirbheis co-fhreagarrach den t-seòrsa NodePort a chleachdadh):
---
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
Às deidh dha a chuir an sàs agus am pod a chuir air bhog gu soirbheachail, tha eadar-aghaidh grafaigeach Livy ri fhaighinn aig a’ cheangal: http://{livy-url}/ui. Le Livy, is urrainn dhuinn ar gnìomh Spark fhoillseachadh a’ cleachdadh iarrtas REST bho, mar eisimpleir, Postman. Tha eisimpleir de chruinneachadh le iarrtasan air a thoirt seachad gu h-ìosal (faodar argamaidean rèiteachaidh le caochladairean a tha riatanach airson obrachadh na h-obrach a chaidh a chuir air bhog a thoirt seachad anns an raon “args”):
{
"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": {}
}
Nach cuir sinn an gnìomh a’ chiad iarrtas bhon chruinneachadh, rach gu eadar-aghaidh OKD agus dèan cinnteach gu bheil an gnìomh air a chuir air bhog gu soirbheachail - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods. Aig an aon àm, nochdaidh seisean anns an eadar-aghaidh Livy (http://{livy-url}/ui), anns an taobh a-staigh, le bhith a’ cleachdadh Livy API no eadar-aghaidh grafaigeach, is urrainn dhut adhartas na h-obrach a leantainn agus an seisean a sgrùdadh logaichean.
A-nis leig dhuinn sealltainn mar a tha Livy ag obair. Gus seo a dhèanamh, leig dhuinn sgrùdadh a dhèanamh air logaichean an t-soithich Livy am broinn a’ phod leis an t-seirbheisiche Livy - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods/{livy-pod-name }?tab=logaichean. bhuapa chì sinn nuair a chuireas sinn fios gu Livy REST API ann an soitheach leis an ainm “livy”, gu bheilear a’ cur a-steach sradag, coltach ris an fhear a chleachd sinn gu h-àrd (an seo {livy-pod-name} is e ainm a’ pod a chaidh a chruthachadh). leis an t-seirbheisiche Livy). Tha an cruinneachadh cuideachd a’ toirt a-steach dàrna ceist a leigeas leat gnìomhan a ruith a bheir aoigheachd do ghnìomhachd Spark air astar a’ cleachdadh frithealaiche Livy.
Cùis treas cleachdaidh - Spark Operator
A-nis gu bheil an obair air a dhearbhadh, tha a 'cheist mu bhith ga ruith ag èirigh gu cunbhalach. Is e an dòigh dhùthchasach air gnìomhan a ruith gu cunbhalach ann am buidheann Kubernetes an eintiteas CronJob agus faodaidh tu a chleachdadh, ach aig an àm seo tha fèill mhòr air cleachdadh ghnìomhaichean gus tagraidhean ann an Kubernetes a riaghladh agus airson Spark tha gnìomhaiche gu math aibidh, a tha cuideachd air a chleachdadh ann am fuasglaidhean ìre Iomairt (mar eisimpleir, Lightbend FastData Platform). Tha sinn a’ moladh a chleachdadh - tha roghainnean rèiteachaidh caran cuibhrichte aig an dreach seasmhach gnàthach de Spark (2.4.5) airson gnìomhan Spark a ruith ann an Kubernetes, fhad ‘s a tha an ath dhreach mòr (3.0.0) ag ainmeachadh làn thaic dha Kubernetes, ach tha an ceann-latha fuasglaidh fhathast neo-aithnichte . Bidh Spark Operator a’ dèanamh dìoladh airson an easbhaidh seo le bhith a’ cur roghainnean rèiteachaidh cudromach ris (mar eisimpleir, a’ cur suas ConfigMap le rèiteachadh ruigsinneachd Hadoop gu pods Spark) agus an comas gnìomh àbhaisteach a ruith.
Nach comharraich sinn e mar an treas cùis cleachdaidh - a’ ruith gnìomhan Spark gu cunbhalach air cruinneachadh Kubernetes ann an lùb cinneasachaidh.
Tha Spark Operator na stòr fosgailte agus air a leasachadh taobh a-staigh Àrd-ùrlar Google Cloud - . Faodar a stàladh a dhèanamh ann an 3 dòighean:
- Mar phàirt de stàladh Lightbend FastData Platform/Cloudflow;
- A' cleachdadh Helm:
helm repo add incubator http://storage.googleapis.com/kubernetes-charts-incubator helm install incubator/sparkoperator --namespace spark-operator - A’ cleachdadh taisbeanairean bhon ionad-tasgaidh oifigeil (https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/tree/master/manifest). Is fhiach a bhith mothachail air na leanas - tha Cloudflow a’ toirt a-steach gnìomhaiche le dreach API v1beta1. Ma thèid an seòrsa stàlaidh seo a chleachdadh, bu chòir tuairisgeulan tagraidh Spark a bhith stèidhichte air tagaichean eisimpleir ann an Git leis an dreach API iomchaidh, mar eisimpleir, “v1beta1-0.9.0-2.4.0”. Gheibhear an dreach den ghnìomhaiche anns an tuairisgeul air an CRD a tha air a ghabhail a-steach don ghnìomhaiche anns an fhaclair “dreachan”:
oc get crd sparkapplications.sparkoperator.k8s.io -o yaml
Ma tha an gnìomhaiche air a chuir a-steach gu ceart, nochdaidh pod gnìomhach leis a ’ghnìomhaiche Spark anns a’ phròiseact co-fhreagarrach (mar eisimpleir, cloudflow-fdp-sparkoperator anns an àite Cloudflow airson an stàladh Cloudflow) agus nochdaidh goireas goireas Kubernetes co-fhreagarrach leis an t-ainm “sparkapplications” . Faodaidh tu sgrùdadh a dhèanamh air tagraidhean Spark a tha rim faighinn leis an àithne a leanas:
oc get sparkapplications -n {project}
Gus gnìomhan a ruith a’ cleachdadh Spark Operator feumaidh tu 3 rudan a dhèanamh:
- cruthaich ìomhaigh Docker anns a bheil na leabharlannan riatanach uile, a bharrachd air rèiteachaidh agus faidhlichean so-ghnìomhaichte. Anns an dealbh targaid, is e seo ìomhaigh a chaidh a chruthachadh aig ìre CI / CD agus air a dhearbhadh air cruinneachadh deuchainn;
- foillsich ìomhaigh Docker gu clàr a tha ruigsinneach bho bhuidheann Kubernetes;
- cruthaich foillseachadh leis an t-seòrsa “SparkApplication” agus tuairisgeul air a ’ghnìomh a thèid a chuir air bhog. Tha eisimpleirean de thaisbeanaidhean rim faighinn anns an ionad-tasgaidh oifigeil (m.e. ). Tha puingean cudromach ri thoirt fa-near mun manifesto:
- feumaidh am faclair “apiVersion” an dreach API a tha co-chosmhail ris an dreach gnìomhaiche a chomharrachadh;
- feumaidh am faclair “metadata.namespace” an t-ainm-fànais anns an tèid an aplacaid a chuir air bhog a chomharrachadh;
- feumaidh seòladh an ìomhaigh Docker cruthaichte a bhith anns an fhaclair “spec.image” ann an clàr ruigsinneach;
- feumaidh an clas gnìomh Spark a bhith anns an fhaclair “spec.mainClass” a dh'fheumar a ruith nuair a thòisicheas am pròiseas;
- feumaidh an t-slighe chun fhaidhle jar so-ghnìomhaichte a bhith anns an fhaclair “spec.mainApplicationFile”;
- feumaidh am faclair “spec.sparkVersion” sealltainn dè an tionndadh de Spark a thathas a’ cleachdadh;
- feumaidh am faclair “spec.driver.serviceAccount” an cunntas seirbheis a shònrachadh taobh a-staigh an àite ainm Kubernetes co-fhreagarrach a thèid a chleachdadh gus an tagradh a ruith;
- feumaidh am faclair “spec.executor” an àireamh de ghoireasan a chaidh a thoirt don tagradh a chomharrachadh;
- feumaidh am faclair "spec.volumeMounts" an eòlaire ionadail a shònrachadh anns an tèid na faidhlichean gnìomh ionadail Spark a chruthachadh.
Tha eisimpleir de bhith a’ gineadh foillseachadh (an seo {spark-service-account} na chunntas seirbheis taobh a-staigh cruinneachadh Kubernetes airson gnìomhan Spark a ruith):
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"
Tha am foillseachadh seo a’ sònrachadh cunntas seirbheis air am feum thu, mus foillsich thu am foillseachadh, na ceanglachan dreuchd riatanach a chruthachadh a bheir seachad na còraichean-slighe a tha riatanach airson an tagradh Spark gus eadar-obrachadh leis an Kubernetes API (ma tha sin riatanach). Anns a ’chùis againn, feumaidh an tagradh còraichean gus Pods a chruthachadh. Cruthaichidh sinn an dleastanas ceangail riatanach:
oc adm policy add-role-to-user edit system:serviceaccount:{project}:{spark-service-account} -n {project}
Is fhiach a bhith mothachail cuideachd gum faodadh an sònrachadh follaiseach seo a bhith a’ toirt a-steach paramadair “hadoopConfigMap”, a leigeas leat ConfigMap a shònrachadh le rèiteachadh Hadoop gun a bhith agad am faidhle co-fhreagarrach a chuir ann an ìomhaigh Docker an toiseach. Tha e cuideachd freagarrach airson gnìomhan a ruith gu cunbhalach - a 'cleachdadh am paramadair "clàr", faodar clàr-ama airson a bhith a' ruith gnìomh sònraichte a shònrachadh.
Às deidh sin, bidh sinn a’ sàbhaladh ar taisbeanach don fhaidhle spark-pi.yaml agus ga chuir an sàs anns a’ bhuidheann Kubernetes againn:
oc apply -f spark-pi.yaml
Cruthaichidh seo rud den t-seòrsa “sparkapplications”:
oc get sparkapplications -n {project}
> NAME AGE
> spark-pi 22h
Anns a ’chùis seo, thèid pod le tagradh a chruthachadh, agus thèid an inbhe aige a thaisbeanadh anns na“ sparkapplications ”a chaidh a chruthachadh. Faodaidh tu fhaicinn leis an òrdugh a leanas:
oc get sparkapplications spark-pi -o yaml -n {project}
Nuair a bhios an obair deiseil, gluaisidh am POD chun inbhe “Crìochnaichte”, a bheir ùrachadh cuideachd ann an “Sparkapplications”. Faodar logaichean tagraidh fhaicinn sa bhrobhsair no a’ cleachdadh an àithne a leanas (an seo {sparkapplications-pod-name} ainm pod na h-obrach ruith):
oc logs {sparkapplications-pod-name} -n {project}
Faodar gnìomhan spark a riaghladh cuideachd le bhith a’ cleachdadh goireas sònraichte sparkctl. Gus a stàladh, clon an stòr leis a’ chòd stòr aige, stàlaich Go agus tog an goireas seo:
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
Nach dèan sinn sgrùdadh air an liosta de ghnìomhan ruith Spark:
sparkctl list -n {project}
Cruthaichidh sinn tuairisgeul airson gnìomh 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"
Feuch an ruith sinn an obair a chaidh a mhìneachadh le sparkctl:
sparkctl create spark-app.yaml -n {project}
Nach dèan sinn sgrùdadh air an liosta de ghnìomhan ruith Spark:
sparkctl list -n {project}
Nach dèan sinn sgrùdadh air an liosta de thachartasan ann an gnìomh Spark a chaidh a chuir air bhog:
sparkctl event spark-pi -n {project} -f
Nach dèan sinn sgrùdadh air inbhe na h-obrach ruith Spark:
sparkctl status spark-pi -n {project}
Gu crìch, bu mhath leam beachdachadh air na h-eas-bhuannachdan a chaidh a lorg bho bhith a’ cleachdadh an dreach seasmhach gnàthach de Spark (2.4.5) ann an Kubernetes:
- Is e a’ chiad agus, is dòcha, am prìomh ana-cothrom dìth sgìre dàta. A dh'aindeoin a h-uile easbhaidhean YARN, bha buannachdan ann cuideachd a bhith ga chleachdadh, mar eisimpleir, am prionnsabal a bhith a 'lìbhrigeadh còd gu dàta (seach dàta gu còd). Taing dha, chaidh gnìomhan Spark a chuir gu bàs air na nodan far an deach an dàta a bha an sàs anns an àireamhachadh a shuidheachadh, agus chaidh an ùine a thug e gus dàta a lìbhrigeadh thairis air an lìonra a lughdachadh gu mòr. Nuair a bhios sinn a’ cleachdadh Kubernetes, tha sinn mu choinneimh an fheum air dàta a tha an sàs ann an gnìomh a ghluasad thairis air an lìonra. Ma tha iad mòr gu leòr, faodaidh an ùine cur an gnìomh àrdachadh gu mòr, agus feumaidh e cuideachd tòrr rùm diosc a tha air a shònrachadh airson suidheachaidhean gnìomh Spark airson an stòradh sealach. Faodar an ana-cothrom seo a lasachadh le bhith a’ cleachdadh bathar-bog sònraichte a nì cinnteach gu bheil sgìre dàta ann an Kubernetes (mar eisimpleir, Alluxio), ach tha seo dha-rìribh a’ ciallachadh gum feumar leth-bhreac iomlan den dàta a stòradh air nodan cruinneachadh Kubernetes.
- Is e an dàrna eas-bhuannachd chudromach tèarainteachd. Gu gnàthach, tha feartan co-cheangailte ri tèarainteachd a thaobh a bhith a’ ruith gnìomhan Spark ciorramach, chan eil cleachdadh Kerberos air a chòmhdach anns na sgrìobhainnean oifigeil (ged a chaidh na roghainnean co-fhreagarrach a thoirt a-steach ann an dreach 3.0.0, a dh’ fheumas obair a bharrachd), agus na sgrìobhainnean tèarainteachd airson a’ cleachdadh Spark (https://spark.apache.org/docs/2.4.5/security.html) chan eil ach YARN, Mesos agus Standalone Cluster a’ nochdadh mar phrìomh stòran. Aig an aon àm, chan urrainnear an neach-cleachdaidh fon tèid gnìomhan Spark a chuir air bhog a shònrachadh gu dìreach - cha bhith sinn a ’sònrachadh ach an cunntas seirbheis fon obraich e, agus tha an neach-cleachdaidh air a thaghadh stèidhichte air na poileasaidhean tèarainteachd rèiteachaidh. A thaobh seo, thathas a’ cleachdadh an dàrna cuid an cleachdaiche freumh, nach eil sàbhailte ann an àrainneachd chinneasach, no neach-cleachdaidh le UID air thuaiream, a tha mì-ghoireasach nuair a bhios tu a’ sgaoileadh chòraichean-slighe gu dàta (faodar seo fhuasgladh le bhith a’ cruthachadh PodSecurityPolicies agus gan ceangal ris an cunntasan seirbheis co-fhreagarrach). An-dràsta, is e am fuasgladh an dàrna cuid na faidhlichean riatanach uile a chuir gu dìreach ann an ìomhaigh Docker, no an sgriobt cur air bhog Spark atharrachadh gus an uidheamachd a chleachdadh airson dìomhaireachdan a chaidh a ghabhail sa bhuidheann agad a stòradh agus fhaighinn air ais.
- Tha ruith obraichean Spark a’ cleachdadh Kubernetes gu h-oifigeil fhathast ann am modh deuchainneach agus dh’ fhaodadh gum bi atharrachaidhean mòra anns na stuthan a thathar a’ cleachdadh (faidhlichean rèiteachaidh, ìomhaighean bonn Docker, agus sgriobtaichean cur air bhog) san àm ri teachd. Agus gu dearbh, nuair a chaidh an stuth ullachadh, chaidh tionndaidhean 2.3.0 agus 2.4.5 a dhearbhadh, bha an giùlan gu math eadar-dhealaichte.
Fuirichidh sinn airson ùrachaidhean - chaidh dreach ùr de Spark (3.0.0) fhoillseachadh o chionn ghoirid, a thug atharrachaidhean mòra air obair Spark air Kubernetes, ach a ghlèidh inbhe taic deuchainneach don mhanaidsear ghoireasan seo. Is dòcha gun dèan na h-ath ùrachaidhean e comasach dha-rìribh a bhith a’ moladh YARN a thrèigsinn agus gnìomhan Spark a ruith air Kubernetes gun eagal mu thèarainteachd an t-siostaim agad agus gun fheum air pàirtean gnìomh atharrachadh gu neo-eisimeileach.
Fionn.
Source: www.habr.com