Docker იმიჯები

შეიტყვეთ Docker იმიჯების, Dockerfile-ების და იმიჯების მართვის შესახებ

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

Docker იმიჯები

Docker იმიჯები კონტეინერების სამშენებლო ბლოკებია. ისინი მხოლოდ წაკითხვადი შაბლონებია, რომლებიც შეიცავს:

  • აპლიკაციის კოდს
  • Runtime გარემოს
  • დამოკიდებულებებს
  • კონფიგურაციას

Docker იმიჯები ფუნქციონირებს როგორც ფაილური სისტემის სრული სნეპშოტი, რომელიც უზრუნველყოფს ყველაფერს, რაც საჭიროა აპლიკაციის გასაშვებად. ისინი არიან:

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

თითოეული image-ი იდენტიფიცირებულია უნიკალური SHA256 დაიჯესტით და შეიძლება ჰქონდეს მრავალი ადამიანისთვის წაკითხვადი თეგი (როგორიცაა nginx:latest ან ubuntu:20.04). image-ის არქიტექტურა განსაზღვრავს, თუ რომელ CPU არქიტექტურებზე შეუძლია მას მუშაობა (x86_64, ARM64 და ა.შ.).

Dockerfile-ებთან მუშაობა

Dockerfile არის ტექსტური დოკუმენტი, რომელიც შეიცავს image-ის ასაგებად საჭირო ყველა ბრძანებას. ის უზრუნველყოფს დეკლარაციულ, განმეორებად გზას თქვენი კონტეინერის გარემოს განსაზღვრისთვის:

# საბაზისო იმიჯად ოფიციალური Python runtime-ის გამოყენება
FROM python:3.9-slim

# სამუშაო დირექტორიის დაყენება
WORKDIR /app

# requirements ფაილის კოპირება
COPY requirements.txt .

# დამოკიდებულებების ინსტალაცია
RUN pip install --no-cache-dir -r requirements.txt

# აპლიკაციის კოდის კოპირება
COPY . .

# აპლიკაციის გასაშვები ბრძანება
CMD ["python", "app.py"]

Dockerfile-ის გავრცელებული ინსტრუქციები

ინსტრუქციადანიშნულებამაგალითი
FROMგანსაზღვრავს საბაზისო image-სFROM ubuntu:20.04
WORKDIRაყენებს სამუშაო დირექტორიასWORKDIR /app
COPYაკოპირებს ფაილებს ჰოსტიდან image-შიCOPY . /app
ADDაკოპირებს ფაილებს დამატებითი ფუნქციებით (URL მხარდაჭერა, tar-ის ამოღება)ADD https://example.com/file.tar.gz /app
RUNასრულებს ბრძანებებს ახალ ფენაშიRUN apt-get update && apt-get install -y curl
ENVაყენებს გარემოს ცვლადებსENV NODE_ENV=production
EXPOSEდოკუმენტირებს, თუ რომელი პორტების გამოქვეყნებაა განზრახულიEXPOSE 8080
CMDუზრუნველყოფს გასაშვებად ნაგულისხმევ ბრძანებასCMD ["node", "app.js"]
ENTRYPOINTაკონფიგურირებს კონტეინერს, რომ გაეშვას როგორც შესრულებადი ფაილიENTRYPOINT ["nginx", "-g", "daemon off;"]
VOLUMEქმნის მიმაგრების წერტილსVOLUME /data
USERაყენებს მომხმარებელს შემდგომი ინსტრუქციებისთვისUSER node
ARGგანსაზღვრავს build-დროის ცვლადებსARG VERSION=latest

Dockerfile-ის თითოეული ინსტრუქცია ქმნის ახალ ფენას image-ში, რაც გავლენას ახდენს როგორც build-ის დროზე, ასევე საბოლოო image-ის ზომაზე.

იმიჯების აგება

აგების ძირითადი ბრძანება

docker build -t my-app:1.0 .

-t დროშა image-ს ანიჭებს სახელსა და ვერსიას. . მიუთითებს build context-ს (დირექტორია, რომელიც შეიცავს თქვენს Dockerfile-ს და აპლიკაციის ფაილებს). ამ ბრძანების გაშვებისას, Docker:

  1. აგზავნის build context-ს Docker daemon-თან
  2. თანმიმდევრულად ასრულებს Dockerfile-ის თითოეულ ინსტრუქციას
  3. ქმნის შუალედურ კონტეინერებს თითოეული ნაბიჯისთვის
  4. თითოეულ ნაბიჯს ინახავს როგორც ახალ image ფენას
  5. შლის შუალედურ კონტეინერებს
  6. საბოლოო image-ს ანიჭებს მითითებულ სახელს

აგება სხვადასხვა Dockerfile-ით

docker build -f Dockerfile.dev -t my-app:dev .

-f დროშა გაძლევთ საშუალებას მიუთითოთ Dockerfile-ის მორგებული სახელი. ეს სასარგებლოა, როდესაც გაქვთ მრავალი Dockerfile-ი სხვადასხვა გარემოსთვის (development, testing, production) ან პლატფორმისთვის.

აგება Build არგუმენტებით

docker build --build-arg ENV=production -t my-app:prod .

