Docker Buildx

# ინლაინ ქეშის გამოყენება ლოკალურ ფაილურ სისტემასთან
docker buildx build \
  --cache-from type=local,src=./cache \
  --cache-to type=local,dest=./cache \
  -t myimage:latest .
# ეს ინახავს ბილდის ქეშის ფენებს ./cache დირექტორიაში
# მომავალ ბილდებს შეუძლიათ ამ ქეშის ხელახლა გამოყენება, თუნდაც Docker-ის დემონი გადაიტვირთოს
# იდეალურია ლოკალური დეველოპმენტისთვის ან CI სისტემებისთვის მუდმივი საცავით

# რეესტრის გამოყენება განაწილებული ქეშირებისთვის
docker buildx build \
  --cache-from type=registry,ref=username/myapp:cache \
  --cache-to type=registry,ref=username/myapp:cache,mode=max \
  -t username/myapp:latest \
  --push .
# ინახავს ბილდის ქეშს თქვენს რეესტრში ცალკე ტეგში
# საშუალებას აძლევს გუნდებს გააზიარონ ბილდის ქეში სხვადასხვა მანქანებსა და CI/CD პაიპლაინებს შორის
# mode=max ოფცია ინახავს ყველა ფენას, შუალედურის ჩათვლით
# ამცირებს ბილდის დროს განაწილებულ გარემოში ზედმეტი სამუშაოს თავიდან აცილებით

# ქეშირება GitHub Actions-ში
docker buildx build \
  --cache-from type=gha \
  --cache-to type=gha,mode=max \
  -t username/myapp:latest .
# სპეციალურად ოპტიმიზირებულია GitHub Actions-ის სამუშაო პროცესებისთვის
# იყენებს GitHub-ის ჩაშენებულ ქეშის სისტემას უფრო სწრაფი CI ბილდებისთვის
# ავტომატურად მუშაობს GitHub-ის runner-ის არქიტექტურასთან
# ინახება სამუშაო პროცესის გაშვებებს შორის განმეორებითი ბილდების დასაჩქარებლად

# syntax=docker/dockerfile:1
FROM --platform=$BUILDPLATFORM golang:1.18 AS builder

# ეს ARGs ავტომატურად დგინდება buildx-ის მიერ
ARG TARGETPLATFORM   # პლატფორმა სამიზნე იმიჯისთვის (მაგ., linux/amd64)
ARG BUILDPLATFORM    # პლატფორმა, სადაც ბილდი მუშაობს (მაგ., linux/arm64)
RUN echo "I am running on $BUILDPLATFORM, building for $TARGETPLATFORM"

WORKDIR /app
COPY . .
# პლატფორმის მნიშვნელობების გარჩევა Go-ს გარემოს ცვლადების დასაყენებლად
RUN GOOS=$(echo $TARGETPLATFORM | cut -d/ -f1) \
    GOARCH=$(echo $TARGETPLATFORM | cut -d/ -f2) \
    go build -o /app/myapp .
# ეს რთავს კროს-კომპილაციას: Go კოდი კომპილირდება სამიზნე პლატფორმისთვის
# მიუხედავად იმისა, სად მუშაობს ბილდი

FROM alpine
COPY --from=builder /app/myapp /usr/local/bin/
CMD ["myapp"]
# საბოლოო იმიჯი შეიცავს მხოლოდ კომპილირებულ ბინარს სამიზნე პლატფორმისთვის
# მრავალ-ეტაპიანი ბილდები ეხმარება უფრო მცირე, უფრო უსაფრთხო იმიჯების შექმნაში

# syntax=docker/dockerfile:1
FROM alpine

# საიდუმლოს გამოყენება buildx-იდან პირდაპირ დამონტაჟებული ბილდის დროს
RUN --mount=type=secret,id=mysecret \
    cat /run/secrets/mysecret > /app/secret-data
# ეს არის ყველაზე უსაფრთხო მეთოდი - საიდუმლო არასოდეს ინახება რომელიმე იმიჯის ფენაში
# საიდუმლო ხელმისაწვდომია მხოლოდ ამ კონკრეტული RUN ინსტრუქციის დროს

# საიდუმლოს გამოყენება როგორც ფაილი (არ არის რეკომენდებული მგრძნობიარე მონაცემებისთვის)
COPY mysecret.txt /app/
# ეს მეთოდი ამატებს საიდუმლო ფაილს იმიჯის ფენაში, რაც მას აღდგენადს ხდის
# გამოიყენეთ მხოლოდ არა-მგრძნობიარე მონაცემებისთვის ან დეველოპმენტის გარემოებისთვის

# საიდუმლოს გამოყენება როგორც გარემოს ცვლადი (გამოიყენეთ სიფრთხილით)
ARG SECRET_ENV
ENV APP_SECRET=$SECRET_ENV
# ბილდის არგუმენტების ნახვა შესაძლებელია იმიჯის ისტორიაში
# გარემოს ცვლადები შეიძლება გამოჩნდეს კონტეინერის მეტამონაცემებში
# პროდაქშენისთვის, უმჯობესია --mount=type=secret მიდგომა

