Kubernetes ගබඩාව සඳහා වෙළුම් ප්ලගීන: Flexvolume සිට CSI දක්වා

නැවතත් Kubernetes තවමත් v1.0.0 වන විට, වෙළුම් ප්ලගීන තිබුණි. ස්ථීර (ස්ථිර) බහාලුම් දත්ත ගබඩා කිරීම සඳහා Kubernetes වෙත පද්ධති සම්බන්ධ කිරීමට ඒවා අවශ්‍ය විය. ඔවුන්ගේ සංඛ්යාව කුඩා වූ අතර, පළමු ඒවා අතර GCE PD, Ceph, AWS EBS සහ වෙනත් අය වැනි ගබඩා සපයන්නන් විය.

ප්ලගීන කුබර්නෙටස් සමඟ බෙදා හරින ලදී, ඒ නිසා ඔවුන්ට ඔවුන්ගේ නම ලැබුණේ - ගස තුළ ය. කෙසේ වෙතත්, බොහෝ දෙනෙකුට, දැනට පවතින එවැනි ප්ලගීන කට්ටලය ප්‍රමාණවත් නොවන බව පෙනී ගියේය. ශිල්පීන් පැච් භාවිතයෙන් Kubernetes හරයට සරල ප්ලගීන එකතු කළ අතර, පසුව ඔවුන් තමන්ගේම Kubernetes එකලස් කර ඔවුන්ගේ සේවාදායකයන් මත ස්ථාපනය කළහ. නමුත් කාලයාගේ ඇවෑමෙන්, Kubernetes සංවර්ධකයින් එය තේරුම් ගත්හ මාළු ගැටලුව විසඳිය නොහැක. මිනිසුන්ට අවශ්‍යයි බිලී පිත්ත. සහ Kubernetes v1.2.0 නිකුත් කිරීමේදී එය දර්ශනය විය...

Flexvolume ප්ලගිනය: අවම මසුන් ඇල්ලීම

Kubernetes සංවර්ධකයින් විසින් FlexVolume ප්ලගිනය නිර්මාණය කරන ලද අතර එය තෙවන පාර්ශවීය සංවර්ධකයින් විසින් ක්‍රියාත්මක කරන ලද Flexvolume ධාවක සමඟ වැඩ කිරීමේ විචල්‍යයන් සහ ක්‍රමවල තාර්කික රාමුවකි.

අපි නැවතී FlexVolume ධාවකය යනු කුමක්දැයි සමීපව බලමු. මෙය නිශ්චිතය ක්රියාත්මක කළ හැකි ගොනුව (ද්විමය ගොනුව, පයිතන් ස්ක්‍රිප්ට්, බැෂ් ස්ක්‍රිප්ට්, ආදිය), එය ක්‍රියාත්මක කළ විට, විධාන රේඛා තර්ක ආදානය ලෙස ගෙන JSON ආකෘතියෙන් පෙර දන්නා ක්ෂේත්‍ර සහිත පණිවිඩයක් ලබා දෙයි. සම්මුතිය අනුව, පළමු විධාන රේඛා තර්කය සෑම විටම ක්රමයක් වන අතර ඉතිරි තර්ක එහි පරාමිතීන් වේ.

OpenShift හි CIFS කොටස් සඳහා සම්බන්ධතා රූප සටහන. Flexvolume Driver - හරි මැද

අවම ක්රම කට්ටලය මේ වගේ:

flexvolume_driver mount # отвечает за присоединение тома к pod'у
# Формат возвращаемого сообщения:
{
  "status": "Success"/"Failure"/"Not supported",
  "message": "По какой причине был возвращен именно такой статус",
}

flexvolume_driver unmount # отвечает за отсоединение тома от pod'а
# Формат возвращаемого сообщения:
{
  "status": "Success"/"Failure"/"Not supported",
  "message": "По какой причине был возвращен именно такой статус",
}

flexvolume_driver init # отвечает за инициализацию плагина
# Формат возвращаемого сообщения:
{
  "status": "Success"/"Failure"/"Not supported",
  "message": "По какой причине был возвращен именно такой статус",
  // Определяет, использует ли драйвер методы attach/deatach
  "capabilities":{"attach": True/False}
}

