Kubernetes මත Apache Spark ධාවනය කිරීම

හිතවත් පාඨකයින්, සුභ සන්ධ්‍යාවක්. අද අපි Apache Spark සහ එහි සංවර්ධන අපේක්ෂාවන් ගැන ටිකක් කතා කරමු.

Big Data හි නවීන ලෝකයේ, Apache Spark යනු කණ්ඩායම් දත්ත සැකසීමේ කාර්යයන් සංවර්ධනය කිරීම සඳහා වන තත්‍ය ප්‍රමිතියයි. මීට අමතරව, එය කුඩා කොටස්වල (Spark Structured Streaming) දත්ත සැකසීම සහ නැව්ගත කිරීම, micro batch සංකල්පය තුළ ක්‍රියා කරන ප්‍රවාහ යෙදුම් නිර්මාණය කිරීමට ද භාවිතා වේ. සම්ප්‍රදායිකව එය සම්පත් කළමනාකරු ලෙස YARN (හෝ සමහර අවස්ථාවල Apache Mesos) භාවිතා කරමින් සමස්ත Hadoop තොගයේ කොටසක් වී ඇත. 2020 වන විට, එහි සාම්ප්‍රදායික ස්වරූපයෙන් එය භාවිතා කිරීම යහපත් Hadoop බෙදාහැරීම් නොමැතිකම හේතුවෙන් බොහෝ සමාගම් සඳහා විශාල ප්‍රශ්නාර්ථ ලකුණකි - HDP සහ CDH සංවර්ධනය නතර වී ඇත, CDH ප්‍රමාණවත් ලෙස සංවර්ධනය වී නොමැති අතර ඉහළ පිරිවැයක් ඇත, සහ ඉතිරි Hadoop සැපයුම්කරුවන් එක්කෝ පැවැත්ම නතර වී හෝ අඳුරු අනාගතයක් ඇත. එබැවින්, Kubernetes භාවිතා කරමින් Apache Spark දියත් කිරීම ප්‍රජාව සහ විශාල සමාගම් අතර උනන්දුව වැඩි කරයි - පුද්ගලික සහ පොදු වලාකුළු වල බහාලුම් වාද්‍ය වෘන්දයේ සහ සම්පත් කළමනාකරණයේ ප්‍රමිතියක් බවට පත්වීම, එය YARN හි Spark කාර්යයන් සඳහා අපහසු සම්පත් උපලේඛනගත කිරීමේ ගැටළුව විසඳන අතර සපයයි. සියලුම ප්‍රමාණයේ සහ ඉරි සහිත සමාගම් සඳහා බොහෝ වාණිජ හා විවෘත බෙදාහැරීම් සහිත ක්‍රමයෙන් සංවර්ධනය වෙමින් පවතින වේදිකාවකි. ඊට අමතරව, ජනප්‍රියතාවයෙන් පසුව, බොහෝ දෙනෙක් දැනටමත් තමන්ගේම ස්ථාපනයන් කිහිපයක් ලබා ගැනීමට සමත් වී ඇති අතර එහි භාවිතය පිළිබඳ ඔවුන්ගේ විශේෂ ise තාව වැඩි කර ඇති අතර එමඟින් පියවර සරල කරයි.

2.3.0 අනුවාදයෙන් පටන් ගෙන, Apache Spark Kubernetes පොකුරක් තුළ කාර්යයන් ධාවනය කිරීම සඳහා නිල සහාය ලබා ගත් අතර අද අපි මෙම ප්‍රවේශයේ වර්තමාන පරිණතභාවය, එහි භාවිතය සඳහා විවිධ විකල්ප සහ ක්‍රියාත්මක කිරීමේදී මුහුණ දෙන අන්තරායන් ගැන කතා කරමු.

පළමුවෙන්ම, අපි Apache Spark මත පදනම්ව කාර්යයන් සහ යෙදුම් සංවර්ධනය කිරීමේ ක්‍රියාවලිය දෙස බලමු සහ ඔබට Kubernetes පොකුරක් මත කාර්යයක් ක්‍රියාත්මක කිරීමට අවශ්‍ය සාමාන්‍ය අවස්ථා ඉස්මතු කරමු. මෙම තනතුර සකස් කිරීමේදී OpenShift බෙදාහැරීමක් ලෙස භාවිතා කරන අතර එහි විධාන රේඛා උපයෝගීතාවයට (oc) අදාල විධාන ලබා දෙනු ඇත. අනෙකුත් Kubernetes බෙදාහැරීම් සඳහා, සම්මත Kubernetes විධාන රේඛා උපයෝගීතාවයෙන් (kubectl) අනුරූප විධාන හෝ ඒවායේ ප්‍රතිසම (උදාහරණයක් ලෙස, oc adm ප්‍රතිපත්තිය සඳහා) භාවිතා කළ හැක.

පළමු භාවිත අවස්ථාව - spark-submit

කාර්යයන් සහ යෙදුම් සංවර්ධනය කිරීමේදී, දත්ත පරිවර්තනය නිදොස් කිරීම සඳහා සංවර්ධකයාට කාර්යයන් ධාවනය කිරීමට අවශ්‍ය වේ. න්‍යායාත්මකව, මෙම අරමුණු සඳහා stubs භාවිතා කළ හැකි නමුත්, අවසාන පද්ධතිවල සැබෑ (පරීක්ෂණයක් වුවද) අවස්ථා වල සහභාගීත්වය ඇතිව සංවර්ධනය මෙම කාර්ය පන්තියේ වේගවත් හා වඩා හොඳ බව ඔප්පු වී ඇත. අවසාන පද්ධතිවල සැබෑ අවස්ථාවන්හිදී අපි නිදොස් කරන විට, අවස්ථා දෙකක් හැකි ය:

• සංවර්ධකයා ස්වාධීන ආකාරයෙන් දේශීයව Spark කාර්යයක් ධාවනය කරයි;

  

• සංවර්ධකයෙකු පරීක්ෂණ ලූපයක Kubernetes පොකුරක් මත Spark කාර්යයක් ධාවනය කරයි.

  

පළමු විකල්පය පැවැත්මට අයිතියක් ඇත, නමුත් අවාසි ගණනාවක් ඇත:

• සෑම සංවර්ධකයෙකුටම සේවා ස්ථානයේ සිට ඔහුට අවශ්‍ය සියලුම අවසාන පද්ධති වෙත ප්‍රවේශය සැපයිය යුතුය;
• සංවර්ධනය වෙමින් පවතින කාර්යය ක්‍රියාත්මක කිරීම සඳහා වැඩ කරන යන්ත්‍රයේ ප්‍රමාණවත් සම්පත් ප්‍රමාණයක් අවශ්‍ය වේ.

දෙවන විකල්පයට මෙම අවාසි නොමැත, මන්ද කුබර්නෙටස් පොකුරක් භාවිතා කිරීමෙන් ඔබට ක්‍රියාත්මක වන කාර්යයන් සඳහා අවශ්‍ය සම්පත් සංචිතය වෙන් කිරීමට සහ අවසාන පද්ධති අවස්ථා සඳහා අවශ්‍ය ප්‍රවේශය ලබා දීමට ඉඩ සලසයි, කුබර්නෙටස් ආදර්ශය භාවිතා කරමින් නම්‍යශීලීව එයට ප්‍රවේශය ලබා දේ. සංවර්ධන කණ්ඩායමේ සියලුම සාමාජිකයින්. අපි එය පළමු භාවිත අවස්ථාව ලෙස ඉස්මතු කරමු - පරීක්ෂණ ලූපයක් තුළ Kubernetes පොකුරක් මත දේශීය සංවර්ධක යන්ත්‍රයකින් Spark කාර්යයන් දියත් කිරීම.

දේශීයව ධාවනය කිරීමට Spark පිහිටුවීමේ ක්‍රියාවලිය ගැන වැඩි විස්තර කතා කරමු. Spark භාවිතා කිරීම ආරම්භ කිරීමට ඔබ එය ස්ථාපනය කළ යුතුය:

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

අපි Kubernetes සමඟ වැඩ කිරීම සඳහා අවශ්ය පැකේජ එකතු කරමු:

cd spark-2.4.5/
./build/mvn -Pkubernetes -DskipTests clean package

සම්පූර්ණ ගොඩනැගීමට බොහෝ කාලයක් ගත වන අතර, ඩොකර් රූප සාදා ඒවා Kubernetes පොකුරක් මත ධාවනය කිරීමට, ඔබට සැබවින්ම අවශ්‍ය වන්නේ “එකලස් /” නාමාවලියෙන් jar ගොනු පමණි, එබැවින් ඔබට මෙම උප ව්‍යාපෘතිය පමණක් ගොඩනගා ගත හැකිය:

./build/mvn -f ./assembly/pom.xml -Pkubernetes -DskipTests clean package

Kubernetes මත Spark jobs ධාවනය කිරීමට, ඔබ මූලික රූපයක් ලෙස භාවිතා කිරීමට Docker රූපයක් සෑදිය යුතුය. මෙහි හැකි ප්රවේශයන් 2 ක් ඇත:

• ජනනය කරන ලද ඩොකර් රූපයේ ක්‍රියාත්මක කළ හැකි Spark කාර්ය කේතය ඇතුළත් වේ;
• සාදන ලද රූපයට ස්පාර්ක් සහ අවශ්‍ය පරායත්තතා පමණක් ඇතුළත් වේ, ක්‍රියාත්මක කළ හැකි කේතය දුරස්ථව සත්කාරකත්වය සපයයි (උදාහරණයක් ලෙස, HDFS හි).

පළමුව, Spark කාර්යයක පරීක්ෂණ උදාහරණයක් අඩංගු Docker රූපයක් ගොඩනඟමු. ඩොකර් රූප සෑදීමට, Spark හට "docker-image-tool" නමින් උපයෝගීතාවයක් ඇත. අපි එය මත උපකාර අධ්යයනය කරමු:

./bin/docker-image-tool.sh --help

එහි ආධාරයෙන්, ඔබට ඩොකර් පින්තූර සාදා ඒවා දුරස්ථ රෙජිස්ට්‍රි වෙත උඩුගත කළ හැකිය, නමුත් පෙරනිමියෙන් එයට අවාසි ගණනාවක් ඇත:

• නොවරදවාම එකවර ඩොකර් රූප 3 ක් නිර්මාණය කරයි - Spark, PySpark සහ R සඳහා;
• රූපයේ නමක් සඳහන් කිරීමට ඔබට ඉඩ නොදේ.

එබැවින්, අපි පහත දැක්වෙන මෙම උපයෝගීතාවයේ නවීකරණය කරන ලද අනුවාදයක් භාවිතා කරන්නෙමු:

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

එහි ආධාරයෙන්, අපි Spark භාවිතයෙන් Pi ගණනය කිරීම සඳහා පරීක්ෂණ කාර්යයක් අඩංගු මූලික Spark රූපයක් එකලස් කරමු (මෙහි {docker-registry-url} යනු ඔබේ ඩොකර් රූප රෙජිස්ට්‍රියේ URL වේ, {repo} යනු රෙජිස්ට්‍රිය තුළ ඇති ගබඩාවේ නමයි, OpenShift හි ව්‍යාපෘතියට ගැළපෙන, {image-name} - රූපයේ නම (පින්තූරවල තුන්-මට්ටම් වෙන් කිරීම භාවිතා කරන්නේ නම්, උදාහරණයක් ලෙස, Red Hat OpenShift පින්තූරවල ඒකාබද්ධ රෙජිස්ට්‍රියේ මෙන්), {tag} - මෙහි ටැගය රූපයේ අනුවාදය):

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