# გამოტანა Docker-ის დემონში
docker buildx build --output type=docker -t myimage .
# იტვირთება საბოლოო იმიჯი პირდაპირ Docker-ის დემონში
# ტრადიციული 'docker build' ქცევის ეკვივალენტი
# მუშაობს მხოლოდ 'docker' დრაივერთან ან ერთ-პლატფორმიან ბილდებთან

# გამოტანა რეესტრში
docker buildx build --output type=registry -t username/myapp .
# ატვირთავს იმიჯს პირდაპირ კონტეინერის რეესტრში
# მოითხოვს რეესტრში შესვლას (docker login)
# არ იტვირთება იმიჯი ლოკალურ Docker-ის დემონში
# ეფექტურია CI/CD პაიპლაინებისთვის, რომლებიც პირდაპირ რეესტრებში ტვირთავენ

# გამოტანა ლოკალურ იმიჯში
docker buildx build --load -t myimage .
# ახდენს აგებული იმიჯის იმპორტს Docker-ის ლოკალურ იმიჯების საცავში
# '--output type=docker'-ის შემოკლება
# საშუალებას იძლევა დაუყოვნებლივ გამოყენებას 'docker run'-ით აგების შემდეგ

# გამოტანა ლოკალურ დირექტორიაში
docker buildx build --output type=local,dest=./output .
# კონტეინერის იმიჯის შექმნის ნაცვლად, ახდენს ბილდის შედეგის ექსპორტს დირექტორიაში
# სასარგებლოა კომპილირებული ბინარების ან სტატიკური ფაილების ამოსაღებად ბილდიდან
# იდეალურია ბილდის სამუშაო პროცესებისთვის, რომლებსაც სჭირდებათ არტეფაქტები და არა სრული იმიჯები

# გამოტანა tar ფაილში
docker buildx build --output type=tar,dest=./image.tar .
# ქმნის tarball-ს, რომელიც შეიცავს ბილდის შედეგს
# შეიძლება გადატანილ იქნას სისტემებს შორის და ხელით ჩაიტვირთოს
# სასარგებლოა ჰაერით-იზოლირებული გარემოებისთვის ან მორგებული გავრცელების მეთოდებისთვის

group "default" {
  targets = ["app", "worker"]
}

target "app" {
  dockerfile = "Dockerfile.app"
  tags = ["myapp:latest"]
  platforms = ["linux/amd64", "linux/arm64"]
}

target "worker" {
  dockerfile = "Dockerfile.worker"
  tags = ["myworker:latest"]
  args = {
    WORKER_VERSION = "1.0"
  }
}

{
  "group": {
    "default": {
      "targets": ["app", "worker"]
    }
  },
  "target": {
    "app": {
      "dockerfile": "Dockerfile.app",
      "tags": ["myapp:latest"],
      "platforms": ["linux/amd64", "linux/arm64"]
    },
    "worker": {
      "dockerfile": "Dockerfile.worker",
      "tags": ["myworker:latest"],
      "args": {
        "WORKER_VERSION": "1.0"
      }
    }
  }
}

# კერძო რეპოზიტორიის კლონირება SSH გასაღებით
FROM alpine
RUN --mount=type=ssh mkdir -p -m 0700 ~/.ssh && \
    ssh-keyscan github.com >> ~/.ssh/known_hosts && \
    git clone [email protected]:username/private-repo.git
# --mount=type=ssh აჩენს ჰოსტის SSH აგენტს ბილდის პროცესში
# მოითხოვს --ssh default-ის გადაცემას buildx build-ის გაშვებისას
# მაგალითი: docker buildx build --ssh default=~/.ssh/id_rsa --no-cache .
# SSH გასაღებები არ ინახება იმიჯში, რაც ინარჩუნებს უსაფრთხოებას

# პაკეტების მენეჯერის ქეშირება
RUN --mount=type=cache,target=/var/cache/apt \
    apt-get update && apt-get install -y package
# ქმნის მუდმივ ქეშის დისკს, რომელიც დამონტაჟებულია /var/cache/apt-ში
# ქეში ინახება ბილდებს შორის, რაც მნიშვნელოვნად აჩქარებს პაკეტების ინსტალაციას
# არ მოქმედებს საბოლოო იმიჯის ზომაზე - ქეში არსებობს მხოლოდ ბილდის დროს
# მრავალ ბილდს შეუძლია ერთდროულად გაიზიაროს იგივე ქეში
# ჩვეულებრივ Docker-ში დისკის დამონტაჟებისგან განსხვავებით, ეს ბილდ-სპეციფიკურია

# დროებითი bind mount-ის გამოყენება
RUN --mount=type=bind,source=./config,target=/config \
    cp /config/app.conf /etc/app/config.conf
# ამონტაჟებს ./config დირექტორიას ბილდის კონტექსტიდან /config-ში კონტეინერში
# ფაილების წაკითხვა და კოპირება შესაძლებელია, მაგრამ არ ხდება რომელიმე ფენის ნაწილი
# სასარგებლოა კონფიგურაციის ფაილებისთვის, შაბლონებისთვის ან ნებისმიერი შინაარსისთვის, რომელიც საჭიროა მხოლოდ ბილდის დროს
# readonly ოფციის დამატება შესაძლებელია დამატებითი უსაფრთხოებისთვის: type=bind,source=./config,target=/config,readonly