HTTP അഭ്യർത്ഥനകൾ ഉപയോഗിച്ച് ഒരു ഡോക്കർ ക്ലയന്റ് ഇല്ലാതെ ഡോക്കർ പുൾ, ഡോക്കർ പുഷ് കമാൻഡുകൾ നടപ്പിലാക്കുന്നു

ഞങ്ങൾക്ക് 2 ബാഗ് പുല്ല്, 75 മെസ്‌കലൈൻ ടാബ്‌ലെറ്റുകൾ യുണിക്സ് എൻവയോൺമെൻ്റ്, ഒരു ഡോക്കർ റിപ്പോസിറ്ററി, ഡോക്കർ ക്ലയൻ്റ് ഇല്ലാതെ ഡോക്കർ പുൾ, ഡോക്കർ പുഷ് കമാൻഡുകൾ നടപ്പിലാക്കുന്നതിനുള്ള ചുമതല എന്നിവ ഉണ്ടായിരുന്നു.

യുപിഎസ്:
ചോദ്യം: ഇതെല്ലാം എന്തിനുവേണ്ടിയാണ്?
ഉത്തരം: ഉൽപ്പന്നത്തിൻ്റെ ലോഡ് ടെസ്റ്റിംഗ് (ബാഷ് ഉപയോഗിക്കുന്നില്ല, വിദ്യാഭ്യാസ ആവശ്യങ്ങൾക്കായി സ്ക്രിപ്റ്റുകൾ നൽകിയിട്ടുണ്ട്). അധിക ലെയറുകൾ കുറയ്ക്കുന്നതിന് (ന്യായമായ പരിധിക്കുള്ളിൽ) ഡോക്കർ ക്ലയൻ്റ് ഉപയോഗിക്കേണ്ടതില്ലെന്ന് തീരുമാനിച്ചു, അതനുസരിച്ച്, ഉയർന്ന ലോഡ് അനുകരിക്കുക. തൽഫലമായി, ഡോക്കർ ക്ലയൻ്റിൻറെ എല്ലാ സിസ്റ്റം കാലതാമസങ്ങളും നീക്കം ചെയ്തു. ഞങ്ങൾക്ക് ഉൽപ്പന്നത്തിൽ നേരിട്ട് താരതമ്യേന ശുദ്ധമായ ലോഡ് ലഭിച്ചു.
ലേഖനത്തിൽ ഉപകരണങ്ങളുടെ ഗ്നു പതിപ്പുകൾ ഉപയോഗിച്ചു.

ആദ്യം, ഈ കമാൻഡുകൾ എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് നോക്കാം.

അപ്പോൾ ഡോക്കർ പുൾ എന്തിനുവേണ്ടിയാണ് ഉപയോഗിക്കുന്നത്? ഇതനുസരിച്ച് പ്രമാണീകരണം:

"ഒരു രജിസ്ട്രിയിൽ നിന്ന് ഒരു ഇമേജ് അല്ലെങ്കിൽ ഒരു ശേഖരം വലിക്കുക".

അതിനുള്ള ഒരു ലിങ്കും അവിടെ കാണാം ഇമേജുകൾ, കണ്ടെയ്നറുകൾ, സ്റ്റോറേജ് ഡ്രൈവറുകൾ എന്നിവ മനസ്സിലാക്കുക.

ചിത്രത്തിലെ ഏറ്റവും പുതിയ മാറ്റങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾക്കൊള്ളുന്ന ചില ലെയറുകളുടെ ഒരു കൂട്ടമാണ് ഡോക്കർ ഇമേജ് എന്ന് ഇവിടെ നിന്ന് നമുക്ക് മനസ്സിലാക്കാം, അത് നമുക്ക് ആവശ്യമുള്ളതാണ്. അടുത്തതായി ഞങ്ങൾ നോക്കുന്നു രജിസ്ട്രി API.

അതിൽ ഇനിപ്പറയുന്നവ പറയുന്നു:

"ഒരു "ചിത്രം" എന്നത് ഒരു JSON മാനിഫെസ്റ്റിൻ്റെയും വ്യക്തിഗത ലെയർ ഫയലുകളുടെയും സംയോജനമാണ്. ഒരു > ഇമേജ് വലിക്കുന്ന പ്രക്രിയ ഈ രണ്ട് ഘടകങ്ങളും വീണ്ടെടുക്കുന്നതിന് ചുറ്റും കേന്ദ്രീകരിക്കുന്നു."

അതിനാൽ ഡോക്യുമെൻ്റേഷൻ അനുസരിച്ച് ആദ്യ ഘട്ടം "ഒരു ഇമേജ് മാനിഫെസ്റ്റ് വലിക്കുന്നു".

തീർച്ചയായും, ഞങ്ങൾ അത് ഷൂട്ട് ചെയ്യില്ല, പക്ഷേ ഞങ്ങൾക്ക് അതിൽ നിന്നുള്ള ഡാറ്റ ആവശ്യമാണ്. ഇനിപ്പറയുന്നത് ഒരു ഉദാഹരണ അഭ്യർത്ഥനയാണ്: GET /v2/{name}/manifests/{reference}

