🥇 Cur an gnìomh òrdughan tarraing docker is docker gun neach-dèiligidh docker a’ cleachdadh iarrtasan HTTP

Bha 2 phoca feòir againn, 75 tablaidean mescaline unix àrainneachd, stòr docker agus an obair a bhith a’ cur an gnìomh òrdughan tarraing docker is docker às aonais neach-dèiligidh docker.

ÙRACHADH:
Ceist: Carson a tha seo uile?
Freagairt: Deuchainn luchd air an toradh (CHAN EIL a ’cleachdadh bash, tha na sgriobtaichean air an toirt seachad airson adhbharan foghlaim). Chaidh co-dhùnadh gun a bhith a’ cleachdadh an neach-dèiligidh docker gus sreathan a bharrachd a lughdachadh (taobh a-staigh crìochan reusanta) agus, a rèir sin, atharrais air luchd nas àirde. Mar thoradh air an sin, chaidh a h-uile dàil siostam den neach-dèiligidh Docker a thoirt air falbh. Fhuair sinn luchd an ìre mhath glan gu dìreach air an toradh.
Chleachd an artaigil dreachan GNU de dh’ innealan.

An toiseach, leig dhuinn a-mach dè a bhios na h-òrdughan sin a’ dèanamh.

Mar sin carson a thathas a’ cleachdadh docker pull? A rèir sgrìobhainnean:

msgstr "Tarraing dealbh no tèarmann o chlàr."

An sin lorg sinn ceangal gu cuideachd tuigsinn ìomhaighean, soithichean, agus draibhearan stòraidh.

Às an seo tuigidh sinn gu bheil ìomhaigh docker na sheata de shreathan sònraichte anns a bheil fiosrachadh mu na h-atharrachaidhean as ùire san ìomhaigh, agus is e sin gu follaiseach a tha a dhìth oirnn. An ath tha sinn a 'coimhead Clàradh API.

Tha e ag ràdh na leanas:

Tha “ìomhaigh” na mheasgachadh de dh’ fhaidhlichean follaiseach JSON agus faidhlichean còmhdach fa leth.

Mar sin is e a’ chiad cheum a rèir nan sgrìobhainnean “A 'tarraing ìomhaigh ìomhaigh".

Gu dearbh, cha bhith sinn ga losgadh, ach feumaidh sinn an dàta bhuaithe. Tha na leanas mar eisimpleir iarrtas: GET /v2/{name}/manifests/{reference}

msgstr "Sònraichidh an t-ainm agus am paramadair iomraidh an dealbh agus tha feum orra. Faodaidh taga no cnuasachadh a bhith san iomradh."

Tha an stòr docker againn air a chleachdadh gu h-ionadail, feuchaidh sinn ris an iarrtas a chuir an gnìomh:

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

Mar fhreagairt, gheibh sinn json às nach eil ùidh againn an-dràsta ach anns na loidhnichean-teasairginn, no an àite an hashes aca. An dèidh dhuinn am faighinn, is urrainn dhuinn a dhol tro gach fear agus an t-iarrtas a leanas a chuir an gnìomh: "GET /v2/{name}/blobs/{digest}"

“Bidh cothrom air còmhdach air a chuairteachadh le ainm an stòr ach tha e air a chomharrachadh gu h-annasach sa chlàr le bhith a’ cladhach. ”

cnuasachadh anns a' chùis so is e an hash a fhuair sinn.

Feuch sinn

curl -s -X GET "http://localhost:8081/link/to/docker/registry/v2/centos-11-10/blobs/sha256:f972d139738dfcd1519fd2461815651336ee25a8b54c358834c50af094bb262f" -H "header_if_needed" --output firstLayer

Chì sinn dè an seòrsa faidhle a fhuair sinn mu dheireadh mar a’ chiad loidhne-teasairginn.

file firstLayer

iadsan. tha rèilichean nan tasglannan teàrr, gan dì-phapadh san òrdugh iomchaidh gheibh sinn susbaint na h-ìomhaigh.

Sgrìobhamaid sgriobt bash beag gus an tèid seo uile a dhèanamh fèin-ghluasadach

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

A-nis is urrainn dhuinn a ruith leis na paramadairean a tha thu ag iarraidh agus susbaint na h-ìomhaigh a tha a dhìth fhaighinn

./script.sh dirName “http://localhost:8081/link/to/docker/registry” myAwesomeImage 1.0

Pàirt 2 - putadh docker

Bidh seo beagan nas iom-fhillte.

Feuch an tòisich sinn a-rithist le sgrìobhainnean. Mar sin feumaidh sinn gach stiùiriche a luchdachadh sìos, am manifesto iomchaidh a chruinneachadh agus a luchdachadh sìos cuideachd. Tha e coltach gu sìmplidh.

