HTTP တောင်းဆိုမှုများကို အသုံးပြု၍ docker client မပါဘဲ docker pull နှင့် docker push command များကို အကောင်အထည်ဖော်ခြင်း။

ကျွန်ုပ်တို့တွင် မြက်အိတ် ၂ အိတ်၊ မက်စကာလိုင်း တက်ဘလက် ၇၅ လုံး Unix ပတ်ဝန်းကျင်၊ docker သိုလှောင်ခန်းနှင့် docker ကလိုင်းယင့်မပါဘဲ docker ဆွဲယူခြင်းနှင့် docker push ညွှန်ကြားချက်များကို အကောင်အထည်ဖော်ရန် တာဝန်ရှိသည်။

UPD:
မေး- ဒါတွေအားလုံးက ဘာအတွက်လဲ။
အဖြေ- ထုတ်ကုန်၏စမ်းသပ်မှုကို တင်ပါ (bash မသုံးပါ၊ scripts များကို ပညာရေးဆိုင်ရာရည်ရွယ်ချက်များအတွက် ပံ့ပိုးပေးသည်)။ ထပ်လောင်းအလွှာများကို (ကျိုးကြောင်းဆီလျော်သောကန့်သတ်ချက်များအတွင်း) လျှော့ချရန် docker client ကိုအသုံးမပြုရန် ဆုံးဖြတ်ခဲ့ပြီး၊ ထို့ကြောင့် ပိုမိုမြင့်မားသောဝန်ကို အတုယူရန် ဆုံးဖြတ်ခဲ့သည်။ ရလဒ်အနေဖြင့် Docker client ၏ စနစ်နှောင့်နှေးမှုအားလုံးကို ဖယ်ရှားခဲ့သည်။ ကျွန်ုပ်တို့သည် ထုတ်ကုန်အပေါ် တိုက်ရိုက် သန့်ရှင်းသောဝန်ကို လက်ခံရရှိခဲ့ပါသည်။
ဆောင်းပါးတွင် GNU ဗားရှင်းများကို အသုံးပြုထားသည်။

ဦးစွာ၊ ဤအမိန့်တော်များသည် အဘယ်အရာလုပ်ဆောင်သည်ကို အဖြေရှာကြည့်ကြပါစို့။

ဒါဆို Docker Pull ကို ဘာအတွက်သုံးတာလဲ။ အရ စာရွက်စာတမ်း:

"မှတ်ပုံတင်တစ်ခုမှ ပုံ သို့မဟုတ် သိုလှောင်ခန်းကို ဆွဲယူပါ။"

အဲဒီမှာ လင့်ခ်တစ်ခုကိုလည်း တွေ့တယ်။ ပုံများ၊ ကွန်တိန်နာများနှင့် သိုလှောင်မှုဒရိုက်ဗာများကို နားလည်ပါ။.

ဤနေရာမှနေ၍ docker ပုံသည် ကျွန်ုပ်တို့လိုအပ်သောအရာဖြစ်သည်မှာ သိသာထင်ရှားသော ရုပ်ပုံ၏နောက်ဆုံးပြောင်းလဲမှုများနှင့်ပတ်သက်သည့် အချက်အလက်များပါရှိသော အချို့သောအလွှာများဖြစ်ကြောင်း ကျွန်ုပ်တို့နားလည်နိုင်ပါသည်။ နောက်တစ်ခု ကျွန်တော်တို့ ကြည့်တယ်။ မှတ်ပုံတင်ခြင်း API.

၎င်းသည် အောက်ပါအတိုင်းဆိုသည်။

""ပုံ" သည် JSON မန်နီးဖက်စ်နှင့် အလွှာတစ်ခုချင်းစီ၏ အလွှာဖိုင်များ ပေါင်းစပ်မှုဖြစ်သည်။ အဆိုပါ အစိတ်အပိုင်းနှစ်ခုကို ပြန်လည်ရယူရာတွင် > ပုံတစ်ပုံကို ဆွဲထုတ်သည့် လုပ်ငန်းစဉ်သည် ဗဟိုချက်ဖြစ်သည်။"

ဒါကြောင့် စာရွက်စာတမ်းတွေအရ ပထမအဆင့်က "Image Manifest ကိုဆွဲခြင်း။"။

