Ana içeriğe geç

Docker Buildx: Çok Platformlu Konteyner İmajları Nasıl Oluşturulur

Docker Buildx’in, çok platform desteği, gelişmiş önbellekleme stratejileri ve performans iyileştirmeleriyle geleneksel konteyner oluşturmayı nasıl genişlettiğini öğrenin. Bu rehber temel kavramlardan ileri tekniklere kadar her şeyi kapsar.
· 14 dk. oku

Yapay Zeka ile Keşfedin

Birden çok platform için konteyner oluşturmak göz korkutucu ve zaman alıcı görünebilir, ancak birazdan bunun hiç de öyle olmadığını göreceksiniz.

docker buildx komutu, Docker'ın derleme yeteneklerini çok platformlu imaj oluşturma, gelişmiş önbellekleme ve paralel derleme işleme gibi ileri özelliklerle genişleterek bu sorunu çözer. Yeni nesil derleme motoru BuildKit'i doğrudan Docker CLI'a entegre eder. buildx komutuyla, tamamen yeni bir araç seti öğrenmeden daha küçük, daha hızlı ve daha güvenli konteyner imajları oluşturacaksınız.

Son yıllarda, Buildx en iyi DevOps uygulamaları ve bulut-yerel uygulama geliştirme için adeta vazgeçilmez hale geldi. CI/CD hatlarını sadeleştirir ve ARM tabanlı IoT cihazlarından bulut sunucu çiftliklerine kadar farklı dağıtım hedeflerinde uygulamaları tutarlı şekilde teslim etmenize yardımcı olur.

> Docker'a yeni misiniz? Tamamen yeni başlayanlara yönelik pratik rehberimiz sizi kısa sürede çalışır hale getirecek.

Bu yazıda, başlangıç ve ileri düzey docker buildx tekniklerinde size yol göstereceğim.

Docker Buildx’i Anlamak

Muhtemelen zaten Docker kullanıyorsunuz ve standart docker build komutunu biliyorsunuz. Ancak er ya da geç, özellikle projeleriniz karmaşıklaştığında sınırlayıcı gelmeye başlayacaktır.

> Docker Buildx, sisteminizde Docker’ın kurulu olduğunu varsayar. Eğer kurulu değilse ve Linux kullanıyorsanız, kolay kurulum için bu rehberi izleyin.

Docker Buildx, mevcut bilginizle uyumlu gelişmiş bir derleme deneyimi sunar. Ayrı bir araç kurmanıza gerek yok — 19.03 sürümünden beri Docker Desktop ve Engine ile birlikte gelir. Buildx, kaputun altında Docker’ın imaj oluşturma biçimini baştan yazan yeni nesil derleyicisi BuildKit’i kullanır. Daha hızlı derlemeler, daha küçük imajlar ve ek özellik desteği fark edeceksiniz.

docker build ile docker buildx build arasındaki geçiş küçük görünebilir — sonuçta sadece bir kelime — fakat kazandığınız yetenekler çok büyüktür.

Şimdi Buildx’in gerçekte nasıl çalıştığını ve eski derleyiciden farkını inceleyelim.

Buildx’in mimari temelleri

Buildx’in sihri, akıllı istemci-sunucu tasarımından gelir.

Bir Buildx komutu çalıştırdığınızda, ağır işi üstlenen sunucu bileşeni BuildKit daemon’ı ile iletişim kuran istemci olarak Docker CLI’ı kullanırsınız. Bu ayrım, BuildKit’in eski derleyicinin yapamadığı şeyleri yapmasını sağlar; örneğin, derleme aşamalarını sırayla değil paralel olarak çalıştırmak. Artık Dockerfile talimatlarınızın tek tek çalışması gerekmez; bağımsız aşamalar olduğunda derleme sürelerini önemli ölçüde kısar.

İstemci-sunucu modeli ayrıca uzaktan derleme yürütmeye olanak tanır. Yerel Docker CLI’ınızı, güçlü bir derleme sunucusunda, bulutta veya hatta bir Kubernetes kümesinde çalışan uzak bir BuildKit örneğine yönlendirebilirsiniz. Bu esneklik sayesinde devasa derlemeler için dizüstü bilgisayarınızın kaynaklarını meşgul etmek zorunda kalmaz veya mimari uyumluluk sorunlarıyla uğraşmazsınız.

BuildKit’in modüler tasarımı ayrıca farklı ön uç ayrıştırıcılarını takmanıza olanak tanır. Dockerfile söz dizimi varsayılandır, ancak iş akışınıza daha uygunsa alternatif derleme tanım biçimlerini kullanabilirsiniz.

Derleme süreç akışı

docker buildx build çalıştırdığınızda, CLI önce varsayılan ya da sizin belirlediğiniz bir oluşturucu örneğini seçer. Derleme bağlamınız ve Dockerfile BuildKit daemon’ına gönderilir; talimatlar ayrıştırılır ve derleme adımlarının yönsüz çevrimsiz bir grafiği (DAG) oluşturulur. Her talimatı sırayla işleyen eski derleyicinin aksine, BuildKit bu grafiği analiz ederek hangi adımların paralel çalıştırılabileceğini belirler.

