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

भाग २ - डॉकर पुश

हे थोडे अधिक क्लिष्ट होईल.

चला पुन्हा सुरुवात करूया दस्तऐवजीकरण. म्हणून आम्हाला प्रत्येक नेता डाउनलोड करणे आवश्यक आहे, संबंधित मॅनिफेस्ट गोळा करणे आणि ते डाउनलोड करणे देखील आवश्यक आहे. हे सोपे दिसते.

दस्तऐवजीकरणाचा अभ्यास केल्यानंतर, आम्ही डाउनलोड प्रक्रियेला अनेक चरणांमध्ये विभागू शकतो:

• प्रक्रिया आरंभ - "POST /v2/{repoName}/blobs/uploads/"
• लाइफलाइन अपलोड करत आहे (आम्ही मोनोलिथिक अपलोड वापरू, म्हणजे आम्ही प्रत्येक लाईफलाईन संपूर्णपणे पाठवतो) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
  सामग्री-लांबी: {स्तराचा आकार}
  सामग्री-प्रकार: अनुप्रयोग/ऑक्टेट-स्ट्रीम
  लेयर बायनरी डेटा".
• मॅनिफेस्ट लोड करत आहे - "PUT /v2/{repoName}/manifests/{reference}".

परंतु दस्तऐवजीकरण एक पाऊल चुकते, त्याशिवाय काहीही कार्य करणार नाही. मोनोलिथिक लोडिंगसाठी, तसेच आंशिक (खंडित) साठी, रेल लोड करण्यापूर्वी, तुम्ही पॅच विनंती करणे आवश्यक आहे:

"पॅटच /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 (लेखनाच्या वेळी वर्तमान), 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

मूलभूत मॅनिफेस्ट तयार केल्यानंतर, तुम्हाला ते वैध डेटाने भरावे लागेल. हे करण्यासाठी, आम्ही रेल ऑब्जेक्टचे 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