Às deidh dhuinn na sgrìobhainnean a sgrùdadh, is urrainn dhuinn am pròiseas luchdachadh sìos a roinn ann an grunn cheumannan:

Tòiseachadh pròiseas - "POST /v2/{repoName}/blobs/uploads/"
A’ luchdachadh suas loidhne-teasairginn (cleachdaidh sinn luchdachadh suas monolithic, i.e. cuiridh sinn gach loidhne-teasairginn gu h-iomlan) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
Fad susbaint: {meud an t-sreath}
Seòrsa susbaint: tagradh / octet-stream
Dàta dà-thaobhach sreath".
A’ luchdachadh am manifesto - “PUT /v2/{repoName}/manifests/{reference}".

Ach tha na sgrìobhainnean ag ionndrainn aon cheum, às aonais nach obraich dad. Airson luchdachadh monolithic, a bharrachd air pàirt (làn), mus luchdaich thu an rèile, feumaidh tu iarrtas PATCH a dhèanamh:

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
Fad susbaint: {meud a’ phìos}
Seòrsa susbaint: tagradh / octet-stream
{Dàta Dà-chànanach Sreath Chunk}".

Rud eile, cha bhith e comasach dhut gluasad nas fhaide na a’ chiad phuing, oir ... An àite a’ chòd freagairt 202 ris a bheil dùil, gheibh thu 4xx.

A-nis tha an algorithm coltach ri:

Toiseach tòiseachaidh
Rèile paiste
A 'luchdachadh an rèile-làimhe
A luchdachadh a-nuas manifesto
Bidh puingean 2 agus 3, fa leth, air an ath-aithris cho tric ’s a tha an àireamh de loidhnichean a dh’ fheumar a luchdachadh.

An toiseach, feumaidh sinn ìomhaigh sam bith. Cleachdaidh mi archlinux: as ùire

docker pull archlinux

A-nis sàbhail sinn e gu h-ionadail airson tuilleadh sgrùdaidh

docker save c24fe13d37b9 -o savedArch

Unpack an tasglann a thig às a-steach don eòlaire gnàthach

tar xvf savedArch

Mar a chì thu, tha gach loidhne-teasairginn ann am pasgan air leth. A-nis leig dhuinn sùil a thoirt air structar an fhollaiseach a fhuair sinn

cat manifest.json | json_pp

Chan eil mòran. Chì sinn dè am manifesto a tha a dhìth airson a luchdachadh, a rèir sgrìobhainnean.

Gu follaiseach, chan eil am manifesto a th’ ann mar-thà a’ freagairt oirnn, agus mar sin nì sinn sinn fhìn le blackjack agus luchd-cùirte, loidhnichean-teasairginn agus configs.

Bidh co-dhiù aon fhaidhle config againn an-còmhnaidh agus sreath de loidhnichean-teasairginn. Sgeama dreach 2 (an-dràsta aig àm sgrìobhaidh), fàgaidh mediaType gun atharrachadh:

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

Às deidh dhut am foillseachadh bunaiteach a chruthachadh, feumaidh tu a lìonadh le dàta dligheach. Gus seo a dhèanamh, bidh sinn a’ cleachdadh an teamplaid json den nì rèile:

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

Cuiridh sinn e ris a’ chunntas airson gach rèile.

An uairsin, feumaidh sinn faighinn a-mach meud an fhaidhle config agus cuir an àite na stubs anns an fhollaiseach le fìor dhàta

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

A-nis faodaidh tu am pròiseas luchdachadh sìos a thòiseachadh agus uuid a shàbhaladh dhut fhèin, a bu chòir a dhol an cois gach iarrtas às deidh sin.

Tha an sgriobt iomlan a’ coimhead rudeigin mar seo:

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

is urrainn dhuinn sgriobt deiseil a chleachdadh:

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

ÙRACHADH:
Dè fhuair sinn mar thoradh air?
An toiseach, fìor dàta airson mion-sgrùdadh, leis gu bheil na deuchainnean air an ruith ann an blazemeter agus nach eil an dàta air iarrtasan teachdaiche docker gu math fiosrachail, eu-coltach ri iarrtasan HTTP fìor.

San dàrna h-àite, leig an eadar-ghluasad leinn an àireamh de luchd-cleachdaidh brìgheil airson luchdachadh suas docker àrdachadh timcheall air 150% agus ùine freagairt cuibheasachd fhaighinn 20-25% nas luaithe. Airson luchdachadh sìos docker, chaidh againn air an àireamh de luchd-cleachdaidh àrdachadh 500%, agus chaidh ùine freagairt cuibheasach sìos mu 60%.

Tapadh leibh airson ur aire.

Source: www.habr.com

A’ cur an gnìomh òrdughan tarraing docker agus docker gun neach-dèiligidh docker a’ cleachdadh iarrtasan HTTP

Pàirt 2 - putadh docker

Cuir beachd ann freagairt a chur dheth