ဟုတ်ပါတယ်၊ ငါတို့က အဲဒါကို ပစ်မှာမဟုတ်ဘူး၊ ဒါပေမယ့် ငါတို့က ဒေတာတွေလိုတယ်။ အောက်တွင်ဖော်ပြထားသော တောင်းဆိုချက်မှာ ဥပမာတစ်ခုဖြစ်သည်။ GET /v2/{name}/manifests/{reference}

"အမည်နှင့် ရည်ညွှန်းမှု ကန့်သတ်ချက်သည် ပုံအား ခွဲခြားသတ်မှတ်ပြီး လိုအပ်ပါသည်။ ကိုးကားချက်တွင် တဂ် သို့မဟုတ် အချေအတင် ပါဝင်နိုင်သည်။"

ကျွန်ုပ်တို့၏ docker repository ကို စက်တွင်းတွင် အသုံးပြုထားပြီး၊ တောင်းဆိုချက်ကို အကောင်အထည်ဖော်ရန် ကြိုးစားကြပါစို့။

curl -s -X GET "http://localhost:8081/link/to/docker/registry/v2/centos-11-10/manifests/1.1.1" -H "header_if_needed"

တုံ့ပြန်မှုအနေဖြင့်၊ ကျွန်ုပ်တို့သည် လက်ရှိအသက်သွေးကြောများ သို့မဟုတ် ၎င်းတို့၏ hashe များကိုသာ စိတ်ဝင်စားသည့် json ကို လက်ခံရရှိပါသည်။ ၎င်းတို့ကို လက်ခံရရှိပြီးနောက်၊ တစ်ခုချင်းစီမှတစ်ဆင့် ကျွန်ုပ်တို့သည် အောက်ပါတောင်းဆိုချက်ကို လုပ်ဆောင်နိုင်သည်- "GET /v2/{name}/blobs/{digest}"

"အလွှာတစ်ခုသို့ဝင်ရောက်ခြင်းကို repository ၏အမည်ဖြင့်တံခါးပိတ်လိမ့်မည်ဖြစ်သော်လည်း၊ မှတ်ပုံတင်ခြင်းတွင်ထူးခြားစွာခွဲခြားသတ်မှတ်ထားသည်။"

ဤကိစ္စတွင် digest သည်ကျွန်ုပ်တို့ရရှိထားသော hash ဖြစ်သည်။

ကြိုးစားနေပါတယ်။

curl -s -X GET "http://localhost:8081/link/to/docker/registry/v2/centos-11-10/blobs/sha256:f972d139738dfcd1519fd2461815651336ee25a8b54c358834c50af094bb262f" -H "header_if_needed" --output firstLayer

ပထမဦးဆုံး အသက်သွေးကြောအဖြစ် နောက်ဆုံးရရှိခဲ့တဲ့ ဖိုင်အမျိုးအစားကို ကြည့်ကြရအောင်။

file firstLayer

အဲဒါတွေ။ ရထားလမ်းများသည် ကတ္တရာစေး မော်ကွန်းတိုက်များဖြစ်ပြီး ၎င်းတို့ကို သင့်လျော်သော အစီအစဥ်အတိုင်း ထုပ်ပိုးပြီး ပုံ၏ အကြောင်းအရာများကို ကျွန်ုပ်တို့ ရရှိမည်ဖြစ်သည်။

ဒါတွေအားလုံး အလိုအလျောက်ဖြစ်နိုင်အောင် bash script လေးတစ်ခုရေးလိုက်ရအောင်

#!/bin/bash -eu

downloadDir=$1
# url as http://localhost:8081/link/to/docker/registry
url=$2
imageName=$3
tag=$4

# array of layers
layers=($(curl -s -X GET "$url/v2/$imageName/manifests/$tag" | grep -oP '(?<=blobSum" : ").+(?=")'))

# download each layer from array
for layer in "${layers[@]}"; do
    echo "Downloading ${layer}"
    curl -v -X GET "$url/v2/$imageName/blobs/$layer" --output "$downloadDir/$layer.tar"
done

# find all layers, untar them and remove source .tar files
cd "$downloadDir" && find . -name "sha256:*" -exec tar xvf {} ;
rm sha256:*.tar
exit 0

ယခု ကျွန်ုပ်တို့ ၎င်းကို အလိုရှိသော ဘောင်များဖြင့် လုပ်ဆောင်နိုင်ပြီး လိုအပ်သော ပုံ၏ အကြောင်းအရာများကို ရယူနိုင်ပါသည်။