Build არგუმენტები საშუალებას გაძლევთ გადასცეთ ცვლადები build პროცესს, რომლებიც შეიძლება გამოყენებულ იქნას თქვენს Dockerfile-ში ARG ინსტრუქციით. ეს იძლევა პარამეტრიზებული build-ების საშუალებას, რომლებსაც შეუძლიათ სხვადასხვა იმიჯების წარმოება მოწოდებული არგუმენტების საფუძველზე.

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

# აგება ქეშის გარეშე
docker build --no-cache -t my-app:latest .

# აგება მრავალი პლატფორმისთვის
docker buildx build --platform linux/amd64,linux/arm64 -t my-app:multi .

# აგება BuildKit-ის ჩართვით (უფრო სწრაფი, მეტი ფუნქციებით)
DOCKER_BUILDKIT=1 docker build -t my-app:fast .

# აგება build-დროის საიდუმლოებებით
docker build --secret id=mysecret,src=./secret.txt -t my-app:secure .

იმიჯების მართვა

# იმიჯების სია
docker images

# იმიჯების სია დეტალური ფორმატით
docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}\t{{.Size}}"

# image-ის წაშლა
docker rmi <image-id>

# ყველა გამოუყენებელი image-ის წაშლა
docker image prune -a

# image-ის ჩამოტვირთვა registry-დან
docker pull <image-name>

# image-ის კონკრეტული ვერსიის ჩამოტვირთვა
docker pull <image-name>:<tag>

# image-ის ჩამოტვირთვა კონკრეტული პლატფორმისთვის
docker pull --platform linux/arm64 <image-name>

# image-ის ატვირთვა registry-ზე
docker push <image-name>

# image-ის თეგირება
docker tag <source-image> <target-image>

# image-ის დეტალების შემოწმება
docker inspect <image-id>

# image-ის ისტორიის (ფენების) ნახვა
docker history <image-id>

# image-ის შენახვა tar ფაილში
docker save -o myimage.tar <image-name>

# image-ის ჩატვირთვა tar ფაილიდან
docker load -i myimage.tar

იმიჯების დასახელების კონვენციები

Docker იმიჯები იყენებენ დასახელების სპეციფიკურ კონვენციას:

  • Registry დომენი: (არასავალდებულო) თუ არ არის მითითებული, ნაგულისხმევად არის Docker Hub
  • Repository სახელი: image-ის სახელი
  • თეგი: (არასავალდებულო) თუ არ არის მითითებული, ნაგულისხმევად არის "latest"
  • დაიჯესტი: (არასავალდებულო) SHA256 ჰეში, რომელიც უნიკალურად განსაზღვრავს image-ს

მაგალითები:

- `nginx:1.21.0` (Docker Hub, nginx repository, თეგი 1.21.0)
- `gcr.io/project/image:v1` (Google Container Registry, project/image repository, თეგი v1)
- `localhost:5000/myapp:dev` (ლოკალური registry პორტზე 5000, myapp repository, თეგი dev)
- `ubuntu@sha256:a56414c82641178a5628fc1a4d281cd39e4fb0f1b94455c693dbc4ae0a7c310e` (Image-ი დაიჯესტით)

Multi-stage Build-ები

Multi-stage build-ები გვეხმარება შევქმნათ უფრო მცირე ზომის production იმიჯები build გარემოს runtime გარემოსგან გამოყოფით:

# Build ეტაპი
FROM node:16 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Production ეტაპი
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Multi-stage Build-ების უპირატესობები

  1. უფრო მცირე საბოლოო იმიჯები: შეიცავს მხოლოდ იმას, რაც საჭიროა runtime-ისთვის
  2. უკეთესი უსაფრთხოების მდგომარეობა: ნაკლები დამოკიდებულება ნიშნავს თავდასხმის მცირე ზედაპირს
  3. მოვალეობების გამიჯვნა: Build ინსტრუმენტები არ აბინძურებს production image-ს
  4. გაუმჯობესებული წარმადობა: მცირე იმიჯები უფრო სწრაფად იტვირთება და ნაკლებ გამტარობას იყენებს
  5. შემცირებული სირთულე: ერთი Dockerfile-ი მრავალი build სკრიპტის ნაცვლად

Multi-stage-ის გაფართოებული ტექნიკები

# საბაზისო ეტაპი საერთო დამოკიდებულებებით
FROM python:3.9-slim AS base
RUN apt-get update && apt-get install -y --no-install-recommends gcc

# Development ეტაპი
FROM base AS development
RUN pip install pytest pytest-cov
COPY . /app/
WORKDIR /app
CMD ["pytest"]

# Build ეტაპი
FROM base AS builder
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . /app/
WORKDIR /app
RUN python setup.py bdist_wheel

# Production ეტაპი
FROM python:3.9-slim AS production
COPY --from=builder /app/dist/*.whl /tmp/
RUN pip install --no-cache-dir /tmp/*.whl && rm /tmp/*.whl
CMD ["python", "-m", "myapp"]

შეგიძლიათ მიუთითოთ კონკრეტული ეტაპები build-ის დროს --target-ით:

docker build --target development -t myapp:dev .

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

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