කොන්සෝල උපයෝගීතාව භාවිතයෙන් OKD පොකුරට ලොග් වන්න (මෙහි {OKD-API-URL} යනු OKD පොකුරු API URL වේ):

oc login {OKD-API-URL}

Docker Registry හි අවසරය සඳහා වත්මන් පරිශීලකයාගේ ටෝකනය ලබා ගනිමු:

oc whoami -t

OKD පොකුරේ අභ්‍යන්තර Docker Registry වෙත ලොග් වන්න (අපි පෙර විධානය භාවිතා කර ලබාගත් ටෝකනය මුරපදය ලෙස භාවිතා කරමු):

docker login {docker-registry-url}

අපි එකලස් කරන ලද ඩොකර් රූපය Docker Registry OKD වෙත උඩුගත කරමු:

./bin/docker-image-tool-upd.sh -r {docker-registry-url}/{repo} -i {image-name} -t {tag} push

එකලස් කරන ලද රූපය OKD හි තිබේදැයි පරීක්ෂා කරමු. මෙය සිදු කිරීම සඳහා, අදාළ ව්‍යාපෘතියේ පින්තූර ලැයිස්තුවක් සමඟ බ්‍රවුසරයේ URL විවෘත කරන්න (මෙහි {project} යනු OpenShift පොකුර තුළ ඇති ව්‍යාපෘතියේ නමයි, {OKD-WEBUI-URL} යනු OpenShift වෙබ් කොන්සෝලයේ URL වේ. ) - https://{OKD-WEBUI-URL}/console /project/{project}/browse/images/{image-name}.

කාර්යයන් ක්‍රියාත්මක කිරීම සඳහා, Pods root ලෙස ධාවනය කිරීමට වරප්‍රසාද සහිත සේවා ගිණුමක් සෑදිය යුතුය (අපි මෙම කරුණ පසුව සාකච්ඡා කරමු):

oc create sa spark -n {project}
oc adm policy add-scc-to-user anyuid -z spark -n {project}

සාදන ලද සේවා ගිණුම සහ ඩොකර් රූපය සඳහන් කරමින්, OKD පොකුරට Spark කාර්යයක් ප්‍රකාශ කිරීමට spark-submit විධානය ක්‍රියාත්මක කරමු:

 /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

මෙන්න:

- නම - කුබර්නෙටස් කරල් වල නම ගොඩනැගීමට සහභාගී වන කාර්යයේ නම;

—class — ක්‍රියාත්මක කළ හැකි ගොනුවේ පන්තිය, කාර්යය ආරම්භ වන විට කැඳවනු ලැබේ;

-conf - Spark වින්යාස පරාමිතීන්;

spark.executor.instances - දියත් කිරීමට Spark executors සංඛ්යාව;

spark.kubernetes.authenticate.driver.serviceAccountName - Pods දියත් කිරීමේදී භාවිතා කරන Kubernetes සේවා ගිණුමේ නම (Kubernetes API සමඟ අන්තර් ක්‍රියා කිරීමේදී ආරක්ෂක සන්දර්භය සහ හැකියාවන් නිර්වචනය කිරීමට);

spark.kubernetes.namespace — රියදුරු සහ ක්‍රියාත්මක කරන්නාගේ පොඩ්ස් දියත් කෙරෙන Kubernetes නාම අවකාශය;

spark.submit.deployMode — Spark දියත් කිරීමේ ක්‍රමය (සම්මත spark-submit "cluster" සඳහා Spark Operator සහ Spark "Client" හි පසු අනුවාද සඳහා භාවිතා වේ);

spark.kubernetes.container.image - කරල් දියත් කිරීමට භාවිතා කරන ඩොකර් රූපය;

spark.master — Kubernetes API URL (බාහිර නිශ්චිතව දක්වා ඇති බැවින් ප්‍රවේශය දේශීය යන්ත්‍රයෙන් සිදුවේ);

local:// යනු ඩොකර් රූපය තුළ ක්‍රියාත්මක කළ හැකි ස්පාර්ක් වෙත යන මාර්ගයයි.

අපි අදාළ OKD ව්‍යාපෘතිය වෙත ගොස් සාදන ලද කරල් අධ්‍යයනය කරන්නෙමු - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods.

සංවර්ධන ක්‍රියාවලිය සරල කිරීම සඳහා, වෙනත් විකල්පයක් භාවිතා කළ හැකිය, එහිදී Spark හි පොදු පාදක රූපයක් නිර්මාණය කර, ක්‍රියාත්මක කිරීම සඳහා සියලු කාර්යයන් භාවිතා කරයි, සහ ක්‍රියාත්මක කළ හැකි ගොනු වල ස්නැප්ෂොට් බාහිර ගබඩාවට ප්‍රකාශනය කරනු ලැබේ (උදාහරණයක් ලෙස, Hadoop) සහ ඇමතීමේ දී සඳහන් වේ. spark-submit සබැඳියක් ලෙස. මෙම අවස්ථාවෙහිදී, ඔබට ඩොකර් රූප නැවත ගොඩනැගීමකින් තොරව Spark කාර්යයන්හි විවිධ අනුවාද ධාවනය කළ හැක, උදාහරණයක් ලෙස, WebHDFS භාවිතා කරමින් පින්තූර ප්‍රකාශනය කරන්න. අපි ගොනුවක් සෑදීමට ඉල්ලීමක් එවන්නෙමු (මෙහි {host} යනු WebHDFS සේවාවේ ධාරකයයි, {port} යනු WebHDFS සේවාවේ වරායයි, {path-to-file-on-hdfs} යනු ගොනුව වෙත අපේක්ෂිත මාර්ගයයි. HDFS මත):