Ardından derleyici, eski katman tabanlı önbellekten çok daha akıllı verimli önbellekleme algoritmaları kullanarak bu adımları yürütür. BuildKit her bir adımın tam girdi ve çıktısını izler; böylece ilgili hiçbir şey değişmediğinde gereksiz yeniden derlemelerin önüne geçer. Ayrıca derlemeyi daha da hızlı işleme için birden fazla çalışan düğüme dağıtmayı destekler.

Derlemeden sonra Buildx sonuçları yalnızca Docker imajı olarak değil, farklı biçimlerde dışa aktarabilir. OCI biçimlerine, yerel dizinlere veya tarball dosyalarına çıktı alabilir, hatta yalnızca derleme sürecini test etmek istiyorsanız imaj oluşturmayı tamamen atlayabilirsiniz.

Haklısınız — bu bölüm, Buildx’in gerçek dünyadaki senaryolarda nasıl çalıştığını göstermek için daha fazla pratik örnek ve görselden kesinlikle fayda sağlayabilir. İşte bunu daha fazla kod örneği ve görsel önerileriyle nasıl güçlendireceğim:

Temel İşlevler ve Özellikler

Docker Buildx yalnızca imajları daha hızlı oluşturmakla ilgili değildir — bunu kesinlikle yapar — asıl mesele derleme hatlarınızla yapılabilenleri genişletmektir.

Gelin, Buildx’i bir sonraki projeniz için değerli kılan öne çıkan özelliklere yakından bakalım.

> Docker proje fikirleri mi arıyorsunuz? Bu 10 fikir DevOps portföyünüzü düzene sokacak.

Kullanılan Python uygulaması

Bu yazı için basit bir Python Flask uygulaması oluşturdum. Takip etmek için app.py, requirements.txt ve Dockerfile olmak üzere 3 dosya oluşturun.

Her birinin içeriği aşağıdadır:

app.py

from flask import Flask, render_template_string
import platform
import socket
import psutil
import datetime

app = Flask(__name__)


@app.route("/")
def home():
    html = """
    <!DOCTYPE html>
    <html>
      <head>
        <title>Docker Buildx Python Demo</title>
        <style>
          body {
            
            max-width: 800px;
            
            
          }
          .container {
            border: 1px solid #ddd;
            border-radius: 5px;
            
            background-
          }
          .info {
            
          }
          .platform {
            font-weight: bold;
            
          }
        </style>
      </head>
      <body>
        <h1>Docker Buildx Multi-Platform Demo (Python)</h1>
        <div class="container">
          <div class="info">Hostname: {{ hostname }}</div>
          <div class="info">Platform: <span class="platform">{{ os_platform }} ({{ architecture }})</span></div>
          <div class="info">CPUs: {{ cpu_count }}</div>
          <div class="info">Total Memory: {{ memory_mb }} MB</div>
          <div class="info">Server Time: {{ server_time }}</div>
        </div>
      </body>
    </html>
    """
    return render_template_string(
        html,
        hostname=socket.gethostname(),
        os_platform=platform.system(),
        architecture=platform.machine(),
        cpu_count=psutil.cpu_count(),
        memory_mb=round(psutil.virtual_memory().total / (1024 * 1024)),
        server_time=datetime.datetime.now().isoformat(),
    )


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

requirements.txt

flask==3.1.0
psutil==7.0.0

Dockerfile

FROM python:3.13-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

EXPOSE 5000

CMD ["python", "app.py"]

Bittiğinde yeni bir Terminal penceresi açın ve proje klasörüne gidin.

Çok platformlu imaj oluşturma

Farklı CPU mimarilerinde çalışan imajlar oluşturmak kabus gibi gelebilir, ancak Buildx bunu şaşırtıcı derecede basit hale getirir.

Şu komuta göz atın:

docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest .

Görsel 1 - Docker Buildx kullanımı

Görsel 1 - Docker Buildx kullanımı

Kısaca, aynı anda birden fazla mimari için imaj oluşturmanızı sağlar. Buildx bunu üç akıllı yaklaşımla yönetir: QEMU kullanarak mimari öykünmesi yapabilir (x86 bir makinada ARM imajları oluşturmanıza izin verir), her hedef platform için yerel oluşturucu düğümlere bağlanabilir veya en iyi performans için her iki yöntemi birleştirebilir. Sonuç olarak her platform için imaj varyantlarını içeren bir çok mimarili manifest listesi — bazen "fat manifest" olarak da adlandırılır — elde edersiniz.

AWS Graviton örnekleri, Raspberry Pi kümeleri veya karma altyapılar gibi çeşitli ortamlara dağıtım yapıyorsanız bu çok platformlu destek kritik önem taşır.