ක්රම භාවිතා කිරීම attach и detach රියදුරු ඇමතීමේදී අනාගතයේදී kubelet ක්‍රියා කරන අවස්ථාව නිර්වචනය කරනු ඇත. විශේෂ ක්රම ද තිබේ expandvolume и expandfs, පරිමාව ගතිකව ප්‍රමාණය වෙනස් කිරීම සඳහා වගකිව යුතු වේ.

ක්රමය එකතු කරන වෙනස්කම් සඳහා උදාහරණයක් ලෙස expandvolume, සහ එය සමඟ තත්‍ය කාලීන වෙළුම් ප්‍රමාණය වෙනස් කිරීමේ හැකියාව, ඔබට ඔබව හුරු කර ගත හැකිය අපේ ඇදීමේ ඉල්ලීම Rook Ceph Operator හි.

NFS සමඟ වැඩ කිරීම සඳහා Flexvolume ධාවකය ක්‍රියාත්මක කිරීම පිළිබඳ උදාහරණයක් මෙන්න:

usage() {
    err "Invalid usage. Usage: "
    err "t$0 init"
    err "t$0 mount <mount dir> <json params>"
    err "t$0 unmount <mount dir>"
    exit 1
}

err() {
    echo -ne $* 1>&2
}

log() {
    echo -ne $* >&1
}

ismounted() {
    MOUNT=`findmnt -n ${MNTPATH} 2>/dev/null | cut -d' ' -f1`
    if [ "${MOUNT}" == "${MNTPATH}" ]; then
        echo "1"
    else
        echo "0"
    fi
}

domount() {
    MNTPATH=$1

    NFS_SERVER=$(echo $2 | jq -r '.server')
    SHARE=$(echo $2 | jq -r '.share')

    if [ $(ismounted) -eq 1 ] ; then
        log '{"status": "Success"}'
        exit 0
    fi

    mkdir -p ${MNTPATH} &> /dev/null

    mount -t nfs ${NFS_SERVER}:/${SHARE} ${MNTPATH} &> /dev/null
    if [ $? -ne 0 ]; then
        err "{ "status": "Failure", "message": "Failed to mount ${NFS_SERVER}:${SHARE} at ${MNTPATH}"}"
        exit 1
    fi
    log '{"status": "Success"}'
    exit 0
}

unmount() {
    MNTPATH=$1
    if [ $(ismounted) -eq 0 ] ; then
        log '{"status": "Success"}'
        exit 0
    fi

    umount ${MNTPATH} &> /dev/null
    if [ $? -ne 0 ]; then
        err "{ "status": "Failed", "message": "Failed to unmount volume at ${MNTPATH}"}"
        exit 1
    fi

    log '{"status": "Success"}'
    exit 0
}

op=$1

if [ "$op" = "init" ]; then
    log '{"status": "Success", "capabilities": {"attach": false}}'
    exit 0
fi

if [ $# -lt 2 ]; then
    usage
fi

shift

case "$op" in
    mount)
        domount $*
        ;;
    unmount)
        unmount $*
        ;;
    *)
        log '{"status": "Not supported"}'
        exit 0
esac

exit 1

එබැවින්, සැබෑ ක්රියාත්මක කළ හැකි ගොනුව සකස් කිරීමෙන් පසුව, ඔබට අවශ්ය වේ රියදුරු Kubernetes පොකුරට උඩුගත කරන්න. ධාවකය එක් එක් පොකුරු නෝඩය මත කලින් තීරණය කළ මාර්ගයට අනුව පිහිටා තිබිය යුතුය. පෙරනිමියෙන් එය තෝරාගෙන ඇත:

/usr/libexec/kubernetes/kubelet-plugins/volume/exec/имя_поставщика_хранилища~имя_драйвера/

... නමුත් විවිධ Kubernetes බෙදාහැරීම් භාවිතා කරන විට (OpenShift, Rancher...) මාර්ගය වෙනස් විය හැක.

Flexvolume ගැටළු: ධීවර පොල්ලක් නිවැරදිව වාත්තු කරන්නේ කෙසේද?

