Registry და დისტრიბუცია

ისწავლეთ Docker-ის registry-ების, image-ების დისტრიბუციისა და რეპოზიტორიების მართვის შესახებ

დავით მაჭახელიძე
@devius

Docker Registry

Docker registry არის Docker image-ების შენახვისა და დისტრიბუციის სპეციალიზებული სისტემა. ის ფუნქციონირებს როგორც ცენტრალიზებული რეპოზიტორი, სადაც კონტეინერის image-ები შეიძლება შეინახოს, ვერსიონირდეს და გაზიარდეს სხვადასხვა სისტემებსა და მომხმარებლებს შორის. მყარი registry გადაწყვეტა საშუალებას გაძლევთ:

  • შეინახოთ Docker image-ები უსაფრთხოდ ვერსიების კონტროლით
  • ეფექტურად გაავრცელოთ image-ები development, testing და production გარემოებში
  • მართოთ image-ების ვერსიები თეგირებითა და მეტამონაცემებით
  • აკონტროლოთ წვდომა image-ებზე ავთენტიფიკაციისა და ავტორიზაციის მექანიზმებით
  • თვალყური ადევნოთ image-ების მოწყვლადობებს და აღასრულოთ უსაფრთხოების პოლიტიკები
  • მოახდინოთ საცავის ოპტიმიზაცია image-ის ფენების დედუპლიკაციით

Registry-ების ტიპები

Docker Hub

  • საჯარო registry სერვისი, რომელსაც მართავს Docker, Inc.
  • უფასო პაკეტი საჯარო რეპოზიტორიებისთვის შეზღუდული ლიმიტებით (100/200 pull-ი 6 საათში ანონიმური/ავთენტიფიცირებული მომხმარებლებისთვის)
  • სააბონენტო გეგმები კერძო რეპოზიტორიებისა და უფრო მაღალი ლიმიტებისთვის
  • ოფიციალური image-ები, რომლებსაც ინახავს Docker-ი და დამოწმებული გამომცემლები სანდო კონტენტისთვის
  • ავტომატიზებული build-ები, რომლებიც გამოწვეულია დაკავშირებულ რეპოზიტორიებში საწყისი კოდის ცვლილებებით
  • Webhook-ები CI/CD მილსადენებთან და სხვა სისტემებთან ინტეგრაციისთვის
  • მოწყვლადობის სკანირება image-ებში უსაფრთხოების პრობლემების გამოსავლენად
  • გუნდის მართვა ერთობლივი development-ისთვის

კერძო Registry

  • თვით-ჰოსტირებული გადაწყვეტა თქვენს საკუთარ ინფრასტრუქტურაში
  • სრული კონტროლი მონაცემთა მდებარეობაზე, შენახვისა და უსაფრთხოების პოლიტიკებზე
  • ქსელის იზოლაციის შესაძლებლობები air-gapped ან მაღალი უსაფრთხოების გარემოებისთვის
  • ინტეგრაცია შიდა სისტემებთან, როგორიცაა LDAP/Active Directory
  • მორგებადი საცავის backend-ები (filesystem, S3, Azure Blob და ა.შ.)
  • დეტალური წვდომის კონტროლის პოლიტიკები
  • გარე ლიმიტებისა და სააბონენტო გადასახადების გარეშე
  • აუდიტის ლოგირება შესაბამისობისა და უსაფრთხოების თვალყურის დევნებისთვის
  • მორგებული ვალიდაციისა და უსაფრთხოების პოლიტიკების დანერგვის შესაძლებლობა

ღრუბლოვანი პროვაიდერების Registry-ები

  • AWS Elastic Container Registry (ECR)
    • მშობლიური ინტეგრაცია AWS IAM-თან წვდომის კონტროლისთვის
    • სასიცოცხლო ციკლის პოლიტიკები ავტომატური გასუფთავებისთვის
    • რეგიონებს შორის რეპლიკაცია გაუმჯობესებული ხელმისაწვდომობისთვის
    • Image-ების სკანირება Amazon ECR-ით და ინტეგრაცია Amazon Inspector-თან
  • Google Container Registry (GCR) / Artifact Registry
    • ინტეგრაცია Google Cloud IAM-თან
    • ჩაშენებული მოწყვლადობის სკანირება
    • გლობალური ხელმისაწვდომობა რეგიონალური საცავით
    • ინტეგრაცია Google Cloud Build-თან
  • Azure Container Registry (ACR)
    • გეო-რეპლიკაცია Azure რეგიონებში
    • ინტეგრაცია Azure Active Directory-სთან
    • WebHook-ები build-ისა და deployment-ის ავტომატიზაციისთვის
    • Premium პაკეტი გთავაზობთ გაძლიერებულ გამტარუნარიანობასა და მასშტაბირებადობას
  • Digital Ocean Container Registry
    • ინტეგრაცია Digital Ocean Kubernetes-თან
    • რეგიონალური საცავის ოფციები
    • მარტივი ფასების მოდელი
  • GitHub Container Registry (GHCR)
    • მჭიდრო ინტეგრაცია GitHub Actions-თან
    • დეტალური უფლებები, რომლებიც შეესაბამება GitHub-ის მოდელს
    • ანონიმური წვდომა საჯარო image-ებისთვის
    • OCI არტეფაქტების მხარდაჭერა კონტეინერის image-ების მიღმა

Docker Hub-თან მუშაობა

Docker Hub არის Docker-ის ნაგულისხმევი registry, რომელიც გთავაზობთ მარტივ სამუშაო პროცესს image-ების შესანახად და გასაზიარებლად:

# Docker Hub-ში შესვლა (რწმუნებათა სიგელები ინახება ~/.docker/config.json-ში)
docker login
# კონკრეტული registry-სთვის: docker login registry-address