"പേരും റഫറൻസ് പാരാമീറ്ററും ചിത്രം തിരിച്ചറിയുന്നു, അവ ആവശ്യമാണ്. റഫറൻസിൽ ഒരു ടാഗ് അല്ലെങ്കിൽ ഡൈജസ്റ്റ് ഉൾപ്പെട്ടേക്കാം."

ഞങ്ങളുടെ ഡോക്കർ ശേഖരം പ്രാദേശികമായി വിന്യസിച്ചിരിക്കുന്നു, അഭ്യർത്ഥന നടപ്പിലാക്കാൻ ശ്രമിക്കാം:

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

"റെപ്പോസിറ്ററിയുടെ പേരിൽ ഒരു ലെയറിലേക്കുള്ള ആക്സസ് ഗേറ്റ് ചെയ്യപ്പെടും, പക്ഷേ ഡൈജസ്റ്റ് വഴി രജിസ്ട്രിയിൽ അദ്വിതീയമായി തിരിച്ചറിയുന്നു."

ഈ കേസിൽ ഡൈജസ്റ്റ് ഞങ്ങൾക്ക് ലഭിച്ച ഹാഷ് ആണ്.

ശ്രമിക്കുന്നു

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

ആ. റെയിലുകൾ ടാർ ആർക്കൈവുകളാണ്, അവ ഉചിതമായ ക്രമത്തിൽ അൺപാക്ക് ചെയ്താൽ നമുക്ക് ചിത്രത്തിൻ്റെ ഉള്ളടക്കം ലഭിക്കും.

ഒരു ചെറിയ ബാഷ് സ്ക്രിപ്റ്റ് എഴുതാം, അങ്ങനെ എല്ലാം ഓട്ടോമേറ്റ് ചെയ്യാം

#!/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 - ഡോക്കർ പുഷ്

ഇത് കുറച്ചുകൂടി സങ്കീർണ്ണമായിരിക്കും.

നമുക്ക് വീണ്ടും തുടങ്ങാം പ്രമാണീകരണം. അതിനാൽ നമ്മൾ ഓരോ നേതാവിനെയും ഡൗൺലോഡ് ചെയ്യുകയും അനുബന്ധ മാനിഫെസ്റ്റ് ശേഖരിക്കുകയും അതും ഡൗൺലോഡ് ചെയ്യുകയും വേണം. ഇത് ലളിതമായി തോന്നുന്നു.

ഡോക്യുമെൻ്റേഷൻ പഠിച്ച ശേഷം, ഡൗൺലോഡ് പ്രക്രിയയെ നമുക്ക് പല ഘട്ടങ്ങളായി വിഭജിക്കാം:

• പ്രോസസ്സ് ആരംഭിക്കൽ - "POST /v2/{repoName}/blobs/uploads/"
• ഒരു ലൈഫ്‌ലൈൻ അപ്‌ലോഡ് ചെയ്യുന്നു (ഞങ്ങൾ ഒരു മോണോലിത്തിക്ക് അപ്‌ലോഡ് ഉപയോഗിക്കും, അതായത് ഓരോ ലൈഫ്‌ലൈനും പൂർണ്ണമായി അയയ്‌ക്കും) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
  ഉള്ളടക്ക ദൈർഘ്യം: {പാളിയുടെ വലിപ്പം}
  ഉള്ളടക്ക തരം: ആപ്ലിക്കേഷൻ/ഒക്ടറ്റ്-സ്ട്രീം
  ലെയർ ബൈനറി ഡാറ്റ".
• മാനിഫെസ്റ്റ് ലോഡുചെയ്യുന്നു - "PUT /v2/{repoName}/manifests/{reference}".

എന്നാൽ ഡോക്യുമെൻ്റേഷൻ ഒരു ഘട്ടം നഷ്‌ടപ്പെടുത്തുന്നു, അതില്ലാതെ ഒന്നും പ്രവർത്തിക്കില്ല. മോണോലിത്തിക്ക് ലോഡിംഗിനും ഭാഗികമായി (ചങ്ക്ഡ്) റെയിൽ ലോഡുചെയ്യുന്നതിന് മുമ്പ്, നിങ്ങൾ ഒരു പാച്ച് അഭ്യർത്ഥന നടത്തണം:

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
ഉള്ളടക്ക ദൈർഘ്യം: {ചങ്കിൻ്റെ വലിപ്പം}
ഉള്ളടക്ക തരം: ആപ്ലിക്കേഷൻ/ഒക്ടറ്റ്-സ്ട്രീം
{ലെയർ ചങ്ക് ബൈനറി ഡാറ്റ}".

അല്ലെങ്കിൽ, നിങ്ങൾക്ക് ആദ്യ പോയിൻ്റിനപ്പുറം നീങ്ങാൻ കഴിയില്ല, കാരണം... പ്രതീക്ഷിക്കുന്ന പ്രതികരണ കോഡ് 202-ന് പകരം, നിങ്ങൾക്ക് 4xx ലഭിക്കും.

