ການປະຕິບັດຄໍາສັ່ງດຶງ docker ແລະ docker push ໂດຍບໍ່ມີລູກຄ້າ docker ໂດຍໃຊ້ຄໍາຮ້ອງຂໍ HTTP

ພວກເຮົາມີ 2 ຖົງຂອງຫຍ້າ, 75 ເມັດ mescaline unix ສະພາບແວດລ້ອມ, docker repository ແລະວຽກງານຂອງການປະຕິບັດຄໍາສັ່ງດຶງ docker ແລະ docker push ໂດຍບໍ່ມີການລູກຄ້າ docker.

UPS:
ຄໍາຖາມ: ທັງຫມົດນີ້ແມ່ນເພື່ອຫຍັງ?
ຄໍາຕອບ: ການທົດສອບການໂຫຼດຂອງຜະລິດຕະພັນ (ບໍ່ໃຊ້ bash, scripts ໄດ້ຖືກສະຫນອງໃຫ້ສໍາລັບການສຶກສາ). ມັນໄດ້ຖືກຕັດສິນໃຈທີ່ຈະບໍ່ໃຊ້ລູກຄ້າ docker ເພື່ອຫຼຸດຜ່ອນຊັ້ນເພີ່ມເຕີມ (ພາຍໃນຂອບເຂດທີ່ສົມເຫດສົມຜົນ) ແລະ, ຕາມຄວາມເຫມາະສົມ, emulate ການໂຫຼດທີ່ສູງຂຶ້ນ. ດັ່ງນັ້ນ, ການຊັກຊ້າຂອງລະບົບທັງຫມົດຂອງລູກຄ້າ Docker ໄດ້ຖືກໂຍກຍ້າຍ. ພວກເຮົາໄດ້ຮັບການໂຫຼດທີ່ຂ້ອນຂ້າງສະອາດໂດຍກົງກ່ຽວກັບຜະລິດຕະພັນ.
ບົດຄວາມໄດ້ໃຊ້ເຄື່ອງມືລຸ້ນ GNU.

ທໍາອິດ, ໃຫ້ເຮົາຄິດອອກວ່າຄໍາສັ່ງເຫຼົ່ານີ້ເຮັດຫຍັງ.

ດັ່ງນັ້ນ docker pull ໃຊ້ສໍາລັບຫຍັງ? ອີງ​ຕາມ ເອກະສານ:

"ດຶງຮູບພາບຫຼື repository ຈາກທະບຽນ".

ຢູ່ທີ່ນັ້ນພວກເຮົາຍັງຊອກຫາການເຊື່ອມຕໍ່ກັບ ເຂົ້າໃຈຮູບພາບ, ບັນຈຸ, ແລະໄດເວີການເກັບຮັກສາ.

ຈາກທີ່ນີ້ພວກເຮົາສາມາດເຂົ້າໃຈວ່າຮູບພາບ docker ແມ່ນຊຸດຂອງຊັ້ນຂໍ້ມູນບາງຢ່າງທີ່ມີຂໍ້ມູນກ່ຽວກັບການປ່ຽນແປງຫຼ້າສຸດຂອງຮູບພາບ, ເຊິ່ງແນ່ນອນວ່າພວກເຮົາຕ້ອງການ. ຕໍ່ໄປພວກເຮົາເບິ່ງຢູ່ API ທະບຽນ.

ມັນເວົ້າດັ່ງຕໍ່ໄປນີ້:

"ຮູບພາບ" ແມ່ນການລວມກັນຂອງ JSON 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"

ໃນການຕອບສະຫນອງ, ພວກເຮົາໄດ້ຮັບ json ຈາກທີ່ພວກເຮົາມີຄວາມສົນໃຈໃນປັດຈຸບັນພຽງແຕ່ໃນ lifelines, ຫຼືແທນທີ່ຈະ hashes ຂອງເຂົາເຈົ້າ. ເມື່ອໄດ້ຮັບພວກມັນ, ພວກເຮົາສາມາດຜ່ານແຕ່ລະອັນແລະປະຕິບັດການຮ້ອງຂໍຕໍ່ໄປນີ້: "GET /v2/{name}/blobs/{digest}"