# image-ის ჩამოტვირთვა (ფორმატი: [registry/]repository[:tag])
docker pull nginx:latest
# კონკრეტული ვერსია
docker pull nginx:1.21.6-alpine
# სხვა registry-დან
docker pull mcr.microsoft.com/dotnet/aspnet:6.0

# image-ის თეგირება თქვენი რეპოზიტორიისთვის
# ფორმატი: docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
docker tag my-app:latest username/my-app:latest
# ვერსიის თეგის დამატება
docker tag my-app:latest username/my-app:v1.0.3
# მრავალი თეგი ერთი და იგივე image-ისთვის
docker tag my-app:latest username/my-app:stable

# Docker Hub-ზე ატვირთვა
docker push username/my-app:latest
# ყველა თეგის ატვირთვა
docker push --all-tags username/my-app

# image-ების ძებნა
docker search nginx
# ფილტრით
docker search --filter=stars=100 nginx
# შედეგების შეზღუდვა
docker search --limit=5 nginx

Docker Hub-თან მუშაობისას გაითვალისწინეთ:

  • pull-ების ლიმიტები (განსაკუთრებით CI/CD გარემოში)
  • image-ზე წვდომის კონტროლი (საჯარო vs. კერძო)
  • ორგანიზაციის ანგარიშები გუნდური თანამშრომლობისთვის
  • ავტომატიზებული build-ები განახლებული image-ების შესანარჩუნებლად

კერძო Registry-ს დაყენება

Image-ების დისტრიბუციის სტრატეგიები

თქვენი Registry-ს დაცვა

სათანადო უსაფრთხოება აუცილებელია ნებისმიერი Docker registry-სთვის, განსაკუთრებით production გარემოში.

ძირითადი ავთენტიფიკაცია

ძირითადი ავთენტიფიკაცია უზრუნველყოფს მარტივ მომხმარებლის სახელისა და პაროლის დაცვას თქვენი registry-სთვის:

# auth დირექტორიის შექმნა
mkdir -p auth

# მომხმარებლის შექმნა BCrypt ჰეშირებით (უფრო უსაფრთხოა, ვიდრე ნაგულისხმევი)
docker run --rm --entrypoint htpasswd \
  httpd:2 -Bbn username password > auth/htpasswd

# დამატებითი მომხმარებლების დამატება
docker run --rm --entrypoint htpasswd \
  httpd:2 -Bbn another-user another-password >> auth/htpasswd

# registry-ს გაშვება ავთენტიფიკაციით
docker run -d \
  -p 5000:5000 \
  --name registry \
  -v "$(pwd)"/auth:/auth \
  -v "$(pwd)"/registry-data:/var/lib/registry \
  -e "REGISTRY_AUTH=htpasswd" \
  -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \
  -e "REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd" \
  registry:2

# კლიენტის ავთენტიფიკაცია push/pull-ისას
docker login localhost:5000

ავთენტიფიკაცია ასევე შეიძლება ინტეგრირდეს LDAP, OAuth, ან სხვა გარე პროვაიდერებთან საწარმოო გარემოსთვის.

TLS კონფიგურაცია

TLS დაშიფვრა კრიტიკულია registry-ს კომუნიკაციების დასაცავად:

# თვით-ხელმოწერილი სერტიფიკატების გენერირება (მხოლოდ ტესტირებისთვის)
mkdir -p certs
openssl req -newkey rsa:4096 -nodes -sha256 \
  -keyout certs/domain.key -x509 -days 365 \
  -out certs/domain.crt \
  -subj "/CN=localhost"

# production-ისთვის გამოიყენეთ სათანადოდ ხელმოწერილი სერტიფიკატები სანდო CA-სგან
# თუ იყენებთ Let's Encrypt-ს:
# certbot certonly --standalone -d registry.example.com

# registry-ს გაშვება TLS-ით
docker run -d \
  -p 443:5000 \
  --name registry \
  -v "$(pwd)"/certs:/certs \
  -v "$(pwd)"/registry-data:/var/lib/registry \
  -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key \
  registry:2

# სერტიფიკატის კოპირება Docker-ის სანდო საცავში (თვით-ხელმოწერილი სერტიფიკატებისთვის)
mkdir -p /etc/docker/certs.d/localhost:443
cp certs/domain.crt /etc/docker/certs.d/localhost:443/ca.crt

საცავის კონფიგურაცია

დააკონფიგურეთ backend საცავის ოფციები production-დონის registry deployment-ისთვის:

# კონფიგურაციის ფაილის შექმნა
cat > config.yml << EOF
version: 0.1
log:
  level: info
storage:
  filesystem:
    rootdirectory: /var/lib/registry
  delete:
    enabled: true
http:
  addr: :5000
  headers:
    X-Content-Type-Options: [nosniff]
auth:
  htpasswd:
    realm: Registry Realm
    path: /auth/htpasswd
EOF

# S3 საცავის backend-ისთვის
cat > config-s3.yml << EOF
version: 0.1
storage:
  s3:
    accesskey: AKIAIOSFODNN7EXAMPLE
    secretkey: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
    region: us-west-1
    bucket: docker-registry
    encrypt: true
    secure: true
EOF

# registry-ს კონფიგურაცია საცავის backend-ით
docker run -d \
  -p 5000:5000 \
  --name registry \
  -v "$(pwd)"/config.yml:/etc/docker/registry/config.yml \
  -v "$(pwd)"/auth:/auth \
  registry:2

წვდომის კონტროლი

უფრო გაფართოებული წვდომის კონტროლისთვის:

# როლზე დაფუძნებული წვდომის კონტროლის კონფიგურაციის მაგალითი
cat > config-rbac.yml << EOF
version: 0.1
auth:
  token:
    realm: https://auth.example.com/token
    service: registry.example.com
    issuer: auth-service
    rootcertbundle: /etc/registry/auth-service.crt
EOF

