HTTP વિનંતીઓનો ઉપયોગ કરીને ડોકર ક્લાયંટ વિના ડોકર પુલ અને ડોકર પુશ આદેશોનો અમલ કરવો

અમારી પાસે ઘાસની 2 બેગ હતી, 75 મેસ્કેલિન ટેબ્લેટ્સ યુનિક્સ એન્વાયર્નમેન્ટ, એક ડોકર રિપોઝીટરી અને ડોકર ક્લાયન્ટ વિના ડોકર પુલ અને ડોકર પુશ આદેશોને અમલમાં મૂકવાનું કાર્ય હતું.

યુપીડી:
પ્રશ્ન: આ બધું શેના માટે છે?
જવાબ: ઉત્પાદનનું લોડ પરીક્ષણ (બેશનો ઉપયોગ નહીં, સ્ક્રિપ્ટો શૈક્ષણિક હેતુઓ માટે પ્રદાન કરવામાં આવે છે). વધારાના સ્તરો (વાજબી મર્યાદામાં) ઘટાડવા માટે ડોકર ક્લાયંટનો ઉપયોગ ન કરવાનો નિર્ણય લેવામાં આવ્યો હતો અને તે મુજબ, વધુ ભારનું અનુકરણ કરવામાં આવ્યું હતું. પરિણામે, ડોકર ક્લાયંટના તમામ સિસ્ટમ વિલંબ દૂર કરવામાં આવ્યા હતા. અમને ઉત્પાદન પર સીધો પ્રમાણમાં સ્વચ્છ લોડ મળ્યો.
લેખમાં સાધનોના GNU સંસ્કરણોનો ઉપયોગ કરવામાં આવ્યો હતો.

પ્રથમ, ચાલો જોઈએ કે આ આદેશો શું કરે છે.

તો ડોકર પુલ શા માટે વપરાય છે? અનુસાર દસ્તાવેજીકરણ:

"રજિસ્ટ્રીમાંથી છબી અથવા રીપોઝીટરી ખેંચો".

ત્યાં આપણને તેની લિંક પણ મળે છે છબીઓ, કન્ટેનર અને સ્ટોરેજ ડ્રાઇવરોને સમજો.

અહીંથી આપણે સમજી શકીએ છીએ કે ડોકર ઇમેજ એ ચોક્કસ સ્તરોનો સમૂહ છે જેમાં ઇમેજમાં નવીનતમ ફેરફારો વિશેની માહિતી હોય છે, જે દેખીતી રીતે જ આપણને જોઈએ છે. આગળ આપણે જોઈએ છીએ રજિસ્ટ્રી 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