Flexvolume ධාවකය පොකුරු නෝඩ් වෙත උඩුගත කිරීම සුළුපටු නොවන කාර්යයක් විය. ක්‍රියාන්විතය එක් වරක් අතින් සිදු කිරීමෙන් පසු, පොකුරේ නව නෝඩ් දිස්වන තත්වයකට මුහුණ දීම පහසුය: නව නෝඩයක් එකතු කිරීම, ස්වයංක්‍රීය තිරස් පරිමාණය හෝ - නරක දෙය - අක්‍රියතාවයක් හේතුවෙන් නෝඩයක් ප්‍රතිස්ථාපනය කිරීම. මෙම අවස්ථාවේදී, මෙම නෝඩ් වල ගබඩාව සමඟ වැඩ කළ යුතුය නොහැකි ය, ඔබ තවමත් Flexvolume ධාවකය හස්තීයව ඒවාට එකතු කරන තුරු.

මෙම ගැටලුවට විසඳුම Kubernetes ප්රාථමිකයන්ගෙන් එකක් විය - DaemonSet. පොකුරේ නව නෝඩයක් දිස්වන විට, එහි ස්වයංක්‍රීයව අපගේ DaemonSet වෙතින් පොඩ් එකක් අඩංගු වන අතර, Flexvolume ධාවක සොයා ගැනීම සඳහා මාර්ගය දිගේ දේශීය පරිමාවක් අමුණා ඇත. සාර්ථක නිර්මාණයකින් පසු, ධාවකයට අවශ්‍ය ලිපිගොනු තැටියට පිටපත් කරයි.

Flexvolume ප්ලගිනයක් තැබීම සඳහා එවැනි DaemonSet එකක උදාහරණයක් මෙන්න:

apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: flex-set
spec:
  template:
    metadata:
      name: flex-deploy
      labels:
        app: flex-deploy
    spec:
      containers:
        - image: <deployment_image>
          name: flex-deploy
          securityContext:
              privileged: true
          volumeMounts:
            - mountPath: /flexmnt
              name: flexvolume-mount
      volumes:
        - name: flexvolume-mount
          hostPath:
            path: <host_driver_directory>

සහ Flexvolume ධාවකය තැබීම සඳහා Bash ස්ක්‍රිප්ට් එකක උදාහරණයක්:

#!/bin/sh

set -o errexit
set -o pipefail

VENDOR=k8s.io
DRIVER=nfs

driver_dir=$VENDOR${VENDOR:+"~"}${DRIVER}
if [ ! -d "/flexmnt/$driver_dir" ]; then
  mkdir "/flexmnt/$driver_dir"
fi

cp "/$DRIVER" "/flexmnt/$driver_dir/.$DRIVER"
mv -f "/flexmnt/$driver_dir/.$DRIVER" "/flexmnt/$driver_dir/$DRIVER"

while : ; do
  sleep 3600
done

පිටපත් කිරීමේ මෙහෙයුම බව අමතක නොකිරීම වැදගත්ය පරමාණුක නොවේ. පද්ධතිය බිඳ වැටීමට තුඩු දෙමින්, එහි ප්‍රතිපාදන ක්‍රියාවලිය සම්පූර්ණ වීමට පෙර kubelet ධාවකය භාවිතා කිරීම ආරම්භ කිරීමට ඉහළ සම්භාවිතාවක් ඇත. නිවැරදි ප්‍රවේශය නම් පළමුව ධාවක ගොනු වෙනත් නමකින් පිටපත් කර පසුව පරමාණුක නැවත නම් කිරීමේ මෙහෙයුමක් භාවිතා කිරීමයි.

Rook ක්රියාකරු තුළ Ceph සමඟ වැඩ කිරීමේ රූප සටහන: රූප සටහනේ Flexvolume ධාවකය Rook නියෝජිතයා තුළ පිහිටා ඇත