Geliştirilmiş önbellekleme stratejileri

Buildx, derleme önbelleklemenin çalışma şeklini tamamen dönüştürür ve genellikle derlemelerinizi hızlandırır.

Sistem, geleneksel Docker derlemelerindeki basit katman önbelleklemenin ötesine geçen üç katmanlı bir önbellekleme stratejisi uygular:

  1. Satır içi önbellek gömme: İlk olarak, Buildx imajlarınıza gömülü satır içi önbelleği kullanır; böylece taze ortamlarda bile önceki derlemelerden önbelleğe alınmış katmanlardan yararlanabilirsiniz.
  2. Yerel derleme önbelleği: İkincisi, yalnızca talimatların sırasına değil girdilerine dayalı olarak akıllıca yönetilen yerel bir derleme önbelleğini destekler.
  3. Kayıt defteri tabanlı önbellekleme: Üçüncüsü, CI/CD hatları veya dağıtık ekipler için ideal olan, farklı makineler arasında derleme önbelleğini paylaşmanızı sağlayan kayıt defteri tabanlı önbellekleme sunar.

Python uygulamamızla yerel önbellekleme stratejilerini nasıl kullanabileceğimize bakalım:

# Yerel önbellek için bir dizin oluşturun
mkdir -p buildx-cache

# İlk derleme - önbelleği yerel dizine aktarın
docker buildx build --cache-to type=local,dest=./buildx-cache -t myapp:latest .

# app.py dosyasında küçük bir değişiklik yapın
echo "# Small comment change" >> app.py

# İkinci derleme - yerel önbelleği kullanın
docker buildx build --cache-from type=local,src=./buildx-cache -t myapp:latest .

İkinci derleme çok daha hızlı olacaktır çünkü ilk derlemeden önbelleğe alınan katmanları yeniden kullanır.

Görsel 2 - Yerel önbellekleme stratejileri

Görsel 2 - Yerel önbellekleme stratejileri

Ayrıca, önbellek meta verilerini imajın içine gömen satır içi önbelleği de kullanabilirsiniz:

docker buildx build --cache-to type=inline -t myapp:latest .

Bu önbellek arka uçlarını --cache-to ve --cache-from gibi basit bayraklarla yerel dizinlere, kayıt defteri depolarına veya hatta özel önbellek servislerine işaret ederek yapılandırabilirsiniz. Bu esneklik, tekrarlanabilirlikten ödün vermeden farklı ortamlarda derlemelerinizin hızlı kalmasını sağlar.

Güvenlik özellikleri

Buildx, güvenlikle ilgili endişeleri zihninizden çıkaracak araçlar içerir.

Diyelim ki Python uygulamanız derleme sırasında bir hava durumu API’sine erişmek zorunda. API anahtarınızı Dockerfile’a gömmek yerine derleme sırlarını (secrets) kullanabilirsiniz:

# API anahtarınızı yerel bir dosyada saklayın
echo "abc123yourweatherapikey" > ./api_key.txt

# Sır ile derleyin
docker buildx build --secret id=weather_api_key,src=./api_key.txt -t myapp:latest .

Ardından Dockerfile içinde, sırra yalnızca gerektiğinde erişebilirsiniz:

FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
# Derleme sırasında sır ile bir yapılandırma dosyası oluşturun
RUN --mount=type=secret,id=weather_api_key \
    echo "WEATHER_API_KEY=$(cat /run/secrets/weather_api_key)" > .env
EXPOSE 5000
CMD ["python", "app.py"]

API anahtarının son imajda olmadığını imaj geçmişini kontrol ederek veya şunu çalıştırarak doğrulayabilirsiniz:

docker run --rm myapp:latest cat .env

Görsel 3 - Ortam değişkenlerini yönetme

Görsel 3 - Ortam değişkenlerini yönetme

app.py dosyanızda API anahtarını şu şekilde yükleyebilirsiniz:

import os
from dotenv import load_dotenv

load_dotenv()  # Load variables from .env file
api_key = os.getenv("WEATHER_API_KEY", "")
# ...

Bu yaklaşım, hassas API anahtarınızın yalnızca gerektiği belirli derleme adımında kullanılabilir olduğu, ancak hiçbir imaj katmanına kaydedilmediği anlamına gelir. İmajınızı çeken hiç kimse, katmanları incelese bile API anahtarınızı çıkaramaz.

Ek güvenlik için, derlemeden sonra otomatik olarak kaldırılan geçici derleme konteynerlerini de kullanabilirsiniz:

docker buildx build --secret id=weather_api_key,src=./api_key.txt --rm -t myapp:latest .

--rm bayrağı, derleme sürecinde oluşturulan ara konteynerlerin kaldırılmasını sağlar ve sızıntı riskini daha da azaltır.

Operasyonel Yapılandırma

Buildx’i iş akışınıza kurmak sadece birkaç komut alır; ancak seçenekleri anlamak ondan en iyi şekilde yararlanmanıza yardımcı olur.