"ການເຂົ້າເຖິງຊັ້ນໃດ ໜຶ່ງ ຈະຖືກເປີດໂດຍຊື່ຂອງບ່ອນເກັບມ້ຽນແຕ່ຖືກ ກຳ ນົດສະເພາະໃນທະບຽນໂດຍການຍ່ອຍ."

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

ເຫຼົ່ານັ້ນ. lifelines ແມ່ນ tar archives, ໂດຍ unpacking ໃຫ້ເຂົາເຈົ້າໃນຄໍາສັ່ງທີ່ເຫມາະສົມ, ພວກເຮົາຈະໄດ້ຮັບເນື້ອໃນຂອງຮູບພາບ.

ໃຫ້ຂຽນ script bash ຂະຫນາດນ້ອຍເພື່ອໃຫ້ທັງຫມົດນີ້ສາມາດອັດຕະໂນມັດ

#!/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}
  ຄວາມຍາວເນື້ອຫາ: {size of layer}
  ປະເພດເນື້ອຫາ: ແອັບພລິເຄຊັນ/octet-stream
  ຊັ້ນຂໍ້ມູນຖານສອງ".
• ກຳລັງໂຫລດ manifest - "PUT /v2/{repoName}/manifests/{reference}".

ແຕ່ເອກະສານຂາດຂັ້ນຕອນຫນຶ່ງ, ໂດຍບໍ່ມີການທີ່ບໍ່ມີຫຍັງຈະເຮັດວຽກ. ສໍາລັບການໂຫຼດ monolithic, ເຊັ່ນດຽວກັນກັບສໍາລັບບາງສ່ວນ (chunked), ກ່ອນທີ່ຈະໂຫຼດລົດໄຟ, ທ່ານຕ້ອງປະຕິບັດຄໍາຮ້ອງຂໍ PATCH:

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
ຄວາມຍາວເນື້ອຫາ: {size of chunk}
ປະເພດເນື້ອຫາ: ແອັບພລິເຄຊັນ/octet-stream
{Layer Chunk Binary Data}".

ຖ້າບໍ່ດັ່ງນັ້ນ, ເຈົ້າຈະບໍ່ສາມາດກ້າວໄປໄກກວ່າຈຸດທໍາອິດ, ເພາະວ່າ ... ແທນທີ່ຈະເປັນລະຫັດຕອບສະຫນອງທີ່ຄາດໄວ້ 202, ທ່ານຈະໄດ້ຮັບ 4xx.

ໃນປັດຈຸບັນ algorithm ເບິ່ງຄືວ່າ:

• ການລິເລີ່ມ
• Patch rail
• ກຳລັງໂຫລດ handrail
• ກຳລັງໂຫລດ manifest
  ຈຸດ 2 ແລະ 3, ຕາມລໍາດັບ, ຈະຖືກເຮັດຊ້ໍາອີກຫຼາຍຄັ້ງຕາມຈໍານວນສາຍທີ່ຕ້ອງການໂຫຼດ.

ກ່ອນອື່ນ ໝົດ, ພວກເຮົາຕ້ອງການຮູບພາບໃດ ໜຶ່ງ. ຂ້ອຍຈະໃຊ້ archlinux:latest

docker pull archlinux

ຕອນນີ້ໃຫ້ພວກເຮົາບັນທຶກມັນຢູ່ໃນທ້ອງຖິ່ນເພື່ອການວິເຄາະຕື່ມອີກ

docker save c24fe13d37b9 -o savedArch

ຖອດແຟ້ມຈັດເກັບຜົນໄດ້ຮັບເຂົ້າໄປໃນໄດເລກະທໍລີປະຈຸບັນ

tar xvf savedArch

