HTTP ਬੇਨਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੌਕਰ ਕਲਾਇੰਟ ਤੋਂ ਬਿਨਾਂ ਡੌਕਰ ਪੁੱਲ ਅਤੇ ਡੌਕਰ ਪੁਸ਼ ਕਮਾਂਡਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਸਾਡੇ ਕੋਲ ਘਾਹ ਦੇ 2 ਬੈਗ ਸਨ, 75 ਮੇਸਕਲਿਨ ਗੋਲੀਆਂ ਯੂਨਿਕਸ ਵਾਤਾਵਰਣ, ਇੱਕ ਡੌਕਰ ਰਿਪੋਜ਼ਟਰੀ ਅਤੇ ਡੌਕਰ ਕਲਾਇੰਟ ਤੋਂ ਬਿਨਾਂ ਡੌਕਰ ਪੁੱਲ ਅਤੇ ਡੌਕਰ ਪੁਸ਼ ਕਮਾਂਡਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਕੰਮ ਸੀ।

ਯੂਪੀਡੀ:
ਸਵਾਲ: ਇਹ ਸਭ ਕਾਹਦੇ ਲਈ ਹੈ?
ਉੱਤਰ: ਉਤਪਾਦ ਦੀ ਲੋਡ ਟੈਸਟਿੰਗ (ਬੈਸ਼ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ, ਸਕ੍ਰਿਪਟਾਂ ਵਿਦਿਅਕ ਉਦੇਸ਼ਾਂ ਲਈ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ)। ਵਾਧੂ ਲੇਅਰਾਂ (ਵਾਜਬ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ) ਨੂੰ ਘਟਾਉਣ ਲਈ ਡੌਕਰ ਕਲਾਇੰਟ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ, ਇਸਦੇ ਅਨੁਸਾਰ, ਇੱਕ ਉੱਚ ਲੋਡ ਦੀ ਨਕਲ ਕਰੋ। ਨਤੀਜੇ ਵਜੋਂ, ਡੌਕਰ ਕਲਾਇੰਟ ਦੀਆਂ ਸਾਰੀਆਂ ਸਿਸਟਮ ਦੇਰੀਆਂ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਸਾਨੂੰ ਉਤਪਾਦ 'ਤੇ ਸਿੱਧਾ ਇੱਕ ਮੁਕਾਬਲਤਨ ਸਾਫ਼ ਲੋਡ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ।
ਲੇਖ ਵਿੱਚ ਟੂਲਸ ਦੇ GNU ਸੰਸਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ।

ਪਹਿਲਾਂ, ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਇਹ ਕਮਾਂਡਾਂ ਕੀ ਕਰਦੀਆਂ ਹਨ।

ਤਾਂ ਡੌਕਰ ਪੁੱਲ ਕਿਸ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ? ਇਸਦੇ ਅਨੁਸਾਰ ਦਸਤਾਵੇਜ਼:

msgstr "ਰਜਿਸਟਰੀ ਤੋਂ ਇੱਕ ਚਿੱਤਰ ਜਾਂ ਰਿਪੋਜ਼ਟਰੀ ਖਿੱਚੋ।"

ਉੱਥੇ ਸਾਨੂੰ ਇੱਕ ਲਿੰਕ ਵੀ ਮਿਲਦਾ ਹੈ ਚਿੱਤਰਾਂ, ਕੰਟੇਨਰਾਂ ਅਤੇ ਸਟੋਰੇਜ ਡਰਾਈਵਰਾਂ ਨੂੰ ਸਮਝੋ.

ਇੱਥੋਂ ਅਸੀਂ ਸਮਝ ਸਕਦੇ ਹਾਂ ਕਿ ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਕੁਝ ਪਰਤਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਚਿੱਤਰ ਵਿੱਚ ਨਵੀਨਤਮ ਤਬਦੀਲੀਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ, ਜੋ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਾਨੂੰ ਲੋੜੀਂਦੀ ਹੈ। ਅੱਗੇ ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਰਜਿਸਟਰੀ 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 - ਡੌਕਰ ਪੁਸ਼

ਇਹ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੋਵੇਗਾ.

ਦੇ ਨਾਲ ਫਿਰ ਸ਼ੁਰੂ ਕਰੀਏ ਦਸਤਾਵੇਜ਼. ਇਸ ਲਈ ਸਾਨੂੰ ਹਰੇਕ ਲੀਡਰ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ, ਸੰਬੰਧਿਤ ਮੈਨੀਫੈਸਟ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਵੀ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਧਾਰਨ ਲੱਗਦਾ ਹੈ.

ਦਸਤਾਵੇਜ਼ਾਂ ਦਾ ਅਧਿਐਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਡਾਊਨਲੋਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚ ਵੰਡ ਸਕਦੇ ਹਾਂ:

• ਪ੍ਰਕਿਰਿਆ ਦੀ ਸ਼ੁਰੂਆਤ - "ਪੋਸਟ /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