Yerel bir ortamda Buildx’i özel ihtiyaçlarınıza göre nasıl yapılandırıp yöneteceğinize bakalım.

Oluşturucu örneği yönetimi

Docker Buildx, farklı yetenek ve yapılandırmalara sahip ayrı BuildKit örnekleri olan "oluşturucular" kavramını kullanır. Farklı amaçlar için birden çok oluşturucu oluşturabilirsiniz.

Önce, halihazırda hangi oluşturucuların olduğunu görelim:

docker buildx ls

Buna benzer bir çıktı göreceksiniz:

Görsel 4 - Mevcut oluşturucular

Görsel 4 - Mevcut oluşturucular

Yeni bir oluşturucu örneği oluşturmak için şu komutları çalıştırın:

# Yeni bir oluşturucu oluşturun
docker buildx create --name mybuilder

# O oluşturucuyu kullanmaya geçin
docker buildx use mybuilder

# Oluşturucuyu önyükleyin (başlatın)
docker buildx inspect --bootstrap

Çalıştığını şu komutla doğrulayabilirsiniz:

# Durumu kontrol edin
docker buildx ls

Görsel 5 - Özel bir oluşturucuya geçiş

Görsel 5 - Özel bir oluşturucuya geçiş

Bir oluşturucuyu kaldırmanız gerekirse sadece şunu çalıştırın:

docker buildx rm mybuilder

Çıktı yönetimi

Buildx, oluşturduğunuz imajlarla ne yapacağınız konusunda esnek seçenekler sunar. Onları doğrudan yerel Docker daemon’ına yükleyebilir, tarball olarak dışa aktarabilir veya yerel bir dizine kaydedebilirsiniz.

Bu seçenekleri Python uygulamamızla nasıl kullanacağımıza bakalım:

# İmajı doğrudan Docker’a yükleyin (varsayılan davranış)
docker buildx build --load -t myapp:latest .

# İmajı tarball olarak dışa aktarın
docker buildx build --output type=docker,dest=myapp.tar -t myapp:latest .

# İmaj içeriğini yerel bir dizine kaydedin
docker buildx build --output type=local,dest=./image-output -t myapp:latest .

Tarball dışa aktarımını kullandıktan sonra, Docker’a şu komutla yükleyebilirsiniz:

docker load < myapp.tar

Görsel 6 - Tarball dışa aktarımından imaj yükleme

Görsel 6 - Tarball dışa aktarımından imaj yükleme

Yerel dizin çıktısı özellikle inceleme için kullanışlıdır. Nelerin oluşturulduğuna bakalım:

ls -la ./image-output

Ham imaj dosya sistemini göreceksiniz:

Görsel 7 - Yerel dizin dışa aktarım içeriği

Görsel 7 - Yerel dizin dışa aktarım içeriği

Hatta son bir imaj oluşturmadan belirli derleme aşamalarını bile çalıştırabilirsiniz. Bu, hata ayıklama veya derleme adımlarını test etmek için kullanışlıdır:

# Çok aşamalı bir Dockerfile oluşturun
cat > Dockerfile.multi << 'EOF'
FROM python:3.13-slim AS base
WORKDIR /app
COPY requirements.txt .

FROM base AS dev-deps
RUN pip install --no-cache-dir -r requirements.txt
RUN pip install pytest

FROM base AS prod-deps
RUN pip install --no-cache-dir -r requirements.txt

FROM prod-deps AS final
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]
EOF

# Yalnızca dev-deps aşamasını derleyin ve dosya sistemini dışa aktarın
docker buildx build --file Dockerfile.multi --target dev-deps --output type=local,dest=./dev-deps-output .

Artık geliştirme ortamında hangi paketlerin kurulduğunu inceleyebilirsiniz:

cat ./dev-deps-output/usr/local/lib/python3.13/site-packages/pytest/__init__.py

Görsel 8 - dev-deps aşamasındaki dosya içeriği

Görsel 8 - dev-deps aşamasındaki dosya içeriği

Özetle, bu çıktı seçenekleri ister yerelde hata ayıklıyor olun ister ekibinizle paylaşılacak imajları hazırlıyor olun, oluşturulan imajlarınızın nereye gideceğini tamamen kontrol etmenizi sağlar.

İleri Düzey Kullanım Senaryoları

Şimdiye kadar temel Buildx komutlarını ve kullanım alanlarını gösterdim. Buildx’in yapabilecekleri çok daha fazlası ve bazı özellikler klasik derleyiciyle uygulanması imkansız şeyler.

Konteynerleştirme iş akışınızı bir üst seviyeye taşıyacak bazı ileri teknikleri keşfedelim.

Çok aşamalı derleme optimizasyonu

Çok aşamalı derlemeler, verimli imajlar oluşturmak için Docker’ın en güçlü özelliklerinden biridir ve Buildx bunları daha da iyi hale getirir.