# გაშვება RBAC კონფიგურაციით
docker run -d \
  -p 5000:5000 \
  --name registry \
  -v "$(pwd)"/config-rbac.yml:/etc/docker/registry/config.yml \
  -v "$(pwd)"/auth-service.crt:/etc/registry/auth-service.crt \
  registry:2

Registry API

Docker Registry HTTP API უზრუნველყოფს პროგრამულ წვდომას registry-ს ოპერაციებზე. ეს RESTful API საშუალებას გაძლევთ მოითხოვოთ, მართოთ და იმოქმედოთ registry-ს მონაცემებთან Docker CLI-ს გამოყენების გარეშე.

# რეპოზიტორიების სია (პაგინაციით)
curl -X GET https://registry:5000/v2/_catalog
curl -X GET https://registry:5000/v2/_catalog?n=100  # 100 შედეგამდე შეზღუდვა

# რეპოზიტორიის თეგების სია (პაგინაციით)
curl -X GET https://registry:5000/v2/repository-name/tags/list
curl -X GET https://registry:5000/v2/repository-name/tags/list?n=20  # 20 თეგამდე შეზღუდვა

# შეამოწმეთ, არსებობს თუ არა image-ი
curl -I -X HEAD https://registry:5000/v2/repository-name/manifests/tag

# image-ის მანიფესტის მიღება (v2 სქემა)
curl -H "Accept: application/vnd.docker.distribution.manifest.v2+json" \
  https://registry:5000/v2/repository-name/manifests/tag

# image-ის დაიჯესტის მიღება
curl -H "Accept: application/vnd.docker.distribution.manifest.v2+json" \
  -I -X HEAD https://registry:5000/v2/repository-name/manifests/tag | grep Docker-Content-Digest

# image-ის წაშლა (მოითხოვს delete-ის ჩართვას registry-ს კონფიგურაციაში)
# ჯერ მიიღეთ დაიჯესტი, შემდეგ:
curl -X DELETE https://registry:5000/v2/repository-name/manifests/sha256:digest-value

# ფენის ინფორმაციის მიღება
curl -X GET https://registry:5000/v2/repository-name/blobs/sha256:layer-digest

# ავთენტიფიკაციით
curl -u username:password -X GET https://registry:5000/v2/_catalog