ດັ່ງທີ່ທ່ານສາມາດເຫັນໄດ້, ແຕ່ລະເສັ້ນຊີວິດແມ່ນຢູ່ໃນໂຟນເດີແຍກຕ່າງຫາກ. ຕອນນີ້ໃຫ້ເບິ່ງໂຄງສ້າງຂອງ manifest ທີ່ພວກເຮົາໄດ້ຮັບ

cat manifest.json | json_pp

ບໍ່​ຫຼາຍ. ໃຫ້ເຮົາເບິ່ງສິ່ງທີ່ manifest ມີຄວາມຈໍາເປັນໃນການໂຫຼດ, ອີງຕາມການ ເອກະສານ.

ແນ່ນອນ, manifesto ທີ່ມີຢູ່ແລ້ວບໍ່ເຫມາະສົມກັບພວກເຮົາ, ດັ່ງນັ້ນພວກເຮົາຈະເຮັດດ້ວຍ blackjack ແລະ courtesans, lifelines ແລະ configs.

ພວກເຮົາຈະມີຢ່າງໜ້ອຍໜຶ່ງໄຟລ໌ config ແລະ array ຂອງ lifelines. 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

ຫຼັງຈາກການສ້າງ manifest ພື້ນຖານ, ທ່ານຈໍາເປັນຕ້ອງຕື່ມຂໍ້ມູນທີ່ຖືກຕ້ອງ. ເພື່ອເຮັດສິ່ງນີ້, ພວກເຮົາໃຊ້ json template ຂອງ rail object:

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

ພວກເຮົາຈະເພີ່ມມັນໃສ່ manifest ສໍາລັບແຕ່ລະ rail.

ຕໍ່ໄປ, ພວກເຮົາຈໍາເປັນຕ້ອງຊອກຫາຂະຫນາດຂອງໄຟລ໌ config ແລະປ່ຽນແທນ stubs ໃນ manifest ດ້ວຍຂໍ້ມູນທີ່ແທ້ຈິງ.

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

ໃນປັດຈຸບັນທ່ານສາມາດເລີ່ມຕົ້ນຂະບວນການດາວໂຫຼດແລະຊ່ວຍປະຢັດຕົວທ່ານເອງເປັນ uuid, ເຊິ່ງຄວນຈະມາພ້ອມກັບການຮ້ອງຂໍຕໍ່ໄປທັງຫມົດ.

script ສະບັບສົມບູນມີລັກສະນະຄ້າຍຄືນີ້:

#!/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

UPS:
ພວກເຮົາໄດ້ຮັບຜົນຫຍັງ?
ທໍາອິດ, ຂໍ້ມູນທີ່ແທ້ຈິງສໍາລັບການວິເຄາະ, ນັບຕັ້ງແຕ່ການທົດສອບແມ່ນດໍາເນີນຢູ່ໃນ blazemeter ແລະຂໍ້ມູນການຮ້ອງຂໍຂອງລູກຄ້າ docker ບໍ່ມີຂໍ້ມູນຫຼາຍ, ບໍ່ເຫມືອນກັບຄໍາຮ້ອງຂໍ HTTP ບໍລິສຸດ.

ອັນທີສອງ, ການປ່ຽນແປງໄດ້ອະນຸຍາດໃຫ້ພວກເຮົາເພີ່ມຈໍານວນຜູ້ໃຊ້ virtual ສໍາລັບການອັບໂຫລດ docker ປະມານ 150% ແລະໃຊ້ເວລາຕອບສະຫນອງສະເລ່ຍ 20-25%. ສໍາລັບການດາວໂຫຼດ docker, ພວກເຮົາໄດ້ຈັດການເພີ່ມຈໍານວນຜູ້ໃຊ້ 500%, ໃນຂະນະທີ່ເວລາຕອບສະຫນອງສະເລ່ຍຫຼຸດລົງປະມານ 60%.

ຂໍຂອບໃຈທ່ານສໍາລັບການເອົາໃຈໃສ່ຂອງທ່ານ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com