🥇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

HTTP ವಿನಂತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಡಾಕರ್ ಕ್ಲೈಂಟ್ ಇಲ್ಲದೆ ಡಾಕರ್ ಪುಲ್ ಮತ್ತು ಡಾಕರ್ ಪುಶ್ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ಭಾಗ 2 - ಡಾಕರ್ ಪುಶ್

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