./script.sh dirName “http://localhost:8081/link/to/docker/registry” myAwesomeImage 1.0

အပိုင်း 2 - docker push

ဒါက နည်းနည်းပိုရှုပ်ထွေးလိမ့်မယ်။

ဖြင့် ပြန်စကြပါစို့ စာရွက်စာတမ်း. ထို့ကြောင့် ကျွန်ုပ်တို့သည် ခေါင်းဆောင်တစ်ဦးစီကို ဒေါင်းလုဒ်လုပ်ရန်၊ သက်ဆိုင်ရာ manifest ကို စုဆောင်းပြီး ၎င်းကိုလည်း ဒေါင်းလုဒ်လုပ်ရန် လိုအပ်ပါသည်။ ရိုးရှင်းပုံရသည်။

စာရွက်စာတမ်းများကို လေ့လာပြီးနောက်၊ ကျွန်ုပ်တို့သည် ဒေါင်းလုဒ်လုပ်ငန်းစဉ်ကို အဆင့်များစွာဖြင့် ပိုင်းခြားနိုင်သည်-

• လုပ်ငန်းစဉ် စတင်ခြင်း - "POST /v2/{repoName}/blobs/uploads/"
• အသက်သွေးကြောတစ်ခုကို အပ်လုဒ်တင်ခြင်း (ကျွန်ုပ်တို့သည် monolithic အပ်လုဒ်ကို အသုံးပြုပါမည်၊ ဆိုလိုသည်မှာ ကျွန်ုပ်တို့သည် ၎င်း၏ အသက်သွေးကြောတစ်ခုစီကို တစ်ခုလုံးတွင် ပေးပို့သည်) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
  အကြောင်းအရာ-အရှည်- {အလွှာ၏ အရွယ်အစား}
  အကြောင်းအရာ-အမျိုးအစား- အပလီကေးရှင်း/octet-stream
  Layer Binary Data"။
• မန်နီးဖက်စ်ကို ဖွင့်နေသည် - "PUT /v2/{repoName}/manifests/{reference}"။

သို့သော် စာရွက်စာတမ်းသည် မည်သည့်အရာမျှ အလုပ်မဖြစ်ဘဲ ခြေတစ်လှမ်း လွဲသွားသည်။ ရထားလမ်းကို မတင်မီ monolithic loading နှင့် partial (chunked) အတွက်၊ PATCH တောင်းဆိုမှုကို လုပ်ဆောင်ရပါမည်-

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
အကြောင်းအရာ-အရှည်- {အတုံးအရွယ်အစား}
အကြောင်းအရာ-အမျိုးအစား- အပလီကေးရှင်း/octet-stream
{Layer Chunk Binary Data}"။

မဟုတ်ရင် ပထမအချက်ကို ကျော်လွန်ပြီး ရွေ့နိုင်မှာ မဟုတ်ပါဘူး...၊ မျှော်လင့်ထားသည့် တုံ့ပြန်မှုကုဒ် 202 အစား 4xx ကို ရရှိမည်ဖြစ်သည်။

ယခု algorithm သည် အောက်ပါအတိုင်း ဖြစ်ပုံရသည်။

• စတင်ခြင်း
• ဖာရထားလမ်း
• လက်တန်းကို ဆွဲတင်နေသည်။
• မန်နီးဖက်စ်ကို ဖွင့်နေသည်။
  အမှတ် 2 နှင့် 3 အသီးသီးသည် လိုင်းအရေအတွက်ကို တင်ရန် လိုအပ်သည်နှင့်အမျှ အကြိမ်များစွာ ထပ်ခါထပ်ခါ ပြုလုပ်ပါမည်။

ပထမဦးစွာကျွန်ုပ်တို့မည်သည့်ပုံလိုအပ်သည်။ archlinux:latest ကိုသုံးပါမည်။

docker pull archlinux

ယခု ထပ်မံခွဲခြမ်းစိတ်ဖြာရန်အတွက် ၎င်းကို စက်တွင်း၌ သိမ်းဆည်းလိုက်ကြပါစို့

docker save c24fe13d37b9 -o savedArch

ရရှိလာသော မော်ကွန်းကို လက်ရှိလမ်းညွှန်ထဲသို့ ထုပ်ပိုးလိုက်ပါ။