Göstermek için birden çok aşamalı, optimize edilmiş bir Python uygulaması oluşturalım:

# Dockerfile.optimized
FROM python:3.13-slim AS base
WORKDIR /app
COPY requirements.txt .

FROM base AS builder
RUN pip install --no-cache-dir --target=/install -r requirements.txt

FROM base AS linter
COPY --from=builder /install /usr/local/lib/python3.13/site-packages
COPY app.py .
RUN pip install pylint && pylint app.py || exit 0

FROM base AS tester
COPY --from=builder /install /usr/local/lib/python3.9/site-packages
COPY app.py .
RUN pip install pytest && python -m pytest app.py -v || exit 0

FROM python:3.13-alpine AS final
WORKDIR /app
COPY --from=builder /install /usr/local/lib/python3.13/site-packages
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]

Buildx ile bunu daha verimli derleyebilirsiniz:

docker buildx build --file Dockerfile.optimized -t myapp:optimized --load .

Görsel 9 - Çok aşamalı derlemeler

Görsel 9 - Çok aşamalı derlemeler

Peki bunu özel kılan ne? Buildx, bağımsız aşamaları paralel olarak işler. Eski derleyici her aşamayı sırayla yürütürken, Buildx linter ve tester aşamalarının birbirine bağlı olmadığını algılar ve aynı anda derler.

Bu derleme optimizasyonunun bir diğer faydası da dosya boyutunun azalmasıdır. İmaj boyutunu şu komutla doğrulayabilirsiniz:

docker images myapp

Şuna benzer bir çıktı göreceksiniz:

Görsel 10 - Docker imaj boyutları

Görsel 10 - Docker imaj boyutları

Alpine tabanlı son imaj çok daha küçüktür.

CI/CD hattı entegrasyonu

Yerelde çalışırken bile CI/CD ortamınızı yansıtan Buildx yapılandırmaları kurabilirsiniz.

Öncelikle, derlemeleri temiz tutmak için bir .dockerignore dosyası oluşturun:

.git
__pycache__
*.pyc
*.pyo
*.pyd
.Python
env
venv
*.so
.coverage
htmlcov

Ardından CI hattınızın yapabileceklerini taklit eden bir derleme betiği oluşturun:

#!/bin/bash
# build.sh - Yerel CI/CD simülasyonu

echo "CI/CD derleme süreci başlatılıyor..."

# Öykünme desteğiyle oluşturucuyu kurun
echo "Oluşturucu ayarlanıyor..."
docker buildx create --name cibuilder --use || true
docker buildx inspect --bootstrap

# Lint aşamasını çalıştırın
echo "Lint aşaması çalıştırılıyor..."
docker buildx build --file Dockerfile.optimized --target linter .

# Testleri çalıştırın
echo "Test aşaması çalıştırılıyor..."
docker buildx build --file Dockerfile.optimized --target tester .

# Birden çok platform için derleyin
echo "Çok platformlu imaj oluşturuluyor..."
docker buildx build --file Dockerfile.optimized \
  --platform linux/amd64,linux/arm64 \
  --tag myapp:$(date +%Y%m%d) \
  --tag myapp:latest \
  --load \
  --progress=plain \
  .

echo "Derleme süreci tamamlandı!"

Basitçe söylemek gerekirse bu betik şunları yapar:

  • CI/CD için özel bir oluşturucu yaratır.
  • Linting aşamasını çalıştırır.
  • Test aşamasını çalıştırır.
  • Sürümlü etiketlerle son çok platformlu imajı oluşturur.

Şimdi işin eğlenceli kısmına geçelim — betiği çalıştırılabilir yapın ve çalıştırın:

chmod +x build.sh
./build.sh

Yerelde düzenleme

Docker ile çalışırken sık karşılaşılan bir sorun, kaynak dosyada her değişiklik yaptığınızda imajı yeniden derleyip konteyneri çalıştırma gerekliliğidir. Bu da fazla zaman alır.

Güzel haber: yerel geliştirme ve daha hızlı yinelemeler için bir geliştirme sürümü oluşturabilirsiniz:

# Dockerfile.dev
FROM python:3.13-slim
WORKDIR /app

RUN pip install flask psutil python-dotenv

# Geliştirme araçlarını yükleyin
RUN pip install pytest pylint watchdog

# Kopyalamak yerine çalışma zamanında uygulama kodunu bağlayın
CMD ["python", "app.py"]

Canlı kod yenilemesi için bir birim (volume) bağlamasıyla çalıştırın:

docker buildx build -f Dockerfile.dev -t myapp:dev --load .
docker run -it --rm -p 5000:5000 -v $(pwd):/app myapp:dev

Artık app.py dosyanızı yerelde düzenleyebilir ve değişiklikler anında çalışan konteynere yansır!

Sırada, performanstan bahsedelim.

Performansla İlgili Hususlar

