ការអនុវត្តពាក្យបញ្ជា docker pull និង docker push ដោយគ្មានម៉ាស៊ីនភ្ញៀវ docker ដោយប្រើសំណើ HTTP

យើងមានស្មៅ 2 បាវ 75 គ្រាប់ mescaline unix បរិស្ថាន ឃ្លាំង docker និងភារកិច្ចអនុវត្តពាក្យបញ្ជា docker pull និង docker push ដោយគ្មានម៉ាស៊ីនភ្ញៀវ docker ។

UPS៖
សំណួរ៖ តើទាំងអស់នេះសម្រាប់អ្វី?
ចម្លើយ៖ ផ្ទុកការធ្វើតេស្តផលិតផល (មិនប្រើបាសទេ ស្គ្រីបត្រូវបានផ្តល់ជូនសម្រាប់គោលបំណងអប់រំ)។ វាត្រូវបានសម្រេចចិត្តមិនប្រើម៉ាស៊ីនភ្ញៀវ docker ដើម្បីកាត់បន្ថយស្រទាប់បន្ថែម (ក្នុងដែនកំណត់សមហេតុផល) ហើយតាមនោះ ធ្វើត្រាប់តាមការផ្ទុកខ្ពស់ជាងនេះ។ ជាលទ្ធផល ការពន្យារពេលប្រព័ន្ធទាំងអស់របស់ម៉ាស៊ីនភ្ញៀវ Docker ត្រូវបានដកចេញ។ យើងបានទទួលបន្ទុកស្អាតដោយផ្ទាល់នៅលើផលិតផល។
អត្ថបទបានប្រើកំណែ GNU នៃឧបករណ៍។

ជាដំបូង ចូរយើងស្វែងយល់ថាតើពាក្យបញ្ជាទាំងនេះធ្វើអ្វី។

ដូច្នេះតើ docker pull ប្រើសម្រាប់អ្វី? យោង​ទៅ​តាម ឯកសារ:

"ទាញរូបភាព ឬឃ្លាំងពីបញ្ជីឈ្មោះ"។

នៅទីនោះយើងក៏រកឃើញតំណភ្ជាប់ទៅ យល់អំពីរូបភាព ធុង និងកម្មវិធីបញ្ជាផ្ទុក.

ពីទីនេះ យើងអាចយល់បានថា រូបភាព docker គឺជាសំណុំនៃស្រទាប់មួយចំនួនដែលមានព័ត៌មានអំពីការផ្លាស់ប្តូរចុងក្រោយបំផុតនៅក្នុងរូបភាព ដែលច្បាស់ជាអ្វីដែលយើងត្រូវការ។ បន្ទាប់យើងមើល API ចុះបញ្ជី.

វានិយាយដូចខាងក្រោមៈ

"រូបភាព" គឺជាការរួមបញ្ចូលគ្នានៃ JSON manifest និងឯកសារស្រទាប់នីមួយៗ។ ដំណើរការនៃការទាញ > រូបភាពផ្តោតជុំវិញការទាញយកសមាសធាតុទាំងពីរនេះ។"

ដូច្នេះជំហានដំបូងយោងទៅតាមឯកសារគឺ "ការទាញការបង្ហាញរូបភាព"។

ជាការពិតណាស់ យើងនឹងមិនបាញ់វាទេ ប៉ុន្តែយើងត្រូវការទិន្នន័យពីវា។ ខាង​ក្រោម​នេះ​គឺ​ជា​សំណើ​ឧទាហរណ៍៖ GET /v2/{name}/manifests/{reference}

"ឈ្មោះ និងប៉ារ៉ាម៉ែត្រយោងកំណត់អត្តសញ្ញាណរូបភាព ហើយត្រូវបានទាមទារ។ ឯកសារយោងអាចរួមបញ្ចូលស្លាក ឬសង្ខេប។"

ឃ្លាំង docker របស់យើងត្រូវបានដាក់ពង្រាយក្នុងស្រុក សូមព្យាយាមអនុវត្តសំណើ៖

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

ជាការឆ្លើយតប យើងទទួលបាន json ដែលបច្ចុប្បន្នយើងចាប់អារម្មណ៍តែលើខ្សែជីវិត ឬជាសញ្ញារបស់ពួកវា។ ដោយបានទទួលពួកវា យើងអាចឆ្លងកាត់សំណើនីមួយៗ និងអនុវត្តសំណើដូចខាងក្រោម៖ "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

ទាំងនោះ។ ផ្លូវរថភ្លើងគឺជាបណ្ណសារ tar ដោយពន្លាពួកវាតាមលំដាប់សមស្របយើងនឹងទទួលបានមាតិកានៃរូបភាព។

ចូរយើងសរសេរស្គ្រីប 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

នេះនឹងមានភាពស្មុគស្មាញបន្តិច។

តោះចាប់ផ្តើមម្តងទៀតជាមួយ ឯកសារ. ដូច្នេះយើងត្រូវទាញយកអ្នកដឹកនាំនីមួយៗ ប្រមូល manifest ដែលត្រូវគ្នា ហើយទាញយកវាផងដែរ។ វាហាក់ដូចជាសាមញ្ញ។

បន្ទាប់ពីសិក្សាឯកសាររួច យើងអាចបែងចែកដំណើរការទាញយកជាជំហានជាច្រើន៖