tar xvf savedArch

သင်တွေ့မြင်ရသည့်အတိုင်း၊ အသက်သွေးကြောတစ်ခုစီသည် သီးခြားဖိုင်တွဲတစ်ခုတွင် ရှိနေသည်။ ယခုကျွန်ုပ်တို့ရရှိထားသော manifest ၏ဖွဲ့စည်းပုံကိုကြည့်ကြပါစို့

cat manifest.json | json_pp

မဟုတ်ပါ။ အဆိုအရ မည်သို့သော မန်နီးဖက်စ်ကို တင်ရန် လိုအပ်သည်ကို ကြည့်ကြပါစို့ စာရွက်စာတမ်း.

ထင်ရှားသည်မှာ၊ ရှိပြီးသားဖော်ပြချက်သည် ကျွန်ုပ်တို့နှင့် မကိုက်ညီသောကြောင့် ကျွန်ုပ်တို့၏ကိုယ်ပိုင် blackjack နှင့် courtesans၊ lifelines နှင့် configs များဖြင့် ကျွန်ုပ်တို့ကို ဖန်တီးပါမည်။

ကျွန်ုပ်တို့တွင် အနည်းဆုံး config ဖိုင်တစ်ခုနှင့် အသက်သွေးကြောတစ်ခု အမြဲရှိနေပါမည်။ Scheme ဗားရှင်း 2 (ရေးသားနေချိန်တွင် လက်ရှိ)၊ mediaType သည် မပြောင်းလဲဘဲ ကျန်နေလိမ့်မည်-