curl -i -X PUT "http://{host}:{port}/webhdfs/v1/{path-to-file-on-hdfs}?op=CREATE

ඔබට මෙවැනි ප්‍රතිචාරයක් ලැබෙනු ඇත (මෙහි {location} යනු ගොනුව බාගැනීමට භාවිතා කළ යුතු URL වේ):

HTTP/1.1 307 TEMPORARY_REDIRECT
Location: {location}
Content-Length: 0

Spark ක්‍රියාත්මක කළ හැකි ගොනුව HDFS වෙත පූරණය කරන්න (මෙහි {path-to-local-file} යනු වත්මන් ධාරකයේ Spark ක්‍රියාත්මක කළ හැකි ගොනුව වෙත යන මාර්ගයයි):

curl -i -X PUT -T {path-to-local-file} "{location}"

මෙයින් පසු, අපට HDFS වෙත උඩුගත කරන ලද Spark ගොනුව භාවිතයෙන් spark-submit කළ හැක (මෙහි {class-name} යනු කාර්යය සම්පූර්ණ කිරීමට දියත් කළ යුතු පන්තියේ නමයි):

/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}

HDFS වෙත ප්‍රවේශ වීම සහ කාර්යය ක්‍රියාත්මක වන බව සහතික කිරීම සඳහා, ඔබට Dockerfile සහ entrypoint.sh ස්ක්‍රිප්ට් වෙනස් කිරීමට අවශ්‍ය විය හැකි බව සටහන් කළ යුතුය - රඳා පවතින පුස්තකාල /opt/spark/jars බහලුම වෙත පිටපත් කිරීමට Dockerfile වෙත විධානයක් එක් කරන්න. SPARK_CLASSPATH හි HDFS වින්‍යාස ගොනුව ඇතුල්වීමේ ස්ථානයෙහි ඇතුළත් කරන්න.

දෙවන භාවිත අවස්ථාව - Apache Livy

තවද, කාර්යයක් සංවර්ධනය කර ප්‍රතිඵලය පරීක්ෂා කිරීමට අවශ්‍ය වූ විට, එය CI/CD ක්‍රියාවලියේ කොටසක් ලෙස දියත් කිරීම සහ එය ක්‍රියාත්මක කිරීමේ තත්ත්වය නිරීක්ෂණය කිරීම පිළිබඳ ප්‍රශ්නය පැන නගී. ඇත්ත වශයෙන්ම, ඔබට එය දේශීය ස්පාර්ක් ඉදිරිපත් කිරීමේ ඇමතුමක් භාවිතයෙන් ක්‍රියාත්මක කළ හැක, නමුත් මෙය CI/CD යටිතල ව්‍යුහය සංකීර්ණ කරයි, මන්ද එයට CI සේවාදායක නියෝජිතයින්/ධාවකයින් මත Spark ස්ථාපනය කිරීම සහ වින්‍යාස කිරීම සහ Kubernetes API වෙත ප්‍රවේශය සැකසීම අවශ්‍ය වන බැවිනි. මෙම අවස්ථාව සඳහා, ඉලක්ක ක්‍රියාත්මක කිරීම Kubernetes පොකුරක් තුළ සත්කාරකත්වය දරන Spark කාර්යයන් ධාවනය කිරීම සඳහා REST API ලෙස Apache Livy භාවිතා කිරීමට තෝරාගෙන ඇත. එහි ආධාරයෙන්, ඔබට ඕනෑම CI විසඳුමක් මත පදනම්ව පහසුවෙන් ක්‍රියාත්මක කළ හැකි සාමාන්‍ය cURL ඉල්ලීම් භාවිතයෙන් Kubernetes පොකුරක් මත Spark කාර්යයන් ධාවනය කළ හැකි අතර, Kubernetes API සමඟ අන්තර් ක්‍රියා කරන විට එය Kubernetes පොකුර තුළ ස්ථානගත කිරීම සත්‍යාපනය පිළිබඳ ගැටළුව විසඳයි.

අපි එය දෙවන භාවිත අවස්ථාවක් ලෙස ඉස්මතු කරමු - පරීක්ෂණ ලූපයක Kubernetes පොකුරක් මත CI/CD ක්‍රියාවලියක කොටසක් ලෙස Spark tasks ධාවනය කිරීම.

Apache Livy ගැන ටිකක් - එය වෙබ් අතුරු මුහුණතක් සහ RESTful API සපයන HTTP සේවාදායකයක් ලෙස ක්‍රියා කරන අතර අවශ්‍ය පරාමිති පසුකර දුරස්ථව spark-submit දියත් කිරීමට ඔබට ඉඩ සලසයි. සම්ප්‍රදායිකව එය HDP බෙදාහැරීමක කොටසක් ලෙස නැව්ගත කර ඇත, නමුත් OKD හෝ වෙනත් ඕනෑම Kubernetes ස්ථාපනයකට යෙදවිය හැක, සුදුසු මැනිෆෙස්ටය සහ මෙවැනි ඩොකර් රූප කට්ටලයක් භාවිතා කර - github.com/ttauveron/k8s-big-data-experiments/tree/master/livy-spark-2.3. අපගේ නඩුව සඳහා, පහත Dockerfile වෙතින් Spark අනුවාදය 2.4.5 ඇතුළුව සමාන Docker රූපයක් ගොඩනගා ඇත:

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"]