Yavaş bir geliştirme iş akışını kimse sevmez ve Docker Buildx’in paralelleştirme gücü burada yardımcı olabilir.

Derlemelerinizi nasıl optimize edeceğinizi ve Buildx’in performans özelliklerinden yararlanarak imajları daha hızlı nasıl oluşturacağınızı inceleyelim.

Derleme paralelleştirme teknikleri

Buildx’in en büyük avantajlarından biri, aşamaları paralel olarak derleyebilmesidir. Geleneksel Docker derleyicisi her adımı sırasıyla çalıştırır; Buildx ise Dockerfile’ınızı analiz eder ve aynı anda çalıştırılabilecek adımları belirler.

Bunu göstermek için iki dosya kullanacağım — Dockerfile.standard ve Dockerfile.parallel. Her ikisinin içeriği şöyle:

Dockerfile.standard

FROM python:3.13-slim
WORKDIR /app

# Sistem bağımlılıkları
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

# Python bağımlılıkları
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Uygulama kodu
COPY app.py .

# Linting
RUN pip install pylint && pylint app.py || true

EXPOSE 5000
CMD ["python", "app.py"]

Dockerfile.parallel

FROM python:3.13-slim AS python-base
WORKDIR /app

# Sistem bağımlılıklarını kurmak için bağımsız aşama
FROM python-base AS system-deps
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

# Python bağımlılıklarını kurmak için bağımsız aşama
FROM python-base AS python-deps
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Statik kod analizi için bağımsız aşama
FROM python-deps AS linting
COPY app.py .
RUN pip install pylint && pylint app.py || true

# Bağımlılıkları birleştiren son aşama
FROM python-base AS final
# Sistem bağımlılıkları aşamasından kopyala
COPY --from=system-deps /usr/bin/gcc /usr/bin/gcc
# Python bağımlılıkları aşamasından kopyala
COPY --from=python-deps /usr/local/lib/python3.13/site-packages /usr/local/lib/python3.13/site-packages
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]

Bu paralel yapının derleme sürelerini nasıl iyileştirdiğini ölçelim:

# Standart sıralı derlemeyi zamanlayın
time docker build -t myapp:standard -f Dockerfile.standard .

# Buildx ile paralel optimize derlemeyi zamanlayın
time docker buildx build --load -t myapp:parallel -f Dockerfile.parallel .

Referans olarak, standart derleme 18.48 saniye sürerken paralel derleme yalnızca 1.17 saniye sürdü!

Daha iyi performans için,

--cache-from ve --cache-to bayraklarını kullanarak yerel disk önbelleğinden yararlanmayı deneyebilirsiniz:

# İlk derleme - önbellek oluşturun
docker buildx build --load -t myapp:latest --cache-to type=local,dest=./buildcache .

# Sonraki derlemeler - önbelleği kullanın
docker buildx build --load -t myapp:latest --cache-from type=local,src=./buildcache .

Ayrıca dikkatli .dockerignore dosyaları ile bağlam boyutunu sınırlayabilirsiniz:

# Kapsamlı bir .dockerignore oluşturun
cat > .dockerignore << 'EOF'
.git
.github
.dockerignore
.pytest_cache
__pycache__
*.pyc
*.pyo
*.pyd
.Python
venv
env
node_modules
.coverage
htmlcov
.DS_Store
EOF

Uzun lafın kısası, Dockerfile’larınızı paralelleştirmeyi göz önünde bulundurarak yapılandırıp Buildx’in gelişmiş önbelleğini kullanarak, derlemeleri beklemeye daha az, özellik geliştirmeye daha çok zaman harcayacaksınız.

Ekosistem Entegrasyonu

Docker Buildx tek başına var olmaz. Geliştirme ortamınızdaki diğer araçlarla sorunsuz entegre olacak şekilde tasarlanmıştır.

Buildx’in yerel geliştirici araçlarıyla nasıl çalıştığını ve konteyner iş akışınızı nasıl daha verimli hale getirdiğini inceleyelim.

Kubernetes derleme kümeleri

Kubernetes, bir küme genelinde dağıtılmış Docker Buildx işlemleri yürütmek için güçlü yetenekler sunar. Buildx’i Kubernetes ile entegre ettiğinizde, projenizin ihtiyaçlarıyla ölçeklenen daha hızlı ve daha dayanıklı derlemeler elde edebilirsiniz.

> Kubernetes’e yeni misiniz? Kubernetes vs Docker: Her Geliştiricinin Bilmesi Gereken Farklar yazısı sıradaki durağınız.

