🥇 Orduithe tarraingthe duga agus brú do dhugairí a chur i bhfeidhm gan cliant duga ag baint úsáide as iarratais HTTP

Bhí 2 mhála féir againn, 75 táibléad mescaline timpeallacht unix, stór dugaí agus an tasc na horduithe tarraingthe duga agus brú duga a chur i bhfeidhm gan cliant duga.

Suas chun dáta:
Ceist: Cén fáth atá leis seo?
Freagra: Tástáil luchtaithe ar an táirge (NACH n-úsáidtear bash, soláthraítear na scripteanna chun críocha oideachais). Socraíodh gan an cliant docker a úsáid chun sraitheanna breise a laghdú (laistigh de theorainneacha réasúnta) agus, dá réir sin, aithris a dhéanamh ar ualach níos airde. Mar thoradh air sin, baineadh gach moill chórais de chuid cliant Docker. Fuair muid ualach sách glan go díreach ar an táirge.
Bhain an t-alt úsáid as leaganacha GNU d’uirlisí.

Ar dtús, déanaimis a dhéanamh amach cad a dhéanann na horduithe seo.

Mar sin cad a úsáidtear tarraingt docker? De réir doiciméadú:

msgstr "Tarraing íomhá nó stór as clárlann".

Faighimid ansin nasc chuig íomhánna, coimeádáin, agus tiománaithe stórála a thuiscint.

Ón áit seo is féidir linn a thuiscint gur sraith de shraitheanna áirithe é íomhá docker ina bhfuil faisnéis faoi na hathruithe is déanaí ar an íomhá, agus is léir gurb é sin an méid a theastaíonn uainn. Ar aghaidh táimid ag Clárlann API.

Deir sé an méid seo a leanas:

"Is éard is "íomhá" ann teaglaim de shainchomhad JSON agus de chomhaid sraitheanna aonair. Díríonn an próiseas chun íomhá > a tharraingt ar an dá chomhpháirt seo a aisghabháil."

Mar sin is í an chéad chéim de réir an doiciméid ná “Ag tarraingt ar Manifest Íomhá".

Ar ndóigh, ní scaoilfimid é, ach ní mór dúinn na sonraí uaidh. Seo a leanas iarratas samplach: GET /v2/{name}/manifests/{reference}

msgstr "Aithníonn an t-ainm agus an paraiméadar tagartha an íomhá agus tá siad ag teastáil. Féadfaidh clib nó achoimre a bheith sa tagairt."

Tá ár stór docker imlonnaithe go háitiúil, déanaimis iarracht an t-iarratas a rith:

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

Mar fhreagra air sin, faightear json as nach bhfuil suim againn faoi láthair ach sna línte tarrthála, nó in áit a gcuid hashes. Tar éis dúinn iad a fháil, is féidir linn dul trí gach ceann acu agus an t-iarratas seo a leanas a dhéanamh: "GET /v2/{name}/blobs/{digest}"

“Beidh rochtain ar shraith faoi réir ainm an taisc ach sainaithnítear é go huathúil sa chlár trí achoimre.”

díolama sa chás seo ná an hash a fuaireamar.

Déanaimis iarracht

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

Feicfimid cén cineál comhaid a fuair muid ar deireadh mar an chéad líne tarrthála.

file firstLayer

siúd. Is cartlanna tarra iad ráillí, agus iad á ndíphacáil san ord cuí gheobhaidh muid ábhar na híomhá.

Scríobhaimis script bheag bash ionas gur féidir é seo go léir a uathoibriú

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

Anois is féidir linn é a rith leis na paraiméadair atá ag teastáil agus a fháil ar an ábhar ar an íomhá riachtanach

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

Cuid 2 - bhrú docker

Beidh sé seo beagán níos casta.

Let tús arís le doiciméadú. Mar sin ní mór dúinn gach ceannaire a íoslódáil, an forléiriú comhfhreagrach a bhailiú agus é a íoslódáil freisin. Dealraíonn sé simplí.

Tar éis dúinn staidéar a dhéanamh ar an doiciméadú, is féidir linn an próiseas íoslódála a roinnt ina roinnt céimeanna:

Tús a chur le próiseas - "POST /v2/{repoName}/blobs/uploads/"
Líne tarrthála á uaslódáil (úsáidfimid uaslódáil mhonailiteach, i.e. seolfaimid gach líne tarrthála ina iomláine) - "PUT /v2/{repoName}/blobs/uploads/{uuid}?digest={digest}
Ábhar-Fad: {méid na ciseal}
Cineál Ábhar: feidhmchlár/sruth octet
Sonraí Dénártha Ciseal".
Manifests á lódáil - "PUT /v2/{repoName}/manifests/{reference}".

Ach cailleann an doiciméadú céim amháin, gan a mbeidh aon rud ag obair. Le haghaidh luchtú monolithic, chomh maith le cuid (puntáilte), sula luchtú an iarnróid, ní mór duit iarratas PATCH a dhéanamh:

"PATCH /v2/{repoName}/blobs/uploads/{uuid}
Ábhar-Fad: {méid an smutáin}
Cineál Ábhar: feidhmchlár/sruth octet
{Sonraí Dénártha Chunc Ciseal}".

Seachas sin, ní bheidh tú in ann bogadh níos faide ná an chéad phointe, mar gheall ar ... In ionad an chóid freagartha ionchais 202, gheobhaidh tú 4xx.

Anois tá cuma ar an algartam:

Tionscnamh
Iarnród paiste
An ráille láimhe á lódáil
An léiriú á lódáil
Déanfar pointí 2 agus 3, faoi seach, a athdhéanamh chomh minic agus is gá líon na línte a luchtú.

Gcéad dul síos, ní mór dúinn aon íomhá. Úsáidfidh mé archlinux: is déanaí

docker pull archlinux

Anois déanaimis é a shábháil go háitiúil le haghaidh tuilleadh anailíse

docker save c24fe13d37b9 -o savedArch

Díphacáil an chartlann mar thoradh air sa chomhadlann reatha

tar xvf savedArch

Mar a fheiceann tú, tá gach líne tarrthála i bhfillteán ar leith. Anois féachaimis ar struchtúr an léiriúcháin a fuaireamar

cat manifest.json | json_pp

Ní mórán. A ligean ar a fheiceáil cad a léiriú is gá a luchtú, de réir doiciméadú.

Ar ndóigh, ní oireann an forógra reatha dúinn, mar sin déanfaimid ár gceann féin le blackjack agus cúirtéis, línte tarrthála agus cumraíochtaí.

Beidh ar a laghad comhad cumraíochta amháin againn i gcónaí agus raon de línte tarrthála. Leagan scéime 2 (reatha agus é seo á scríobh), ní dhéanfar aon athrú ar an gcineál meáin:

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

Tar éis duit an léiriú bunúsach a chruthú, ní mór duit é a líonadh le sonraí bailí. Chun seo a dhéanamh, úsáidimid an teimpléad json den réad iarnróid:

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

Cuirfimid é leis an léiriú do gach iarnród.

Ansin, ní mór dúinn méid an chomhaid cumraíochta a fháil amach agus na stubs sa léiriú a athsholáthar le sonraí fíor

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

Anois is féidir leat tús a chur leis an bpróiseas íoslódála agus uuid a shábháil duit féin, ba chóir a bheith in éineacht le gach iarratas ina dhiaidh sin.

Breathnaíonn an script iomlán rud éigin 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 féidir linn script réidh a úsáid:

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

Suas chun dáta:
Cad a fuair muid mar thoradh air?
Ar an gcéad dul síos, fíor-shonraí le haghaidh anailíse, ós rud é go ndéantar na tástálacha a reáchtáil i blazemeter agus nach bhfuil na sonraí ar iarratais cliant docker an-fhaisnéiseach, murab ionann agus iarratais HTTP íon.

Ar an dara dul síos, cheadaigh an t-aistriú dúinn líon na n-úsáideoirí fíorúla le haghaidh uaslódáil docker a mhéadú thart ar 150% agus meán-am freagartha a fháil 20-25% níos tapúla. Le híoslódáil docker, d’éirigh linn líon na n-úsáideoirí a mhéadú 500%, agus tháinig laghdú thart ar 60% ar an am freagartha meánlíon.

Go raibh maith agat as do aird.

Foinse: will.com

Orduithe tarraingthe docker agus brú docker a chur i bhfeidhm gan cliant docker ag baint úsáide as iarratais HTTP

Cuid 2 - bhrú docker

Add a comment Cealaigh freagra