Flexvolume ධාවක භාවිතා කරන විට ඇති ඊළඟ ගැටළුව වන්නේ පොකුරු නෝඩයක බොහෝ ගබඩා කිරීම සඳහා ය මේ සඳහා අවශ්ය මෘදුකාංග ස්ථාපනය කළ යුතුය (උදාහරණයක් ලෙස, Ceph සඳහා ceph-common පැකේජය). මුලදී, Flexvolume ප්ලගිනය එවැනි සංකීර්ණ පද්ධති ක්රියාත්මක කිරීම සඳහා නිර්මාණය කර නැත.

මෙම ගැටළුව සඳහා මුල් විසඳුම Rook ක්රියාකරුගේ Flexvolume ධාවකය ක්රියාත්මක කිරීමේදී දැකිය හැකිය:

ධාවකයම RPC සේවාලාභියෙකු ලෙස නිර්මාණය කර ඇත. සන්නිවේදනය සඳහා IPC සොකට් එක රියදුරු ලෙසම එකම නාමාවලියෙහි පිහිටා ඇත. ධාවක ගොනු පිටපත් කිරීම සඳහා, ධාවක සමඟ නාමාවලිය පරිමාවක් ලෙස සම්බන්ධ කරන DaemonSet භාවිතා කිරීම හොඳ බව අපට මතකයි. අවශ්‍ය රූක් ධාවක ගොනු පිටපත් කිරීමෙන් පසු, මෙම පොඩ් එක මිය යන්නේ නැත, නමුත් සම්පූර්ණ RPC සේවාදායකයක් ලෙස අමුණා ඇති පරිමාව හරහා IPC සොකට් එකට සම්බන්ධ වේ. ceph-common පැකේජය දැනටමත් පොඩ් කන්ටේනරය තුළ ස්ථාපනය කර ඇත. IPC සොකට් එක මගින් kubelet හරියටම එකම node එකක් මත පිහිටා ඇති Pod එක සමඟ සන්නිවේදනය කරන බව සහතික කරයි. දක්ෂ සෑම දෙයක්ම සරලයි! ..

ආයුබෝවන්, අපගේ ආදරණීය... ගස තුළ ප්ලගීන!

Kubernetes සංවර්ධකයින් විසින් හරය තුළ ගබඩා කිරීම සඳහා ප්ලගීන ගණන විස්සක් බව සොයා ගන්නා ලදී. ඒවගේම ඒ සෑම එකකම වෙනසක්, එක් ආකාරයකින් හෝ වෙනත් ආකාරයකින්, සම්පූර්ණ Kubernetes මුදා හැරීමේ චක්‍රය හරහා ගමන් කරයි.

ගබඩා ප්ලගිනයේ නව අනුවාදය භාවිතා කිරීමට එය හැරෙනවා, ඔබ සම්පූර්ණ පොකුර යාවත්කාලීන කළ යුතුය. මීට අමතරව, Kubernetes හි නව අනුවාදය ඔබ භාවිතා කරන Linux කර්නලය සමඟ හදිසියේම නොගැලපීම ගැන ඔබ පුදුමයට පත් විය හැකිය ... එබැවින් ඔබ ඔබේ කඳුළු පිස දමා, ඔබේ දත්මිටි කමින්, ඔබේ කළමනාකාරිත්වය සහ පරිශීලකයින් සමඟ සම්බන්ධීකරණය කරන්න. Linux kernel සහ Kubernetes cluster යාවත්කාලීන කරන්න. සේවා සැපයීමේදී ඇති විය හැකි අක්‍රීය කාලය සමඟ.

තත්වය හාස්‍යජනක දෙයකට වඩා වැඩියි, ඔබ සිතන්නේ නැද්ද? ප්‍රවේශය ක්‍රියාත්මක නොවන බව සමස්ත ප්‍රජාවටම පැහැදිලි විය. හිතාමතා තීරණයක් මගින්, Kubernetes සංවර්ධකයින් ගබඩා සමඟ වැඩ කිරීම සඳහා නව ප්ලගීන තවදුරටත් කර්නලය තුළට පිළි නොගන්නා බව නිවේදනය කරයි. මීට අමතරව, අප දැනටමත් දන්නා පරිදි, Flexvolume ප්ලගිනය ක්‍රියාත්මක කිරීමේදී අඩුපාඩු ගණනාවක් හඳුනාගෙන ඇත ...