Derleme altyapınız için Kubernetes kullanmak birkaç avantaj sunar:

  1. Otomatik ölçekleme: Kubernetes, talebe göre oluşturucu düğümlerinizi ölçekleyebilir, kaynakları küme genelinde verimli biçimde tahsis eder. Hatta CPU kullanımına dayalı otomatik ölçekleme kuralları belirleyebilirsiniz.
  2. Kaynak optimizasyonu: Kubernetes zamanlayıcısı, tek tek düğümleri zorlamadan derlemelerinizin ihtiyaç duyduğu kaynakları almasını sağlar. Tutarlı performans için kaynak sınırları ve istekler belirleyebilirsiniz.
  3. Yüksek erişilebilirlik: BuildKit örneklerini birden fazla düğüme dağıtarak, bireysel düğümler başarısız olsa bile derleme altyapınız erişilebilir kalır.
  4. Tutarlı ortamlar: Her ekip üyesi aynı derleme altyapısına bağlanır ve “benim makinemde çalışıyor” sorunları ortadan kalkar.
  5. Paralel yürütme: Birçok aşaması olan karmaşık derlemeler, birden çok düğümde paralel çalışabilir ve derleme sürelerini önemli ölçüde azaltır. Yerelde 15 dakika sürecek bir proje, dağıtılmış halde 3-4 dakikada tamamlanabilir.

Bunu daha "teorik" bir bölüm olarak değerlendirin; zira Kubernetes’e daha derinlemesine dalmak başlı başına ileri düzey bir konudur.

Başlamak için, buildkit-deployment.yaml adlı bir dosya oluşturun ve aşağıdaki içeriği ekleyin:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: buildkit
  namespace: buildkit
spec:
  replicas: 3
  selector:
    matchLabels:
      app: buildkit
  template:
    metadata:
      labels:
        app: buildkit
    spec:
      containers:
      - name: buildkit
        image: moby/buildkit:latest
        args:
        - --addr
        - tcp://0.0.0.0:1234
        ports:
        - containerPort: 1234
        securityContext:
          privileged: true
---
apiVersion: v1
kind: Service
metadata:
  name: buildkit
  namespace: buildkit
spec:
  type: ClusterIP
  ports:
  - port: 1234
    targetPort: 1234
  selector:
    app: buildkit

Bir sonraki adım bu dosyayı Kubernetes kümenize uygulamaktır:

kubectl create namespace buildkit
kubectl apply -f buildkit-deployment.yaml

Son olarak, yerel makinenizden bu dağıtıma bağlanın:

docker buildx create --name k8s-builder \
  --driver remote \
  --driver-opt endpoint=tcp://<cluster-ip>:1234 \
  --use

Ve hepsi bu kadar; hazırsınız!

IDE eklenti desteği

Visual Studio Code gibi IDE’ler, Docker uzantısı aracılığıyla Docker Buildx ile mükemmel entegrasyon sunar. Bu entegrasyon, Buildx iş akışlarınızı doğrudan geliştirme ortamınızdan yönetmeyi kolaylaştırır.

VS Code’da Docker Buildx ile başlamak için VS Code marketplace’ten "Docker" uzantısını yükleyin.

Kurulduktan sonra birkaç Buildx’e özgü özelliğe sahip olursunuz:

  • Herhangi bir Dockerfile’a sağ tıklayıp Buildx’i destekleyen "Build Image..." bağlam menüsüne erişebilirsiniz.
  • UI üzerinden derleme argümanlarına, platform hedeflerine ve çıktı seçeneklerine erişim.
  • Farklı oluşturucu örneklerini yönetme ve aralarında geçiş yapma olanağı.
  • Karmaşık Buildx komutlarını çalıştırmak için VS Code terminali ile entegrasyon.

Görsel 12 - VSCode için Docker uzantısı

Görsel 11 - VSCode için Docker uzantısı

Buildx’i kullanmak için VS Code görevlerini özelleştirmeye bir örnek olarak .vscode/tasks.json dosyası oluşturma:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Docker: Buildx Build",
      "type": "shell",
      "command": "docker buildx build --load -t ${input:imageName} .",
      "group": {
        "kind": "build",
        "isDefault": true
      }
    },
    {
      "label": "Docker: Buildx Multi-Platform",
      "type": "shell",
      "command": "docker buildx build --platform linux/amd64,linux/arm64 -t ${input:imageName} ."
    }
  ],
  "inputs": [
    {
      "id": "imageName",
      "description": "Image name (with tag):",
      "default": "myapp:latest",
      "type": "promptString"
    }
  ]
}

Bu yapılandırmayla, VS Code Görevler menüsünden (Terminal > Run Task) yaygın Buildx komutlarına hızla erişebilirsiniz. Uzantı ayrıca Dockerfile’lar için yararlı sözdizimi vurgulaması ve yaygın Docker komutları için otomatik tamamlama sağlar; tüm bunlar Buildx iş akışınızı daha üretken kılar.

Sorun Giderme ve Hata Ayıklama

Her geliştirme aracı bazen (fazla sık) sorun gidermeye ihtiyaç duyar ve Docker Buildx de bir istisna değil. Bu bölümde, sizi hızla tekrar yola döndürebilmeniz için birkaç yaygın sorunu ve nasıl teşhis edileceğini anlatacağım.

Yaygın sorunlar ve çözümleri