echo ‘{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
   "config": {
      "mediaType": "application/vnd.docker.container.image.v1+json",
      "size": config_size,
      "digest": "config_hash"
   },
   "layers": [
      ’ > manifest.json

အခြေခံမန်နီးဖက်စ်ကို ဖန်တီးပြီးနောက်၊ ၎င်းကို မှန်ကန်သောဒေတာဖြင့် ဖြည့်စွက်ရန် လိုအပ်သည်။ ဒါကိုလုပ်ဖို့၊ rail object ရဲ့ json template ကို သုံးပါတယ်။

{
         "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
         "size": ${layersSizes[$i]},
         "digest": "sha256:${layersNames[$i]}"
      },

ရထားတစ်ခုစီအတွက် မန်နီးဖက်စ်တွင် ၎င်းကို ထည့်ပါမည်။

ထို့နောက်၊ ကျွန်ုပ်တို့သည် config ဖိုင်၏အရွယ်အစားကိုရှာဖွေပြီး manifest ရှိ stubs များကို real data ဖြင့်အစားထိုးရန်လိုအပ်ပါသည်။

sed -i "s/config_size/$configSize/g; s/config_hash/$configName/g" $manifestFile

ယခု သင်သည် ဒေါင်းလုဒ်လုပ်ခြင်းလုပ်ငန်းစဉ်ကို စတင်နိုင်ပြီး နောက်ဆက်တွဲတောင်းဆိုမှုများအားလုံးကို လိုက်လျောညီထွေဖြစ်စေမည့် uuid ကို သင့်ကိုယ်သင် သိမ်းဆည်းနိုင်ပါပြီ။

ဇာတ်ညွှန်းအပြည့်အစုံသည် ဤကဲ့သို့ ဖြစ်သည်-

#!/bin/bash -eux

imageDir=$1
# url as http://localhost:8081/link/to/docker/registry
url=$2
repoName=$3
tag=$4
manifestFile=$(readlink -f ${imageDir}/manifestCopy)
configFile=$(readlink -f $(find $imageDir -name "*.json" ! -name "manifest.json"))

# calc layers sha 256 sum, rename them accordingly, and add info about each to manifest file
function prepareLayersForUpload() {
  info_file=$imageDir/info
  # lets calculate layers sha256 and use it as layers names further
  layersNames=($(find $imageDir -name "layer.tar" -exec shasum -a 256 {} ; | cut -d" " -f1))

  # rename layers according to shasums. !!!Set required amount of fields for cut command!!!
  # this part definitely can be done easier but i didn't found another way, sry
  find $imageDir -name "layer.tar" -exec bash -c 'mv {} "$(echo {} | cut -d"/" -f1,2)/$(shasum -a 256 {} | cut -d" " -f1)"' ;

  layersSizes=($(find $imageDir -name "*.tar" -exec ls -l {} ; | awk '{print $5}'))

  for i in "${!layersNames[@]}"; do
    echo "{
         "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
         "size": ${layersSizes[$i]},
         "digest": "sha256:${layersNames[$i]}"
      }," >> $manifestFile
  done
  # remove last ','
  truncate -s-2 $manifestFile
  # add closing brakets to keep json consistent
  printf "nt]n}" >> $manifestFile
}

# calc config sha 256 sum and add info about it to manifest
function setConfigProps() {
  configSize=$(ls -l $configFile | awk '{print $5}')
  configName=$(basename $configFile | cut -d"." -f1)

  sed -i "s/config_size/$configSize/g; s/config_hash/$configName/g" $manifestFile
}

#prepare manifest file
prepareLayersForUpload
setConfigProps
cat $manifestFile

# initiate upload and get uuid
uuid=$(curl -s -X POST -I "$url/v2/$repoName/blobs/uploads/" | grep -oP "(?<=Docker-Upload-Uuid: ).+")

# patch layers
# in data-binary we're getting absolute path to layer file
for l in "${!layersNames[@]}"; do
  pathToLayer=$(find $imageDir -name ${layersNames[$l]} -exec readlink -f {} ;)
    curl -v -X PATCH "$url/v2/$repoName/blobs/uploads/$uuid" 
  -H "Content-Length: ${layersSizes[$i]}" 
  -H "Content-Type: application/octet-stream" 
  --data-binary "@$pathToLayer"

# put layer
  curl -v -X PUT "$url/v2/$repoName/blobs/uploads/$uuid?digest=sha256:${layersNames[$i]}" 
  -H 'Content-Type: application/octet-stream' 
  -H "Content-Length: ${layersSizes[$i]}" 
  --data-binary "@$pathToLayer"
done

# patch and put config after all layers
curl -v -X PATCH "$url/v2/$repoName/blobs/uploads/$uuid" 
  -H "Content-Length: $configSize" 
  -H "Content-Type: application/octet-stream" 
  --data-binary "@$configFile"

  curl -v -X PUT "$url/v2/$repoName/blobs/uploads/$uuid?digest=sha256:$configName" 
  -H 'Content-Type: application/octet-stream' 
  -H "Content-Length: $configSize" 
  --data-binary "@$configFile"

# put manifest
curl -v -X PUT "$url/v2/$repoName/manifests/$tag" 
  -H 'Content-Type: application/vnd.docker.distribution.manifest.v2+json' 
  --data-binary "@$manifestFile"

exit 0

အဆင်သင့်လုပ်ထားသော script ကိုသုံးနိုင်သည်။

./uploadImage.sh "~/path/to/saved/image" "http://localhost:8081/link/to/docker/registry" myRepoName 1.0

UPD:
ရလဒ်အနေနဲ့ ကျွန်တော်တို့ ဘာရခဲ့လဲ။
ပထမဦးစွာ၊ စမ်းသပ်မှုများကို blazemeter တွင်လုပ်ဆောင်ပြီး docker client တောင်းဆိုမှုဆိုင်ရာဒေတာသည် HTTP တောင်းဆိုချက်များနှင့်မတူဘဲ သတင်းအချက်အလက်အတွက် အလွန်သိရှိနိုင်သောကြောင့် ခွဲခြမ်းစိတ်ဖြာရန်အတွက် ဒေတာအစစ်အမှန်ဖြစ်သည်။

ဒုတိယအနေဖြင့်၊ အကူးအပြောင်းသည် ကျွန်ုပ်တို့အား docker အပ်လုဒ်လုပ်ရန်အတွက် virtual အသုံးပြုသူအရေအတွက်ကို 150% ခန့်တိုးစေပြီး ပျမ်းမျှတုံ့ပြန်ချိန် 20-25% ပိုမိုမြန်ဆန်စေသည်။ docker ဒေါင်းလုဒ်အတွက်၊ ကျွန်ုပ်တို့သည် ပျမ်းမျှတုံ့ပြန်မှုအချိန် 500% ခန့်လျော့နည်းသွားသော်လည်း အသုံးပြုသူအရေအတွက် 60% တိုးရန် စီမံထားပါသည်။

သင့်ရဲ့အာရုံစူးစိုက်မှုကိုကျေးဇူးတင်ပါသည်။

source: www.habr.com