Kubernetes හි වෙළුම් සඳහා නවතම එකතු කරන ලද ප්ලගිනය, CSI, ස්ථීර දත්ත ගබඩා කිරීමේ ගැටලුව එක් වරක් සහ සියල්ලටම වසා දැමීමට ඉල්ලා සිටියේය. එහි ඇල්ෆා අනුවාදය, වඩාත් සම්පුර්ණයෙන්ම හඳුන්වනු ලබන්නේ ගසෙන් පිටත CSI වෙළුම් ප්ලගීන ලෙස, නිකුතුවේදී නිවේදනය කරන ලදී. කුබර්නෙට්ස් 1.9.

බහාලුම් ගබඩා අතුරුමුහුණත, හෝ CSI 3000 කැරකෙන සැරයටිය!

පළමුවෙන්ම, CSI යනු වෙළුම් ප්ලගිනයක් පමණක් නොව සැබෑ එකක් බව සටහන් කිරීමට කැමැත්තෙමි සම්මත දත්ත ගබඩා සමඟ වැඩ කිරීම සඳහා අභිරුචි සංරචක නිර්මාණය කිරීම මත. Kubernetes සහ Mesos වැනි බහාලුම් වාද්‍ය වෘන්ද පද්ධති මෙම ප්‍රමිතියට අනුව ක්‍රියාත්මක කරන ලද සංරචක සමඟ ක්‍රියා කරන්නේ කෙසේදැයි “ඉගෙන” ගත යුතුව තිබුණි. දැන් මම දැනටමත් Kubernetes ඉගෙන ගෙන ඇත.

Kubernetes හි CSI ප්ලගිනයේ ව්‍යුහය කුමක්ද? CSI ප්ලගිනය විශේෂ ධාවක සමඟ ක්‍රියා කරයි (CSI ධාවකයන්) තෙවන පාර්ශවීය සංවර්ධකයින් විසින් ලියා ඇත. Kubernetes හි CSI ධාවකයක් අවම වශයෙන් කොටස් දෙකකින් (pods) සමන්විත විය යුතුය:

• පාලක - බාහිර ස්ථීර ගබඩා කළමනාකරණය කරයි. එය gRPC සේවාදායකයක් ලෙස ක්‍රියාත්මක වන අතර ඒ සඳහා ප්‍රාථමිකය භාවිතා වේ StatefulSet.
• node එකක් මතම ඊට අදාල - පොකුරු නෝඩ් වෙත ස්ථීර ගබඩාව සවි කිරීම සඳහා වගකිව යුතුය. එය gRPC සේවාදායකයක් ලෙසද ක්‍රියාත්මක වේ, නමුත් එය ප්‍රාථමික භාවිතා කරයි DaemonSet.

CSI ප්ලගිනය Kubernetes හි ක්‍රියා කරන ආකාරය

ඔබට CSI හි වැඩ පිළිබඳ වෙනත් විස්තර කිහිපයක් ගැන ඉගෙන ගත හැකිය, උදාහරණයක් ලෙස, "" ලිපියෙන්C.S.I අවබෝධ කර ගැනීම.», එහි පරිවර්තනය අපි වසරකට පෙර පළ කළෙමු.

එවැනි ක්රියාත්මක කිරීමේ වාසි