ഇപ്പോൾ അൽഗോരിതം ഇതുപോലെ കാണപ്പെടുന്നു:

• പ്രാരംഭം
• പാച്ച് റെയിൽ
• ഹാൻഡ്‌റെയിൽ ലോഡ് ചെയ്യുന്നു
• മാനിഫെസ്റ്റ് ലോഡ് ചെയ്യുന്നു
  യഥാക്രമം 2-ഉം 3-ഉം പോയിൻ്റുകൾ, എത്ര വരികൾ ലോഡുചെയ്യേണ്ടതുണ്ടോ അത്രയും തവണ ആവർത്തിക്കും.

ആദ്യം, നമുക്ക് ഏതെങ്കിലും ചിത്രം ആവശ്യമാണ്. ഞാൻ archlinux:latest ഉപയോഗിക്കും

docker pull archlinux

ഇനി കൂടുതൽ വിശകലനത്തിനായി ഇത് പ്രാദേശികമായി സംരക്ഷിക്കാം

docker save c24fe13d37b9 -o savedArch

തത്ഫലമായുണ്ടാകുന്ന ആർക്കൈവ് നിലവിലെ ഡയറക്ടറിയിലേക്ക് അൺപാക്ക് ചെയ്യുക

tar xvf savedArch

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഓരോ ലൈഫ്‌ലൈനും ഒരു പ്രത്യേക ഫോൾഡറിലാണ്. ഇനി നമുക്ക് ലഭിച്ച മാനിഫെസ്റ്റിൻ്റെ ഘടന നോക്കാം

cat manifest.json | json_pp

വളരെയധികമില്ല. ലോഡുചെയ്യാൻ ആവശ്യമായ മാനിഫെസ്റ്റ് എന്താണെന്ന് നോക്കാം പ്രമാണീകരണം.

വ്യക്തമായും, നിലവിലുള്ള മാനിഫെസ്റ്റോ ഞങ്ങൾക്ക് അനുയോജ്യമല്ല, അതിനാൽ ബ്ലാക്ക് ജാക്കും വേശ്യകളും, ലൈഫ്‌ലൈനുകളും കോൺഫിഗേഷനുകളും ഉപയോഗിച്ച് ഞങ്ങൾ സ്വന്തമായി നിർമ്മിക്കും.

ഞങ്ങൾക്ക് എല്ലായ്‌പ്പോഴും കുറഞ്ഞത് ഒരു കോൺഫിഗറേഷൻ ഫയലും ലൈഫ് ലൈനുകളുടെ ഒരു നിരയും ഉണ്ടായിരിക്കും. സ്കീം പതിപ്പ് 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

അടിസ്ഥാന മാനിഫെസ്റ്റ് സൃഷ്‌ടിച്ച ശേഷം, നിങ്ങൾ അത് സാധുവായ ഡാറ്റ ഉപയോഗിച്ച് പൂരിപ്പിക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ റെയിൽ ഒബ്ജക്റ്റിൻ്റെ json ടെംപ്ലേറ്റ് ഉപയോഗിക്കുന്നു:

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

ഓരോ റെയിലിനും ഞങ്ങൾ അത് മാനിഫെസ്റ്റിലേക്ക് ചേർക്കും.

അടുത്തതായി, കോൺഫിഗറേഷൻ ഫയലിൻ്റെ വലുപ്പം കണ്ടെത്തുകയും മാനിഫെസ്റ്റിലെ അപൂർണ്ണമായ വിവരങ്ങൾ യഥാർത്ഥ ഡാറ്റ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുകയും വേണം.

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

യുപിഎസ്:
അതിൻ്റെ ഫലമായി നമുക്ക് എന്താണ് ലഭിച്ചത്?
ഒന്നാമതായി, വിശകലനത്തിനായുള്ള യഥാർത്ഥ ഡാറ്റ, ബ്ലേസ്‌മീറ്ററിലാണ് ടെസ്റ്റുകൾ പ്രവർത്തിക്കുന്നത്, കൂടാതെ ഡോക്കർ ക്ലയൻ്റ് അഭ്യർത്ഥനകളിലെ ഡാറ്റ ശുദ്ധമായ HTTP അഭ്യർത്ഥനകളിൽ നിന്ന് വ്യത്യസ്തമായി വളരെ വിവരദായകമല്ല.

രണ്ടാമതായി, ഡോക്കർ അപ്‌ലോഡിനായുള്ള വെർച്വൽ ഉപയോക്താക്കളുടെ എണ്ണം ഏകദേശം 150% വർദ്ധിപ്പിക്കാനും ശരാശരി പ്രതികരണ സമയം 20-25% വേഗത്തിൽ നേടാനും സംക്രമണം ഞങ്ങളെ അനുവദിച്ചു. ഡോക്കർ ഡൗൺലോഡിനായി, ഉപയോക്താക്കളുടെ എണ്ണം 500% വർദ്ധിപ്പിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞു, അതേസമയം ശരാശരി പ്രതികരണ സമയം ഏകദേശം 60% കുറഞ്ഞു.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി.

അവലംബം: www.habr.com