• ការចាប់ផ្តើមដំណើរការ - "POST /v2/{repoName}/blobs/uploads/"
• ការបង្ហោះខ្សែបន្ទាត់ជីវិត (យើងនឹងប្រើការបង្ហោះ monolithic ពោលគឺ យើងផ្ញើខ្សែជីវិតនីមួយៗទាំងស្រុង) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
  ប្រវែងខ្លឹមសារ៖ {ទំហំស្រទាប់}
  ប្រភេទមាតិកា៖ កម្មវិធី/octet-stream
  ស្រទាប់ទិន្នន័យគោលពីរ"។
• កំពុងផ្ទុក manifest - "PUT /v2/{repoName}/manifests/{reference}"។

ប៉ុន្តែ​ឯកសារ​នេះ​ខកខាន​មួយ​ជំហាន ដោយ​គ្មាន​អ្វី​នឹង​ដំណើរការ​ឡើយ។ សម្រាប់ការផ្ទុក monolithic ក៏ដូចជាសម្រាប់ផ្នែកខ្លះ (កំណាត់) មុនពេលផ្ទុកផ្លូវដែក អ្នកត្រូវតែអនុវត្តសំណើ PATCH៖

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
ប្រវែងខ្លឹមសារ៖ {ទំហំកំណាត់}
ប្រភេទមាតិកា៖ កម្មវិធី/octet-stream
{Layer Chunk Binary Data}"។

បើមិនដូច្នេះទេ អ្នកនឹងមិនអាចហួសពីចំណុចទីមួយបានទេ ព្រោះ... ជំនួសឱ្យលេខកូដឆ្លើយតបដែលរំពឹងទុក 202 អ្នកនឹងទទួលបាន 4xx ។

ឥឡូវនេះក្បួនដោះស្រាយមើលទៅដូចនេះ:

• ការចាប់ផ្តើម
• ផ្លូវដែកបំណះ
• កំពុងផ្ទុកដៃ
• កំពុងផ្ទុក manifest
  ចំនុចទី 2 និងទី 3 នឹងត្រូវធ្វើម្តងទៀតច្រើនដងតាមចំនួនបន្ទាត់ដែលត្រូវផ្ទុក។

ដំបូងយើងត្រូវការរូបភាពណាមួយ។ ខ្ញុំនឹងប្រើ archlinux:latest

docker pull archlinux

ឥឡូវនេះសូមរក្សាទុកវានៅក្នុងមូលដ្ឋានសម្រាប់ការវិភាគបន្ថែម

docker save c24fe13d37b9 -o savedArch

ពន្លាប័ណ្ណសារលទ្ធផលទៅក្នុងថតបច្ចុប្បន្ន

tar xvf savedArch

ដូចដែលអ្នកអាចឃើញខ្សែជីវិតនីមួយៗស្ថិតនៅក្នុងថតដាច់ដោយឡែកមួយ។ ឥឡូវនេះសូមមើលរចនាសម្ព័ន្ធនៃ manifest ដែលយើងបានទទួល

cat manifest.json | json_pp

មិន​ច្រើន។ តោះមើលអ្វីដែល manifest ត្រូវការដើម្បីផ្ទុក នេះបើយោងតាម ឯកសារ.

ជាក់ស្តែង ការបង្ហាញដែលមានស្រាប់មិនសមនឹងយើងទេ ដូច្នេះយើងនឹងបង្កើតដោយខ្លួនឯងជាមួយនឹង blackjack និង courtesans, lifelines និង configs ។

យើងតែងតែមានឯកសារកំណត់រចនាសម្ព័ន្ធយ៉ាងហោចណាស់មួយ និងអារេនៃខ្សែជីវិត។ គ្រោងការណ៍កំណែ 2 (បច្ចុប្បន្ននៅពេលសរសេរ) ប្រភេទមេឌៀនឹងត្រូវបានទុកចោលមិនផ្លាស់ប្តូរ៖

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 នៃវត្ថុផ្លូវដែក៖

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

យើងនឹងបន្ថែមវាទៅ manifest សម្រាប់ផ្លូវរថភ្លើងនីមួយៗ។

បន្ទាប់មក យើងត្រូវស្វែងរកទំហំនៃឯកសារកំណត់រចនាសម្ព័ន្ធ ហើយជំនួស stubs ក្នុង manifest ជាមួយទិន្នន័យពិត

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

យើងអាចប្រើស្គ្រីបដែលត្រៀមរួចជាស្រេច៖

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

UPS៖
តើយើងទទួលបានលទ្ធផលអ្វី?
ទីមួយ ទិន្នន័យពិតប្រាកដសម្រាប់ការវិភាគ ចាប់តាំងពីការធ្វើតេស្តត្រូវបានដំណើរការនៅក្នុង blazemeter ហើយទិន្នន័យនៅលើសំណើរបស់អតិថិជន docker គឺមិនមានព័ត៌មានច្រើនទេ មិនដូចសំណើ HTTP សុទ្ធនោះទេ។

ទីពីរ ការផ្លាស់ប្តូរបានអនុញ្ញាតឱ្យយើងបង្កើនចំនួនអ្នកប្រើប្រាស់និម្មិតសម្រាប់ការបង្ហោះ docker ប្រហែល 150% និងទទួលបានពេលវេលាឆ្លើយតបជាមធ្យម 20-25% លឿនជាងមុន។ សម្រាប់ការទាញយក docker យើងបានគ្រប់គ្រងដើម្បីបង្កើនចំនួនអ្នកប្រើប្រាស់ 500% ខណៈដែលពេលវេលាឆ្លើយតបជាមធ្យមបានថយចុះប្រហែល 60%។

សូមអរគុណចំពោះការយកចិត្តទុកដាក់របស់អ្នក។

ប្រភព: www.habr.com