• Node එකක් සඳහා ධාවකයක් ලියාපදිංචි කිරීම වැනි මූලික දේවල් සඳහා, Kubernetes සංවර්ධකයින් විසින් බහාලුම් කට්ටලයක් ක්රියාත්මක කරන ලදී. Flexvolume ප්ලගිනය සඳහා කරන ලද පරිදි, ඔබට තවදුරටත් හැකියාවන් සහිත JSON ප්‍රතිචාරයක් ජනනය කිරීමට අවශ්‍ය නොවේ.
• ක්‍රියාත්මක කළ හැකි ගොනු නෝඩ් වලට "ලිස්සා යාම" වෙනුවට, අපි දැන් පොකුරට පොඩ්ස් උඩුගත කරමු. Kubernetes වෙතින් අප මුලින් බලාපොරොත්තු වන්නේ මෙයයි: සියලුම ක්‍රියාවලීන් Kubernetes primitives භාවිතයෙන් යොදවා ඇති බහාලුම් තුළ සිදු වේ.
• සංකීර්ණ ධාවක ක්‍රියාත්මක කිරීමට ඔබට තවදුරටත් RPC සේවාදායකයක් සහ RPC සේවාලාභියෙකු සංවර්ධනය කිරීමට අවශ්‍ය නොවේ. Kubernetes සංවර්ධකයින් විසින් සේවාදායකයා අප වෙනුවෙන් ක්‍රියාත්මක කරන ලදී.
• gRPC ප්‍රොටෝකෝලය හරහා වැඩ කිරීමට තර්ක සම්මත කිරීම විධාන රේඛා තර්ක හරහා ඒවා සම්මත කිරීමට වඩා පහසු, නම්‍යශීලී සහ විශ්වාසදායක වේ. ප්‍රමිතිගත gRPC ක්‍රමයක් එක් කිරීමෙන් CSI වෙත පරිමා භාවිත ප්‍රමිතික සඳහා සහය එක් කරන්නේ කෙසේදැයි තේරුම් ගැනීමට, ඔබට කියවිය හැක: අපේ ඇදීමේ ඉල්ලීම vsphere-csi ධාවකය සඳහා.
• kubelet විසින් ඉල්ලීම නිවැරදි පොඩ් වෙත යැව්වාද යන්න ව්‍යාකූල නොවන පරිදි IPC සොකට් හරහා සන්නිවේදනය සිදු වේ.

මෙම ලැයිස්තුව ඔබට යමක් මතක් කරනවාද? CSI හි ඇති වාසි වේ එම ගැටළු විසඳීම, Flexvolume ප්ලගිනය සංවර්ධනය කිරීමේදී සැලකිල්ලට නොගත් ඒවා.

සොයා ගැනීම්

දත්ත ගබඩා සමඟ අන්තර්ක්‍රියා කිරීම සඳහා අභිරුචි ප්ලගීන ක්‍රියාත්මක කිරීමේ ප්‍රමිතියක් ලෙස CSI ප්‍රජාව විසින් ඉතා උණුසුම් ලෙස පිළිගනු ලැබීය. එපමනක් නොව, ඔවුන්ගේ වාසි සහ බහුකාර්යතාව හේතුවෙන්, CSI ධාවකයන් Ceph හෝ AWS EBS වැනි ගබඩා පද්ධති සඳහා පවා නිර්මාණය කර ඇත, Kubernetes හි පළමු අනුවාදයේ එකතු කරන ලද වැඩ කිරීම සඳහා ප්ලගීන.

2019 ආරම්භයේදී, ගස් තුළ ප්ලගීන යල්පැන ඇති බව ප්‍රකාශ කර ඇත. අපි Flexvolume ප්ලගිනය සඳහා අඛණ්ඩව සහය දැක්වීමට සැලසුම් කරමු, නමුත් ඒ සඳහා නව ක්‍රියාකාරීත්වයක් වර්ධනය නොකරමු.

අපට දැනටමත් ceph-csi, vsphere-csi භාවිතා කිරීමේ අත්දැකීම් ඇති අතර මෙම ලැයිස්තුවට එක් කිරීමට සූදානම්! මෙතෙක්, CSI එය වෙත පවරා ඇති කාර්යයන් සමඟ සාර්ථකව කටයුතු කරයි, නමුත් අපි බලා සිටිමු.

අලුත් සෑම දෙයක්ම පැරණි දේ ගැන නැවත සිතා බැලීමක් බව අමතක නොකරන්න!

ප්රාදේශීය සභා

අපගේ බ්ලොග් අඩවියේ ද කියවන්න:

• «අපි බහාලුම් ගබඩා අතුරුමුහුණත තේරුම් ගනිමු (කුබර්නෙටස් හි පමණක් නොව)»;
• «Rook කිරීමට හෝ Rook කිරීමට - එය ප්රශ්නයයි»;
• «Kubernetes හි වෙළුම් ස්නැප්ෂොට් වල ඇල්ෆා අනුවාදය හඳුන්වා දීම".

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