ජනනය කරන ලද රූපය අභ්‍යන්තර OKD ගබඩාව වැනි ඔබගේ පවතින ඩොකර් ගබඩාවට ගොඩනගා උඩුගත කළ හැක. එය යෙදවීමට, පහත මැනිෆෙස්ට් භාවිතා කරන්න ({registry-url} - ඩොකර් රූප රෙජිස්ට්‍රියේ URL, {image-name} - Docker image name, {tag} - Docker image tag, {livy-url} - අවශ්‍ය URL සේවාදායකය වෙත ප්‍රවේශ විය හැකි Livy; Red Hat OpenShift Kubernetes බෙදාහැරීම ලෙස භාවිතා කරන්නේ නම්, "මාර්ගය" මැනිෆෙස්ටය භාවිතා වේ, එසේ නොමැතිනම් 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

එය යෙදීමෙන් සහ පොඩ් එක සාර්ථකව දියත් කළ පසු, Livy චිත්‍රක අතුරුමුහුණත සබැඳියෙන් ලබා ගත හැක: http://{livy-url}/ui. Livy සමඟින්, අපට අපගේ Spark කාර්යය REST ඉල්ලීමක් භාවිතයෙන් ප්‍රකාශනය කළ හැක, උදාහරණයක් ලෙස, Postman. ඉල්ලීම් සහිත එකතුවක උදාහරණයක් පහත දැක්වේ (දියත් කරන ලද කාර්යයේ ක්‍රියාකාරිත්වය සඳහා අවශ්‍ය විචල්‍යයන් සහිත වින්‍යාස තර්ක “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": {}
}