# ტოკენის ავთენტიფიკაციის გამოყენება
TOKEN=$(curl -u username:password https://auth.example.com/token?service=registry.example.com | jq -r .token)
curl -H "Authorization: Bearer $TOKEN" https://registry:5000/v2/_catalog

Registry API იძლევა ავტომატიზაციის საშუალებას:

  • CI/CD მილსადენებისთვის, რომლებსაც სჭირდებათ image-ის არსებობის შემოწმება
  • მორგებული ინტერფეისებისა და მართვის ინსტრუმენტებისთვის
  • Registry-ს მიგრაციის სკრიპტებისთვის
  • ავტომატიზებული გასუფთავებისა და მოვლისთვის
  • სხვა სისტემებთან ინტეგრაციისთვის

მესამე მხარის Registry ოფციები

ძირითადი Docker Registry-ს გარდა, ხელმისაწვდომია მრავალი სპეციალიზებული registry გადაწყვეტა:

ღრუბლოვანი პროვაიდერების Registry-ები

  • Amazon Elastic Container Registry (ECR)
    • ღრმად ინტეგრირებულია AWS სერვისებთან (ECS, EKS, Lambda)
    • კერძო რეპოზიტორიები IAM ავთენტიფიკაციით
    • სასიცოცხლო ციკლის პოლიტიკები ავტომატიზებული image-ების გასუფთავებისთვის
    • მოწყვლადობის სკანირება Amazon Inspector-ით
    • რეგიონებსა და ანგარიშებს შორის რეპლიკაცია
    • გადაიხადე-გამოყენებისამებრ ფასების მოდელი
  • Google Container Registry (GCR) / Artifact Registry
    • მშობლიური ინტეგრაცია Google Cloud Build-თან და GKE-სთან
    • ავტომატური მოწყვლადობის სკანირება
    • IAM წვდომის კონტროლი და აუდიტის ლოგირება
    • რეგიონალური საცავი გლობალური წვდომით
    • Docker, OCI და ენაზე-სპეციფიური პაკეტების მხარდაჭერა
    • შენახვის ფასი + მონაცემთა გადაცემის ხარჯები
  • Azure Container Registry (ACR)
    • ინტეგრირებულია Azure DevOps-თან და AKS-თან
    • Premium პაკეტი გეო-რეპლიკაციით
    • ავტომატიზებული build-ები Tasks-ით
    • Content trust image-ების ხელმოწერისთვის
    • იარუსიანი ფასები (Basic, Standard, Premium)
    • Webhook-ების მხარდაჭერა build-ისა და deployment-ის ავტომატიზაციისთვის
  • DigitalOcean Container Registry
    • მარტივი ინტეგრაცია DO Kubernetes-თან
    • პირდაპირი ფასები შენახვის იარუსების მიხედვით
    • გლობალური ხელმისაწვდომობა
    • ინტეგრირებული მოწყვლადობის სკანირება

თვით-ჰოსტირებული გადაწყვეტილებები

  • Harbor
    • ღია კოდის, საწარმოზე-ორიენტირებული registry
    • როლზე დაფუძნებული წვდომის კონტროლი
    • პოლიტიკაზე დაფუძნებული image-ების რეპლიკაცია
    • მოწყვლადობის სკანირების ინტეგრაცია
    • Image-ების ხელმოწერა და ვერიფიკაცია
    • მრავალი registry-სა და Helm chart-ების მხარდაჭერა
    • WebHook-ები მოვლენების შეტყობინებისთვის
    • აუდიტის ლოგირება შესაბამისობისთვის
  • Nexus Repository
    • მრავალ-ფორმატიანი არტეფაქტების მართვა (არა მხოლოდ Docker)
    • მხარდაჭერა npm, Maven, NuGet, PyPI და ა.შ.
    • როლზე დაფუძნებული წვდომის კონტროლი
    • კომპონენტების სასიცოცხლო ციკლის მართვა
    • რეპოზიტორიის ჯანმრთელობის შემოწმება
    • ხელმისაწვდომია უფასო OSS და კომერციულ გამოცემებში
    • დისტანციური რეპოზიტორიების პროქსირება და ქეშირება
  • JFrog Artifactory
    • უნივერსალური არტეფაქტების მართვის პლატფორმა
    • მაღალი ხელმისაწვდომობის კონფიგურაცია
    • გაფართოებული უსაფრთხოების ფუნქციები
    • მეტამონაცემებზე დაფუძნებული ძებნა
    • Build-ის ინტეგრაცია
    • ვრცელი REST API
    • კომერციული შეთავაზება საწარმოო მხარდაჭერით
    • რეპლიკაციისა და ფედერაციის შესაძლებლობები
  • GitLab Container Registry
    • ინტეგრირებულია GitLab CI/CD-სთან
    • ჩაშენებულია GitLab-ის ინსტალაციებში
    • პროექტზე დაფუძნებული უფლებები
    • მოწყვლადობის სკანირება
    • Image-ების გასუფთავების პოლიტიკები
    • არ საჭიროებს დამატებით კონფიგურაციას GitLab-თან

Image-ების ხელმოწერა და სანდოობა

Image-ების ხელმოწერა უზრუნველყოფს კონტეინერის image-ების ავთენტურობასა და მთლიანობას. Docker Content Trust (DCT) იძლევა როგორც გამომცემლის, ასევე image-ების შინაარსის ვერიფიკაციის საშუალებას.

# Docker Content Trust-ის გლობალურად ჩართვა (ასევე შეიძლება დაყენდეს თითოეულ ბრძანებაზე)
export DOCKER_CONTENT_TRUST=1

# ხელმოწერის გასაღებების გენერირება (პირველადი დაყენება)
docker trust key generate my-signing-key

# საკუთარი თავის ხელმომწერად დამატება რეპოზიტორიისთვის
docker trust signer add --key my-signing-key.pub my-name username/image

# image-ის ხელმოწერა push-ის დროს (ავტომატურად ხდება DCT-ს ჩართვისას)
docker push username/image:tag

# სანდო მონაცემებისა და ვერიფიკაციის სტატუსის ნახვა
docker trust inspect username/image:tag

# ხელმომწერის დეტალური ინფორმაციის ნახვა
docker trust inspect --pretty username/image:tag

# ხელმოწერების გაუქმება
docker trust revoke username/image:tag

# image-ებთან მუშაობა ვერიფიკაციის გარეშე დროებით
DOCKER_CONTENT_TRUST=0 docker pull username/image:untrusted-tag

საწარმოო გარემოსთვის:

  • დანერგეთ Notary გაფართოებული ხელმოწერის სამუშაო პროცესებისთვის
  • დააყენეთ უსაფრთხო ოფლაინ root გასაღები
  • დაადგინეთ გასაღებების როტაციის პოლიტიკა
  • დააკონფიგურეთ CI/CD სისტემები image-ების ავტომატურად ხელმოსაწერად
  • ინტეგრაცია მოახდინეთ მოწყვლადობის სკანირებასთან, რათა ხელი მოეწეროს მხოლოდ უსაფრთხო image-ებს
  • გამოიყენეთ admission controller-ები Kubernetes-ში ხელმოწერების ვერიფიკაციისთვის

DCT ქმნის ორი ტიპის გასაღებს:

  1. Root გასაღები: მთავარი გასაღები, რომელიც უსაფრთხოდ უნდა ინახებოდეს ოფლაინ
  2. რეპოზიტორიის გასაღებები: გამოიყენება კონკრეტული რეპოზიტორიების ხელმოსაწერად

ჩართვისას, Docker-ი ჩამოტვირთავს მხოლოდ ხელმოწერილ image-ებს დამოწმებული ხელმოწერებით.

Registry-ს ნაგვის შეგროვება

Registry-ს კონფიგურაცია

Docker Registry ძალიან კონფიგურირებადია მისი config.yml ფაილის საშუალებით. ქვემოთ მოცემულია ანოტირებული მაგალითი გავრცელებული კონფიგურაციის ოფციებით:

version: 0.1
log:
  level: info  # ოფციები: error, warn, info, debug
  formatter: json  # ოფციები: text, json
  fields:
    service: registry
    environment: production

storage:
  # ფაილური სისტემის საცავის დრაივერი
  filesystem:
    rootdirectory: /var/lib/registry
  # წაშლის ჩართვა (აუცილებელია ნაგვის შეგროვებისთვის)
  delete:
    enabled: true
  # ქეშის კონფიგურაცია
  cache:
    blobdescriptor: inmemory
  # საცავის მოვლის ოფციები
  maintenance:
    uploadpurging:
      enabled: true
      age: 168h
      interval: 24h
      dryrun: false
  # საცავის კვოტის მართვა
  redirect:
    disable: false
  # ალტერნატივა: S3 საცავი
  # s3:
  #   accesskey: AKIAIOSFODNN7EXAMPLE
  #   secretkey: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
  #   region: us-west-1
  #   bucket: docker-registry
  #   encrypt: true
  #   secure: true
  #   v4auth: true
  #   chunksize: 5242880
  #   multipartcopychunksize: 33554432
  #   multipartcopymaxconcurrency: 100
  #   multipartcopythresholdsize: 33554432

http:
  addr: :5000
  # TLS კონფიგურაცია
  tls:
    certificate: /certs/domain.crt
    key: /certs/domain.key
  headers:
    X-Content-Type-Options: [nosniff]
  # სიჩქარის შეზღუდვა
  host: https://registry.example.com
  # მოთხოვნის таймаутები
  timeout: 1h
  # CORS პარამეტრები ბრაუზერიდან წვდომისთვის
  http2:
    disabled: false

auth:
  # ძირითადი ავთენტიფიკაცია htpasswd-ით
  htpasswd:
    realm: Registry Realm
    path: /auth/htpasswd
  # ალტერნატივა: ტოკენზე დაფუძნებული ავთენტიფიკაცია
  # token:
  #   realm: https://auth.example.com/token
  #   service: registry.example.com
  #   issuer: auth-service
  #   rootcertbundle: /etc/registry/auth.crt

middleware:
  registry:
    - name: repository
      options:
        allow:
          - "^approved/.*$"
        
# მეტრიკების რეპორტინგი
reporting:
  bugsnag:
    apikey: XYZ123EXAMPLE
    releasestage: production
    endpoint: https://notify.bugsnag.com

# Redis განაწილებული ბლოკირებისა და ქეშირებისთვის
redis:
  addr: redis:6379
  password: secret
  db: 0
  dialtimeout: 10ms
  readtimeout: 10ms
  writetimeout: 10ms
  pool:
    maxidle: 16
    maxactive: 64
    idletimeout: 300s

# მოვლენების შეტყობინებები (webhooks)
notifications:
  endpoints:
    - name: webhook
      url: http://webhook-service:8000/notify
      headers:
        Authorization: [Bearer <token>]
      timeout: 500ms
      threshold: 5
      backoff: 1s
      ignoredmediatypes:
        - application/octet-stream
      ignore:
        mediatypes:
          - application/octet-stream
        actions:
          - pull

გავრცელებული კონფიგურაციის გამოყენების შემთხვევები:

  1. მაღალი ხელმისაწვდომობის დაყენება: დააკონფიგურირეთ registry-ს მრავალი ინსტანცია გაზიარებული საცავით
  2. წარმადობის ოპტიმიზაცია: დაარეგულირეთ ქეშის პარამეტრები და დანერგეთ Redis
  3. უსაფრთხოების გამკაცრება: დააკონფიგურირეთ TLS, ავთენტიფიკაცია და ავტორიზაცია
  4. საცავის მართვა: დააყენეთ კვოტები, ნაგვის შეგროვება და საცავის დრაივერები
  5. ინტეგრაცია: დააკონფიგურირეთ webhook-ები მოვლენების შეტყობინებისთვის
  6. შესაბამისობა: ჩართეთ აუდიტის ლოგირება და წვდომის კონტროლი

საუკეთესო პრაქტიკები

ამ საუკეთესო პრაქტიკების დანერგვა დაგეხმარებათ თქვენი კონტეინერის registry-ს ეფექტურად და უსაფრთხოდ მართვაში:

თეგირების სტრატეგია

  • გამოიყენეთ სემანტიკური ვერსიონირება (SemVer)
    • ფორმატი: MAJOR.MINOR.PATCH (მაგ., 1.2.3)
    • MAJOR: მსხვრევადი ცვლილებები
    • MINOR: ახალი ფუნქციები, უკუთავსებადი
    • PATCH: შეცდომების გასწორება, უკუთავსებადი
  • ჩართეთ build-ის ინფორმაცია
    • დაამატეთ build-ის ნომრები ან დროის ნიშნულები
    • ფორმატის მაგალითები:
      • 1.2.3-build.456
      • 1.2.3-20230415.1
      • 1.2.3-alpha.1, 1.2.3-beta.2, 1.2.3-rc.1
  • არასდროს გამოიყენოთ "latest" production-ში
    • "latest" ცვალებადია და არაპროგნოზირებადი
    • ართულებს ან შეუძლებელს ხდის rollback-ებს
    • ართულებს აუდიტსა და ვერსიონირებას
    • ბუნდოვანს ხდის, რომელი ვერსია მუშაობს რეალურად
  • დაათეგეთ git commit ჰეშებით
    • უზრუნველყოფს პირდაპირ მიკვლევადობას საწყის კოდამდე
    • ფორმატის მაგალითი: 1.2.3-a7ff23e
    • სასარგებლოა კონკრეტული ვერსიების დებაგინგისთვის
    • შეიძლება ავტომატიზირდეს CI/CD მილსადენებში
  • განიხილეთ დაიჯესტის მითითებების გამოყენება
    • უცვლელი და ხელყოფისგან დაცული
    • ფორმატი: image@sha256:digest
    • გარანტიას იძლევა image-ის ზუსტ შინაარსზე
    • შეიძლება გამოყენებულ იქნას მოწყვლადობის სკანერებთან
    • საუკეთესოა უსაფრთხოება-კრიტიკული deployment-ებისთვის
  • დანერგეთ თეგების სასიცოცხლო ციკლის პოლიტიკები
    • მოახდინეთ ძველი თეგების გასუფთავების ავტომატიზაცია
    • შეინარჩუნეთ მნიშვნელოვანი ისტორიული ვერსიები
    • დაადოკუმენტირეთ შენახვის პოლიტიკები

უსაფრთხოება

  • რეგულარული მოწყვლადობის სკანირება
    • ინტეგრაცია მოახდინეთ სკანერებთან, როგორიცაა Trivy, Clair, ან Anchore
    • დაბლოკეთ მოწყვლადი image-ების deployment-ი
    • დააკონფიგურირეთ არსებული image-ების დაგეგმილი ხელახალი სკანირება
    • თვალყური ადევნეთ CVE-ებს და დააპატჩეთ დაზარალებული image-ები
  • Image-ების ხელმოწერა
    • დანერგეთ Docker Content Trust
    • გამოიყენეთ Notary გაფართოებული ხელმოწერის სამუშაო პროცესებისთვის
    • აღასრულეთ ხელმოწერის ვერიფიკაცია pull-ისას
    • შეინახეთ root გასაღებები უსაფრთხოდ ოფლაინ
    • პერიოდულად მოახდინეთ ხელმოწერის გასაღებების როტაცია
  • წვდომის კონტროლი
    • დანერგეთ მინიმალური პრივილეგიების პრინციპი
    • გამოიყენეთ namespace-ები პროექტების იზოლაციისთვის
    • დააკონფიგურირეთ როლზე დაფუძნებული წვდომის კონტროლი
    • რეგულარულად ჩაატარეთ მომხმარებლის წვდომის აუდიტი
    • დანერგეთ დამტკიცების სამუშაო პროცესები მგრძნობიარე რეპოზიტორიებისთვის
  • აუდიტის ლოგირება
    • დალოგეთ registry-ს ყველა ოპერაცია
    • დააფიქსირეთ ვინ, რა, როდის ინფორმაცია
    • შეინახეთ ლოგები უსაფრთხოდ და უცვლელად
    • დააყენეთ შეტყობინებები საეჭვო აქტივობებზე
    • შეინახეთ ლოგები შესაბამისობის მოთხოვნებისთვის
    • გადააგზავნეთ ლოგები SIEM სისტემებში
  • რეგულარული ნაგვის შეგროვება
    • დაგეგმეთ რუტინული ნაგვის შეგროვება
    • დააკვირდეთ საცავის გამოყენებას
    • დააკონფიგურირეთ შენახვის პოლიტიკები
    • დანერგეთ image-ების სასიცოცხლო ციკლის მართვა
    • წაშალეთ უთეგო და მოძველებული image-ები
  • ქსელის უსაფრთხოება
    • გამოიყენეთ TLS 1.2+ registry-ს ყველა ტრაფიკისთვის
    • დანერგეთ სათანადო სერტიფიკატების მართვა
    • განიხილეთ ქსელის სეგმენტაცია
    • გამოიყენეთ VPN-ები ან კერძო ენდფოინთები წვდომისთვის

ეფექტურობა

  • ფენების ქეშირება
    • მოახდინეთ Dockerfile-ების ოპტიმიზაცია ქეშის გამოყენებისთვის
    • გამოიყენეთ BuildKit-ის გაუმჯობესებული ქეშირება
    • დანერგეთ გაზიარებული build-ის ქეშები CI/CD-ში
    • დააკონფიგურირეთ შესაბამისი ქეშის სიცოცხლის ხანგრძლივობა
    • განიხილეთ დისტანციური ქეშირება განაწილებული გუნდებისთვის
  • ოპტიმიზირებული საცავის backend-ები
    • შეარჩიეთ შესაბამისი backend მასშტაბისთვის (S3, Azure Blob და ა.შ.)
    • დააკონფიგურირეთ შეკუმშვის პარამეტრები
    • დანერგეთ მონაცემთა დედუპლიკაცია, სადაც ხელმისაწვდომია
    • დააკვირდეთ საცავის წარმადობის მეტრიკებს
    • დანერგეთ სასიცოცხლო ციკლის პოლიტიკები ავტომატიზებული მართვისთვის
  • Pull-through ქეშირება
    • დააყენეთ პროქსი registry-ები ხშირად გამოყენებული image-ებისთვის
    • დააქეშეთ გარე image-ები ლოკალურად გამტარუნარიანობის შესამცირებლად
    • დააკონფიგურირეთ შესაბამისი ქეშის TTL მნიშვნელობები
    • დაგეგმეთ ქეშის გახურება კრიტიკული image-ებისთვის
    • დანერგეთ health check-ები upstream registry-ებისთვის
  • დატვირთვის ბალანსირება
    • გაანაწილეთ registry-ს დატვირთვა მრავალ ინსტანციაზე
    • დანერგეთ round-robin ან სხვა დატვირთვის ბალანსირების სტრატეგიები
    • დააკონფიგურირეთ კავშირების დაცლა მოვლისთვის
    • დააკვირდეთ თითოეული ინსტანციის წარმადობის მეტრიკებს
    • დააყენეთ მაღალი ხელმისაწვდომობის კლასტერები
  • გეოგრაფიული განაწილება
    • განათავსეთ registry-ები მომხმარებლებთან/კლასტერებთან ახლოს
    • დანერგეთ registry-ს რეპლიკაცია რეგიონებში
    • გამოიყენეთ კონტენტის მიწოდების ქსელები, სადაც მიზანშეწონილია
    • დააკონფიგურირეთ ჭკვიანი მარშრუტიზაცია კლიენტის მდებარეობის მიხედვით
    • მოახდინეთ მეტამონაცემების სინქრონიზაცია განაწილებულ ინსტანციებს შორის

დისტრიბუციის სტრატეგიები

Image-ის ფენებთან მუშაობა

ფენების გაგება

  • Dockerfile-ის თითოეული ინსტრუქცია ქმნის ფენას
    • ყოველი RUN, COPY, ADD ბრძანება ქმნის ახალ ფენას
    • სხვა ინსტრუქციები ქმნის მხოლოდ მეტამონაცემების ცვლილებებს
    • ფენები წარმოადგენს ფაილური სისტემის განსხვავებებს
    • მაქსიმუმ 127 ფენა თითო image-ზე (პრაქტიკული ლიმიტი)
    • ძველმა image-ებმა შეიძლება გამოიყენონ სხვადასხვა ფენების ტექნოლოგია
  • ფენები ქეშირდება და ხელახლა გამოიყენება
    • უცვლელი ფენები იყენებენ ქეშს build-ების დროს
    • ქეშის ინვალიდაცია ხდება პირველი ცვლილებისას
    • ყველა შემდგომი ფენა ხელახლა უნდა აიგოს
    • დაალაგეთ ინსტრუქციები ნაკლებად ხშირად ცვლადიდან ყველაზე ხშირად ცვლადამდე
    • გამოიყენეთ .dockerignore ქეშის ინვალიდაციის თავიდან ასაცილებლად
  • ეფექტური დისტრიბუცია ეყრდნობა ფენების გაზიარებას
    • საერთო ფენები ინახება ერთხელ დისკზე
    • ერთი და იგივე ბაზის მქონე image-ები იზიარებენ საძირკვლის ფენებს
    • Registry გადასცემს მხოლოდ დაკარგულ ფენებს
    • აუმჯობესებს pull-ის წარმადობას და ამცირებს შენახვის ადგილს
    • იძლევა ეფექტური ფართომასშტაბიანი deployments-ების საშუალებას
  • საბაზისო image-ები ქმნიან საერთო საძირკვლის ფენებს
    • შეარჩიეთ შესაბამისი საბაზისო image-ები გაზიარებისთვის
    • განიხილეთ ორგანიზაცია-სპეციფიური საბაზისო image-ების გამოყენება
    • საბაზისო image-ებზე სტანდარტიზაცია ზრდის გაზიარებას
    • რეგულარულად განაახლეთ საბაზისო image-ები უსაფრთხოების პატჩებისთვის
    • თვალყური ადევნეთ საბაზისო image-ების გამოყენებას ორგანიზაციაში
  • pull-ის დროს გადაიცემა მხოლოდ შეცვლილი ფენები
    • Docker კლიენტი ამოწმებს, რომელი ფენები აქვს უკვე
    • Registry ემსახურება მხოლოდ დაკარგულ ფენებს
    • ფენები მოწმდება content-addressable ჰეშებით
    • ქსელის გადაცემა მინიმიზირებულია
    • განიხილეთ squashing production-ისთვის, თუ გაზიარება არ არის სასარგებლო

ფენების მართვა

# image-ის ფენებისა და ზომების ნახვა
docker history my-image:latest

# დეტალური ფენების ინფორმაციის ნახვა SHA256 დაიჯესტების ჩათვლით
docker history --no-trunc my-image:latest

# ფენების დეტალების ნახვა mount წერტილებისა და დრაივერის მონაცემების ჩათვლით
docker inspect my-image:latest

# კონკრეტული ფენის ამოღება (გაფართოებული)
LAYER_ID=$(docker inspect my-image:latest | jq -r '.[0].RootFS.Layers[2]')
mkdir -p /tmp/extracted-layer
docker save my-image:latest | tar -xf - -C /tmp
tar -xf /tmp/$LAYER_ID/layer.tar -C /tmp/extracted-layer

# image-ის ფენების ანალიზი dive ინსტრუმენტით
docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest my-image:latest

ფენების ოპტიმიზაცია

  • დააჯგუფეთ დაკავშირებული ბრძანებები ფენების რაოდენობის შესამცირებლად
  • გამოიყენეთ მრავალეტაპიანი build-ები build-მხოლოდ ფენების აღმოსაფხვრელად
  • წაშალეთ დროებითი ფაილები იმავე ფენაში, სადაც ისინი იქმნება
  • განიხილეთ ფენების squashing production image-ებისთვის
  • გამოიყენეთ შესაბამისი საბაზისო image-ები ფენების გაზიარების მაქსიმიზაციისთვის

მრავალ-Registry ოპერაციები

მრავალ registry-სთან მუშაობა გავრცელებულია საწარმოო გარემოში, სადაც შეიძლება გქონდეთ შიდა registry-ები development-ისთვის და გარე registry-ები დისტრიბუციისთვის.

# მრავალ registry-ში შესვლა (რწმუნებათა სიგელები ინახება ცალ-ცალკე)
docker login registry1.example.com
docker login registry2.example.com

# შესული registry-ების ვერიფიკაცია
cat ~/.docker/config.json | jq '.auths'

# ერთი registry-დან ჩამოტვირთვა და მეორეზე ატვირთვა
docker pull registry1.example.com/app:latest
docker tag registry1.example.com/app:latest registry2.example.com/app:latest
docker push registry2.example.com/app:latest

# ყველა თეგის კოპირება ერთი registry-დან მეორეზე
SOURCE_REPO="registry1.example.com/app"
DEST_REPO="registry2.example.com/app"

# რეპოზიტორიის ყველა თეგის მიღება
TAGS=$(curl -s -X GET https://registry1.example.com/v2/app/tags/list | jq -r '.tags[]')

for TAG in $TAGS; do
  docker pull $SOURCE_REPO:$TAG
  docker tag $SOURCE_REPO:$TAG $DEST_REPO:$TAG
  docker push $DEST_REPO:$TAG
done

# გამოიყენეთ skopeo image-ების კოპირებისთვის registry-ებს შორის docker daemon-ის გარეშე
skopeo copy \
  docker://registry1.example.com/app:latest \
  docker://registry2.example.com/app:latest

# registry-ს რწმუნებათა სიგელების გამოყენება გარემოს ცვლადებიდან
export REGISTRY1_USERNAME="user1"
export REGISTRY1_PASSWORD="pass1"
export REGISTRY2_USERNAME="user2"
export REGISTRY2_PASSWORD="pass2"

docker login -u $REGISTRY1_USERNAME -p $REGISTRY1_PASSWORD registry1.example.com
docker login -u $REGISTRY2_USERNAME -p $REGISTRY2_PASSWORD registry2.example.com

მრავალ registry-სთან მუშაობისას გაითვალისწინეთ:

  • registry-ების registry-ს დანერგვა (ფედერაცია)
  • სინქრონიზაციის დაყენება registry-ებს შორის
  • რწმუნებათა სიგელების უსაფრთხოდ მართვა
  • თანმიმდევრული დასახელების კონვენციების დანერგვა registry-ებში
  • image-ების წარმომავლობის თვალყურის დევნება, როდესაც ისინი registry-ებს შორის გადაადგილდებიან

Image-ების სარკირება და ქეშირება

გაფართოებული თემები

Content Trust

  • image-ების ხელმოწერა და ვერიფიკაცია
    • დანერგეთ Notary ხელმოწერების მართვისთვის
    • დააკონფიგურირეთ ცალკეული გასაღებები სხვადასხვა გარემოსთვის
    • დაადოკუმენტირეთ გასაღებების მართვის პროცედურები
    • დანერგეთ აპარატურული უსაფრთხოების მოდულები გასაღებების შესანახად
    • დააყენეთ ავტომატური ხელმოწერა CI/CD მილსადენებში
  • image-ის ავთენტურობის უზრუნველყოფა
    • დაადასტურეთ გამომცემლის იდენტობა
    • დაადასტურეთ, რომ შინაარსი არ შეცვლილა
    • შეამოწმეთ ხელმოწერის სიახლე და ვადის გასვლა
    • დანერგეთ სანდოობის ჯაჭვის ვალიდაცია
    • ინტეგრაცია უსაფრთხო პროგრამული უზრუნველყოფის მიწოდების ჯაჭვთან
  • ხელყოფის თავიდან აცილება
    • შეინახეთ ხელმოწერები image-ებისგან ცალკე
    • გამოიყენეთ ზღურბლური ხელმოწერა კრიტიკული image-ებისთვის
    • დანერგეთ გასაღებების როტაციის პროცედურები
    • დააკვირდეთ არაავტორიზებული ხელმოწერის მცდელობებს
    • დალოგეთ ყველა ვერიფიკაციის აქტივობა
  • ჩართვა daemon.json-ში
    {
  "content-trust": {
    "trust-pinning": {
      "official-library-images": true,
      "root-keys": {
        "docker.io/myorg/*": ["key1", "key2"]
      }
    }
  }
}
  • ვერიფიკაცია deployment-მდე
    • დაამატეთ ვერიფიკაციის ნაბიჯები deployment მილსადენებში
    • დაბლოკეთ deployment ხელმოუწერელი image-ების
    • დანერგეთ პოლიტიკის კონტროლერები Kubernetes-ში
    • დაადოკუმენტირეთ ვერიფიკაციის მოთხოვნები
    • დაამატეთ ხელმოწერის მეტამონაცემები deployment არტეფაქტებს

Registry API

  • RESTful API
    • კარგად დოკუმენტირებული ენდფოინთები
    • სტანდარტული HTTP სტატუს კოდები
    • JSON პასუხის ფორმატი
    • ავთენტიფიკაცია Bearer ტოკენებით
    • სიჩქარის შეზღუდვისა და throttling-ის კონტროლი
  • Image-ების მანიპულაცია
    • Push და pull ოპერაციები
    • ფენების ატვირთვა და ჩამოტვირთვა
    • რეპოზიტორიებს შორის blob-ების მიმაგრება
    • Image-ების მანიფესტების მართვა
    • Content addressable blob-ების საცავი
  • რეპოზიტორიის მართვა
    • რეპოზიტორიების სია და ძებნა
    • თეგების მართვის ოპერაციები
    • წვდომის კონტროლის კონფიგურაცია
    • რეპოზიტორიის მეტამონაცემების დამუშავება
    • Namespace-ების ორგანიზაცია
  • კატალოგის ოპერაციები
    • პაგინირებული რეპოზიტორიების სია
    • ძებნისა და ფილტრაციის შესაძლებლობები
    • მეტამონაცემების აგრეგაცია
    • თეგების ჩამოთვლა
    • რეპოზიტორიებს შორის ოპერაციები
  • Webhook-ების ინტეგრაცია
    • მოვლენებზე დაფუძნებული შეტყობინებები
    • მორგებული მოვლენების ფილტრაცია
    • მიწოდების ხელახალი ცდის მექანიზმები
    • ავთენტიფიკაცია webhook-ების ენდფოინთებისთვის
    • Webhook-ების მიწოდების ლოგირება და აუდიტი

ნაგვის შეგროვება

# ძირითადი ნაგვის შეგროვების გაშვება
docker exec -it registry \
  registry garbage-collect /etc/docker/registry/config.yml

# დეტალური ნაგვის შეგროვება ვრცელი გამოსავლით
docker exec -it registry \
  registry garbage-collect -v /etc/docker/registry/config.yml

# ნაგვის შეგროვების გაშვება მშრალი გაშვებით წაშლების წინასწარ სანახავად
docker exec -it registry \
  registry garbage-collect --dry-run /etc/docker/registry/config.yml 2>&1 | tee gc-preview.log

# გაანალიზეთ, რამდენი ადგილი გათავისუფლდება
docker exec -it registry \
  registry garbage-collect --dry-run /etc/docker/registry/config.yml 2>&1 | \
  grep "blob eligible for deletion" | \
  awk '{sum+=$7} END {print "Total bytes to be freed: " sum}'

# ნაგვის შეგროვების გაშვება და registry-ს გადატვირთვა ცვლილებების გამოსაყენებლად
docker exec -it registry \
  registry garbage-collect /etc/docker/registry/config.yml
docker restart registry

გაფართოებული საცავის მართვა

  • დანერგეთ საცავის კვოტები თითოეულ რეპოზიტორიაზე/namespace-ზე
  • დააკონფიგურირეთ ავტომატური გასუფთავების პოლიტიკები
  • დააყენეთ საცავის ანალიტიკა და მონიტორინგი
  • დანერგეთ მონაცემთა შეკუმშვა საცავის ეფექტურობისთვის
  • დააკონფიგურირეთ რეგიონებს შორის რეპლიკაცია კატასტროფისგან აღდგენისთვის

პრობლემების მოგვარება

ოპტიმიზაცია
ისწავლეთ Docker-ის image-ების, კონტეინერების და Docker-ის საერთო წარმადობის ოპტიმიზაცია
მონიტორინგი და ლოგირება
ისწავლეთ Docker-ის კონტეინერების მონიტორინგი და ეფექტური ლოგირების სტრატეგიების დანერგვა