Buildx ile çalışırken birkaç yaygın zorlukla karşılaşabilirsiniz. En sık görülen sorunlar ve çözümleri şunlardır:

  • Oluşturucu oluşturma başarısız. docker buildx create ile bir oluşturucu oluştururken hata görüyorsanız, Docker sürümünüzü kontrol edin:
docker version

Buildx, Docker 19.03 veya daha yenisini gerektirir. Daha eski bir sürüm kullanıyorsanız, Buildx özelliklerine erişmek için Docker’ı yükseltin.

“no such plugin” hataları için, şunu çalıştırarak Buildx’in düzgün kurulu olduğundan emin olun:

docker buildx version
  • Çok platformlu derleme hataları. Birden çok platform için derlerken "exec format error" veya "no matching manifest" gibi hatalar alıyorsanız QEMU’nun kurulu olup olmadığını kontrol edin:
docker buildx inspect --bootstrap

Gerekirse platform öykünücülerini kurun:

docker run --privileged --rm tonistiigi/binfmt --install all
  • Önbellekle ilgili sorunlar. Önbellekleme ile ilgili sorunlarda yerel derleme önbelleğinizi temizlemeyi deneyin:
# Belirli bir oluşturucunun önbelleğini kaldırın
docker buildx prune -b mybuilder

# Tüm derleme önbelleklerini kaldırın
docker buildx prune --all

> Docker prune komutu tam olarak nedir? Bir sürü pratik örnekle öğrenin.

  • BuildKit daemon bağlantı sorunları. "failed to solve" veya bağlantı hataları görürseniz oluşturucuyu yeniden başlatın:
docker buildx rm mybuilder
docker buildx create --name mybuilder --use
docker buildx inspect --bootstrap
  • Performansla ilgili sorunlar. Yavaş derlemelerde, darboğazları belirlemek için debug çıktısını deneyin:
docker buildx build --progress=plain --no-cache .

Bu ayrıntılı çıktı, en çok zaman alan derleme aşamalarını belirlemenize yardımcı olur ve Dockerfile’ınızı buna göre optimize etmenizi sağlar.

  • "Load" komutu hataları. Çok platformlu derlemelerde --load kullanırken "error: docker exporter does not currently support exporting manifest lists" hatası alırsanız, Docker daemon’ına aynı anda birden çok platform yüklemenin desteklenmediğini unutmayın. Bunun yerine:
# Geçerli platformunuz için derleyin ve yükleyin
docker buildx build --platform linux/amd64 --load -t myapp:latest .
  • Hata ayıklama uygulamaları. Daha karmaşık sorunlarda şu yaklaşımlar yardımcı olur:
# BuildKit debug günlüklerini etkinleştirin
BUILDKIT_DEBUG=1 docker buildx build .

# Oluşturucunun iç durumunu inceleyin
docker buildx inspect

# Sistem gereksinimlerini kontrol edin
docker info

# Belirli aşama hatalarında yalnızca o aşamaya kadar derleyin
docker buildx build --target problem-stage .

# Docker bağlamınızı doğrulayın
docker context ls

Bu sorun giderme adımlarını sistematik olarak uygulayarak çoğu Buildx sorununu çözebilir ve verimli bir konteyner derleme iş akışını sürdürebilirsiniz.

Docker Buildx Rehberinin Özeti

Bu Docker Buildx yazısında epey yol kat ettik! Bu güçlü aracın konteyner derlemelerinizi nasıl daha hızlı ve daha esnek hale getirebileceğini gördünüz.

Unutmayın, temel avantajlar şunlar: Tek bir komutla birden çok platform için imaj oluşturabilir, gelişmiş önbellekleme ile derlemeleri hızlandırabilir ve doğru sır yönetimiyle imajlarınızı güvenli tutabilirsiniz. Özellikle Dockerfile’larınızı paralel derlemeyi göz önünde bulundurarak yapılandırdığınızda performans iyileştirmeleri gerçektir.

Ben M çipli Macbook’umda sürekli kullanıyorum; çünkü tüm imajlar ARM için mevcut değil.

İster tek başına bir geliştirici olun ister büyük bir ekibin parçası, Buildx iş akışınıza uyan araçlar sunar. Derlemeleri yerelde çalıştırabilir, konteynerlere dağıtabilir veya ihtiyaçlarınız arttıkça Kubernetes kümelerine ölçekleyebilirsiniz.

Docker ve Docker Buildx hakkında daha fazla bilgi edinmek için aşağıdaki DataCamp kurslarına kaydolmanızı öneririm:

Dario Radečić

Yazar

Dario Radečić

LinkedIn
Hırvatistan merkezli Kıdemli Veri Bilimci. 700’ün üzerinde yayımlanmış makaleyle 10 M+ görüntüleme elde eden, önde gelen bir teknoloji yazarı. TPOT ile Makine Öğrenimi Otomasyonu kitabının yazarı.

Konular

Docker

İlgili

Devamını Gör →