එකතුවෙන් පළමු ඉල්ලීම ක්‍රියාත්මක කරමු, OKD අතුරුමුහුණත වෙත ගොස් කාර්යය සාර්ථකව දියත් කර ඇත්දැයි පරීක්ෂා කරන්න - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods. ඒ සමඟම, Livy අතුරුමුහුණතෙහි (http://{livy-url}/ui) සැසියක් දිස්වනු ඇත, එය තුළ, Livy API හෝ චිත්‍රක අතුරුමුහුණත භාවිතයෙන්, ඔබට කාර්යයේ ප්‍රගතිය නිරීක්ෂණය කර සැසිය අධ්‍යයනය කළ හැකිය. සටහන්.

දැන් බලමු Livy වැඩ කරන හැටි. මෙය සිදු කිරීම සඳහා, Livy සේවාදායකය සමඟ පොඩ් එක තුළ ඇති Livy බහාලුම් ලොග් පරීක්ෂා කරමු - https://{OKD-WEBUI-URL}/console/project/{project}/browse/pods/{livy-pod-name }?tab=logs. ඒවායින් අපට පෙනෙන්නේ “livy” නම් කන්ටේනරයක Livy REST API ඇමතීමේදී, අප ඉහත භාවිතා කළ ආකාරයටම, spark-submit එකක් ක්‍රියාත්මක වන බව (මෙහි {livy-pod-name} යනු සාදන ලද පොඩ් එකේ නමයි. Livy සේවාදායකය සමඟ). Livy සේවාදායකයක් භාවිතයෙන් Spark ක්‍රියාත්මක කළ හැකි දුරස්ථව සත්කාරකත්වය සපයන කාර්යයන් ක්‍රියාත්මක කිරීමට ඔබට ඉඩ සලසන දෙවන විමසුමක් ද එකතුව හඳුන්වා දෙයි.

තෙවන භාවිත අවස්ථාව - Spark Operator

දැන් කාර්යය පරීක්ෂා කර ඇති අතර, එය නිතිපතා ක්රියාත්මක කිරීමේ ප්රශ්නය පැන නගී. Kubernetes පොකුරක් තුළ නිතිපතා කාර්යයන් ක්‍රියාත්මක කිරීමට දේශීය ක්‍රමය CronJob ආයතනය වන අතර ඔබට එය භාවිතා කළ හැකිය, නමුත් මේ මොහොතේ Kubernetes හි යෙදුම් කළමනාකරණය කිරීම සඳහා ක්‍රියාකරුවන් භාවිතා කිරීම ඉතා ජනප්‍රිය වන අතර Spark සඳහා තරමක් පරිණත ක්‍රියාකරුවෙකු සිටී, එයද වේ. ව්‍යවසාය මට්ටමේ විසඳුම් වල භාවිතා වේ (උදාහරණයක් ලෙස, Lightbend FastData Platform). අපි එය භාවිතා කිරීම නිර්දේශ කරමු - Spark හි වත්මන් ස්ථාවර අනුවාදය (2.4.5) Kubernetes හි Spark කාර්යයන් ධාවනය කිරීම සඳහා තරමක් සීමිත වින්‍යාස විකල්ප ඇත, ඊළඟ ප්‍රධාන අනුවාදය (3.0.0) Kubernetes සඳහා පූර්ණ සහාය ප්‍රකාශ කරයි, නමුත් එය නිකුත් කරන දිනය තවමත් නොදනී. . Spark Operator වැදගත් වින්‍යාස විකල්ප (උදාහරණයක් ලෙස, Spark Pods වෙත Hadoop ප්‍රවේශ වින්‍යාසය සහිත ConfigMap සවිකිරීම) සහ නිතිපතා නියමිත කාර්යයක් ක්‍රියාත්මක කිරීමේ හැකියාව එක් කිරීමෙන් මෙම අඩුපාඩුව සඳහා වන්දි ලබා දේ.

අපි එය තුන්වන භාවිත අවස්ථාවක් ලෙස ඉස්මතු කරමු - නිෂ්පාදන ලූපයක Kubernetes පොකුරක් මත Spark කාර්යයන් නිතිපතා ධාවනය කරයි.

Spark Operator විවෘත මූලාශ්‍රයක් වන අතර Google Cloud Platform තුළ සංවර්ධනය කර ඇත - github.com/GoogleCloudPlatform/spark-on-k8s-operator. එහි ස්ථාපනය ක්රම තුනකින් සිදු කළ හැකිය:

1. Lightbend FastData Platform/Cloudflow ස්ථාපනයෙහි කොටසක් ලෙස;
2. හෙල්ම් භාවිතා කිරීම:

   helm repo add incubator http://storage.googleapis.com/kubernetes-charts-incubator
   helm install incubator/sparkoperator --namespace spark-operator
   	

3. නිල ගබඩාවෙන් මැනිෆෙස්ට් භාවිතා කිරීම (https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/tree/master/manifest). පහත සඳහන් කරුණු සඳහන් කිරීම වටී - Cloudflow හි API අනුවාදය v1beta1 සමඟ ක්‍රියාකරුවෙකු ඇතුළත් වේ. මෙම ආකාරයේ ස්ථාපනය භාවිතා කරන්නේ නම්, Spark යෙදුම් මැනිෆෙස්ට් විස්තරය Git හි ඇති උදාහරණ ටැග් මත සුදුසු API අනුවාදය සමඟ පදනම් විය යුතුය, උදාහරණයක් ලෙස, "v1beta1-0.9.0-2.4.0". "අනුවාද" ශබ්ද කෝෂයේ ක්‍රියාකරුට ඇතුළත් කර ඇති CRD හි විස්තරයෙන් ක්‍රියාකරුගේ අනුවාදය සොයාගත හැකිය:

   oc get crd sparkapplications.sparkoperator.k8s.io -o yaml
   	

ක්‍රියාකරු නිවැරදිව ස්ථාපනය කර ඇත්නම්, ස්පාර්ක් ක්‍රියාකරු සමඟ සක්‍රීය පොඩ් එකක් අදාළ ව්‍යාපෘතියේ දිස්වනු ඇත (උදාහරණයක් ලෙස, Cloudflow ස්ථාපනය සඳහා Cloudflow අවකාශයේ cloudflow-fdp-sparkoperator) සහ "sparkapplications" නම් අනුරූප Kubernetes සම්පත් වර්ගය දිස්වනු ඇත. . ඔබට පහත විධානය සමඟින් පවතින Spark යෙදුම් ගවේෂණය කළ හැක:

oc get sparkapplications -n {project}

Spark Operator භාවිතයෙන් කාර්යයන් ක්‍රියාත්මක කිරීමට ඔබට දේවල් 3ක් කළ යුතුය:

• අවශ්‍ය සියලුම පුස්තකාල, මෙන්ම වින්‍යාස කිරීම සහ ක්‍රියාත්මක කළ හැකි ගොනු ඇතුළත් ඩොකර් රූපයක් සාදන්න. ඉලක්ක පින්තූරයේ, මෙය CI/CD අදියරේදී සාදන ලද සහ පරීක්ෂණ පොකුරක් මත පරීක්ෂා කරන ලද රූපයකි;
• Kubernetes පොකුරෙන් ප්‍රවේශ විය හැකි රෙජිස්ට්‍රියකට Docker රූපයක් ප්‍රකාශනය කරන්න;
• "SparkApplication" වර්ගය සහ දියත් කිරීමට නියමිත කාර්යය පිළිබඳ විස්තරයක් සහිත මැනිෆෙස්ට් එකක් ජනනය කරන්න. උදාහරණ ප්‍රකාශන නිල ගබඩාවේ ඇත (උදා. github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/v1beta1-0.9.0-2.4.0/examples/spark-pi.yaml) ප්‍රතිපත්ති ප්‍රකාශනයේ සඳහන් කළ යුතු වැදගත් කරුණු තිබේ:
  1. "apiVersion" ශබ්දකෝෂය ක්‍රියාකරු අනුවාදයට අනුරූප වන API අනුවාදය දැක්විය යුතුය;
  2. "metadata.namespace" ශබ්දකෝෂය යෙදුම දියත් කරන නාම අවකාශය සඳහන් කළ යුතුය;
  3. "spec.image" ශබ්ද කෝෂයේ ප්‍රවේශ විය හැකි රෙජිස්ට්‍රියක සාදන ලද ඩොකර් රූපයේ ලිපිනය අඩංගු විය යුතුය;
  4. "spec.mainClass" ශබ්ද කෝෂයේ ක්‍රියාවලිය ආරම්භ වන විට ධාවනය කළ යුතු Spark කාර්ය පන්තිය අඩංගු විය යුතුය;
  5. "spec.mainApplicationFile" ශබ්ද කෝෂයේ ක්‍රියාත්මක කළ හැකි jar ගොනුව වෙත යන මාර්ගය අඩංගු විය යුතුය;
  6. "spec.sparkVersion" ශබ්දකෝෂය Spark භාවිතා කරන අනුවාදය සඳහන් කළ යුතුය;
  7. "spec.driver.serviceAccount" ශබ්දකෝෂය යෙදුම ක්‍රියාත්මක කිරීමට භාවිතා කරන අනුරූප Kubernetes නාම අවකාශය තුළ සේවා ගිණුම සඳහන් කළ යුතුය;
  8. "spec.executor" ශබ්දකෝෂය යෙදුමට වෙන් කර ඇති සම්පත් ගණන දැක්විය යුතුය;
  9. "spec.volumeMounts" ශබ්දකෝෂය දේශීය Spark කාර්ය ගොනු නිර්මාණය කරන දේශීය නාමාවලිය සඳහන් කළ යුතුය.

මැනිෆෙස්ටයක් ජනනය කිරීමේ උදාහරණයක් (මෙහි {spark-service-account} යනු Spark කාර්යයන් ධාවනය කිරීම සඳහා Kubernetes පොකුර තුළ ඇති සේවා ගිණුමකි):

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"

මෙම මැනිෆෙස්ට් එක සේවා ගිණුමක් සඳහන් කරයි, මැනිෆෙස්ටය ප්‍රකාශනය කිරීමට පෙර, ඔබ විසින් ස්පාර්ක් යෙදුමට Kubernetes API සමඟ අන්තර් ක්‍රියා කිරීමට (අවශ්‍ය නම්) අවශ්‍ය ප්‍රවේශ හිමිකම් සපයන අවශ්‍ය භූමිකාව බැඳීම් නිර්මාණය කළ යුතුය. අපගේ නඩුවේදී, Pods නිර්මාණය කිරීමට යෙදුමට අයිතිවාසිකම් අවශ්ය වේ. අවශ්‍ය භූමිකාව බැඳීම නිර්මාණය කරමු:

oc adm policy add-role-to-user edit system:serviceaccount:{project}:{spark-service-account} -n {project}

මෙම මැනිෆෙස්ට් පිරිවිතරයේ "hadoopConfigMap" පරාමිතියක් ඇතුළත් විය හැකි බව සඳහන් කිරීම වටී, එමඟින් ඔබට ඩොකර් රූපයේ අනුරූප ගොනුව තැබීමෙන් තොරව Hadoop වින්‍යාසය සමඟ වින්‍යාස සිතියමක් නියම කිරීමට ඉඩ සලසයි. එය නිතිපතා ක්‍රියාත්මක වන කාර්යයන් සඳහා ද සුදුසු වේ - “කාලසටහන” පරාමිතිය භාවිතා කරමින්, දී ඇති කාර්යයක් ක්‍රියාත්මක කිරීම සඳහා කාලසටහනක් නියම කළ හැකිය.

ඊට පසු, අපි අපගේ මැනිෆෙස්ටය spark-pi.yaml ගොනුවට සුරකින අතර එය අපගේ Kubernetes පොකුරට යොදන්නෙමු:

oc apply -f spark-pi.yaml

මෙය "sparkapplications" වර්ගයේ වස්තුවක් සාදනු ඇත:

oc get sparkapplications -n {project}
> NAME       AGE
> spark-pi   22h

මෙම අවස්ථාවේදී, යෙදුමක් සහිත පොඩ් එකක් සාදනු ඇත, එහි තත්ත්වය නිර්මාණය කරන ලද "sparkapplications" තුළ පෙන්වනු ඇත. පහත දැක්වෙන විධානය සමඟ ඔබට එය නැරඹිය හැකිය:

oc get sparkapplications spark-pi -o yaml -n {project}

කාර්යය අවසන් වූ පසු, POD "සම්පූර්ණ" තත්ත්වයට ගමන් කරනු ඇත, එය "sparkapplications" තුළද යාවත්කාලීන වේ. යෙදුම් ලොග් බ්‍රවුසරයේ හෝ පහත විධානය භාවිතයෙන් නැරඹිය හැක (මෙහි {sparkapplications-pod-name} යනු ධාවන කාර්යයේ පොඩ් එකේ නමයි):

oc logs {sparkapplications-pod-name} -n {project}

විශේෂිත sparkctl උපයෝගීතාව භාවිතයෙන් ස්පාර්ක් කාර්යයන් ද කළමනාකරණය කළ හැක. එය ස්ථාපනය කිරීමට, එහි මූල කේතය සමඟ ගබඩාව ක්ලෝන කරන්න, Go ස්ථාපනය කර මෙම උපයෝගීතාව ගොඩනඟන්න:

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

ධාවනය වන Spark කාර්යයන් ලැයිස්තුව පරීක්ෂා කරමු:

sparkctl list -n {project}

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"

sparkctl භාවිතයෙන් විස්තර කර ඇති කාර්යය ධාවනය කරමු:

sparkctl create spark-app.yaml -n {project}

ධාවනය වන Spark කාර්යයන් ලැයිස්තුව පරීක්ෂා කරමු:

sparkctl list -n {project}

දියත් කරන ලද Spark කාර්යයක සිදුවීම් ලැයිස්තුව පරීක්ෂා කරමු:

sparkctl event spark-pi -n {project} -f

ධාවනය වන Spark කාර්යයේ තත්ත්වය පරීක්ෂා කරමු:

sparkctl status spark-pi -n {project}

අවසාන වශයෙන්, මම Kubernetes හි Spark (2.4.5) හි වත්මන් ස්ථාවර අනුවාදය භාවිතා කිරීමේ සොයාගත් අවාසි සලකා බැලීමට කැමැත්තෙමි:

1. පළමු සහ, සමහර විට, ප්රධාන අවාසිය නම් Data Locality නොමැතිකමයි. YARN හි සියලු අඩුපාඩු තිබියදීත්, එය භාවිතා කිරීමේ වාසි ද ඇත, උදාහරණයක් ලෙස, දත්ත වෙත කේතය ලබා දීමේ මූලධර්මය (කේතයට දත්ත වෙනුවට). එයට ස්තූතියි, ගණනය කිරීම්වලට සම්බන්ධ දත්ත පිහිටා ඇති නෝඩ් මත ස්පාර්ක් කාර්යයන් ක්‍රියාත්මක කරන ලද අතර ජාලය හරහා දත්ත ලබා දීමට ගතවන කාලය සැලකිය යුතු ලෙස අඩු විය. Kubernetes භාවිතා කරන විට, අපි ජාලය හරහා කාර්යයකට සම්බන්ධ දත්ත ගෙනයාමේ අවශ්‍යතාවයට මුහුණ දී සිටිමු. ඒවා ප්‍රමාණවත් තරම් විශාල නම්, කාර්යය ක්‍රියාත්මක කිරීමේ කාලය සැලකිය යුතු ලෙස වැඩි විය හැකි අතර, ඒවායේ තාවකාලික ගබඩා කිරීම සඳහා ස්පාර්ක් කාර්ය අවස්ථා සඳහා වෙන් කරන ලද තැටි ඉඩ ප්‍රමාණය තරමක් විශාල ප්‍රමාණයක් අවශ්‍ය වේ. Kubernetes (උදාහරණයක් ලෙස Alluxio) හි දත්ත ප්‍රදේශය සහතික කරන විශේෂිත මෘදුකාංග භාවිතයෙන් මෙම අවාසිය අවම කර ගත හැක, නමුත් මෙයින් අදහස් කරන්නේ Kubernetes පොකුරේ නෝඩ් වල දත්තවල සම්පූර්ණ පිටපතක් ගබඩා කිරීමේ අවශ්‍යතාවයයි.
2. දෙවන වැදගත් අවාසිය නම් ආරක්ෂාවයි. පෙරනිමියෙන්, Spark කර්තව්‍යයන් ක්‍රියාත්මක කිරීම සම්බන්ධ ආරක්‍ෂාවට අදාළ විශේෂාංග අක්‍රිය කර ඇත, Kerberos භාවිතය නිල ලේඛනවල ආවරණය නොවේ (අතිරේක වැඩ අවශ්‍ය වන අනුරූප විකල්ප 3.0.0 අනුවාදයෙන් හඳුන්වා දී ඇතත්), සහ ආරක්ෂක ලියකියවිලි Spark භාවිතා කරමින් (https://spark.apache.org/docs/2.4.5/security.html) YARN, Mesos සහ Standalone Cluster පමණක් ප්‍රධාන ගබඩා ලෙස දිස්වේ. ඒ අතරම, Spark කාර්යයන් දියත් කරන පරිශීලකයා සෘජුවම සඳහන් කළ නොහැක - අපි එය ක්‍රියා කරන සේවා ගිණුම පමණක් සඳහන් කරන අතර, පරිශීලකයා වින්‍යාසගත ආරක්ෂක ප්‍රතිපත්ති මත පදනම්ව තෝරා ගනු ලැබේ. මේ සම්බන්ධයෙන්, එක්කෝ ඵලදායි පරිසරයක ආරක්ෂිත නොවන මූල පරිශීලකයා හෝ දත්ත සඳහා ප්‍රවේශ අයිතිවාසිකම් බෙදා හැරීමේදී අපහසු වන අහඹු UID සහිත පරිශීලකයෙකු භාවිතා කරයි (මෙය PodSecurityPolicies නිර්මාණය කර ඒවා සම්බන්ධ කිරීමෙන් විසඳා ගත හැක. අනුරූප සේවා ගිණුම්). දැනට, විසඳුම වන්නේ එක්කෝ අවශ්‍ය සියලුම ලිපිගොනු සෘජුවම ඩොකර් රූපයට තැබීම, නැතහොත් ඔබේ සංවිධානයේ සම්මත කර ඇති රහස් ගබඩා කිරීම සහ ලබා ගැනීම සඳහා යාන්ත්‍රණය භාවිතා කිරීම සඳහා ස්පාර්ක් දියත් කිරීමේ ස්ක්‍රිප්ට් වෙනස් කිරීමයි.
3. Kubernetes භාවිතයෙන් Spark jobs ධාවනය කිරීම නිල වශයෙන් තවමත් පර්යේෂණාත්මක මාදිලියේ පවතින අතර අනාගතයේදී භාවිතා කරන ලද පුරාවස්තුවල (වින්‍යාස ගොනු, Docker පාදක රූප සහ දියත් ස්ක්‍රිප්ට්) සැලකිය යුතු වෙනස්කම් ඇති විය හැක. ඇත්ත වශයෙන්ම, ද්රව්යය සකස් කිරීමේදී, 2.3.0 සහ 2.4.5 අනුවාද පරීක්ෂා කරන ලදී, හැසිරීම සැලකිය යුතු ලෙස වෙනස් විය.

යාවත්කාලීන කිරීම් සඳහා රැඳී සිටිමු - Spark (3.0.0) හි නව අනුවාදයක් මෑතකදී නිකුත් කරන ලද අතර, එය Kubernetes හි Spark හි කාර්යයට සැලකිය යුතු වෙනස්කම් ගෙන ආ නමුත් මෙම සම්පත් කළමනාකරු සඳහා සහාය වීමේ පර්යේෂණාත්මක තත්ත්වය රඳවා ගත්තේය. සමහර විට මීළඟ යාවත්කාලීන කිරීම් මඟින් ඔබේ පද්ධතියේ ආරක්ෂාව ගැන බියෙන් තොරව සහ ක්‍රියාකාරී සංරචක ස්වාධීනව වෙනස් කිරීමේ අවශ්‍යතාවයකින් තොරව YARN අත්හැරීම සහ Kubernetes හි Spark කාර්යයන් ධාවනය කිරීම සම්පූර්ණයෙන්ම නිර්දේශ කිරීමට හැකි වනු ඇත.

ෆින්.

මූලාශ්රය: www.habr.com