Docker Buildx: Cara Membangun Citra Kontainer Multi-Platform

Kasus Penggunaan Lanjutan

Sejauh ini, saya telah menunjukkan perintah dan kasus penggunaan Buildx dasar. Masih banyak lagi yang bisa dilakukan Buildx, dengan beberapa fitur yang mustahil diterapkan dengan builder klasik.

Mari jelajahi beberapa teknik lanjutan untuk membawa alur kerja kontainerisasi Anda ke level berikutnya.

Optimasi build multi-tahap

Build multi-tahap adalah salah satu fitur paling kuat dari Docker untuk membuat citra yang efisien, dan Buildx membuatnya semakin baik.

Untuk demonstrasi, mari buat aplikasi Python yang dioptimalkan dengan beberapa tahap:

# 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"]Didukung oleh

Dengan Buildx, Anda dapat membangunnya lebih efisien:

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

Gambar 9 - Build multi-tahap

Jadi, apa yang membuatnya istimewa? Buildx memproses tahap-tahap yang independen secara paralel. Sementara builder lama mengeksekusi setiap tahap berurutan, Buildx mengidentifikasi bahwa tahap linter dan tester tidak saling bergantung dan membangunnya secara simultan.

Satu manfaat tambahan dari optimasi build ini adalah pengurangan ukuran berkas. Anda dapat memverifikasi ukuran citra dengan menjalankan:

docker images myappDidukung oleh

Anda akan melihat sesuatu seperti ini:

Gambar 10 - Ukuran citra Docker

Citra final berbasis alpine jauh lebih kecil.

Integrasi pipeline CI/CD

Saat Anda bekerja secara lokal, Anda tetap bisa menyiapkan konfigurasi Buildx yang mencerminkan lingkungan CI/CD Anda.

Sebagai awal, buat berkas .dockerignore untuk menjaga build tetap bersih:

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

Lalu buat skrip build yang meniru apa yang mungkin dilakukan pipeline CI Anda:

#!/bin/bash
# build.sh - Simulasi CI/CD lokal

echo "Starting CI/CD build process..."

# Menyiapkan builder dengan dukungan emulasi
echo "Setting up builder..."
docker buildx create --name cibuilder --use || true
docker buildx inspect --bootstrap

# Jalankan linting
echo "Running lint stage..."
docker buildx build --file Dockerfile.optimized --target linter .

# Jalankan tes
echo "Running test stage..."
docker buildx build --file Dockerfile.optimized --target tester .

# Build untuk banyak platform
echo "Building multi-platform image..."
docker buildx build --file Dockerfile.optimized \
  --platform linux/amd64,linux/arm64 \
  --tag myapp:$(date +%Y%m%d) \
  --tag myapp:latest \
  --load \
  --progress=plain \
  .

echo "Build process complete!"Didukung oleh

Singkatnya, skrip ini melakukan hal berikut:

• Membuat builder khusus untuk CI/CD.
• Menjalankan tahap linting.
• Menjalankan tahap pengujian.
• Membangun citra final multi-platform dengan tag versi.

Sekarang bagian yang menyenangkan — buat skrip dapat dieksekusi dan jalankan:

chmod +x build.sh
./build.shDidukung oleh

Pengeditan lokal

Kendala umum saat bekerja dengan Docker adalah setiap kali Anda mengubah berkas sumber, Anda harus membangun ulang citra dan menjalankan kontainer. Ini terlalu memakan waktu.

Kabar baiknya: untuk pengembangan lokal dengan iterasi lebih cepat, Anda dapat membuat versi pengembangan:

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

RUN pip install flask psutil python-dotenv

# Instal alat pengembangan
RUN pip install pytest pylint watchdog

# Mount kode aplikasi saat runtime alih-alih menyalin
CMD ["python", "app.py"]Didukung oleh

Jalankan dengan mount volume untuk live reloading kode:

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

Sekarang Anda bisa mengedit berkas app.py secara lokal, dan perubahan akan langsung tercermin di kontainer yang berjalan!

Selanjutnya, mari bahas performa.

Pertimbangan Performa

Tidak ada yang suka alur kerja pengembangan yang lambat, dan kekuatan paralelisasi dengan Docker Buildx dapat membantu.

Mari jelajahi cara mengoptimalkan build Anda dan memanfaatkan fitur performa Buildx untuk membuat citra lebih cepat.

Teknik paralelisasi build

Salah satu keunggulan terbesar Buildx adalah kemampuannya membangun tahap secara paralel. Builder Docker tradisional mengeksekusi setiap langkah berurutan, tetapi Buildx menganalisis Dockerfile Anda dan mengidentifikasi langkah mana yang dapat dijalankan bersamaan.

Untuk demonstrasi, saya akan menggunakan dua berkas — Dockerfile.standard dan Dockerfile.parallel. Berikut isi keduanya:

Dockerfile.standard

FROM python:3.13-slim
WORKDIR /app

# System dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

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

# Application code
COPY app.py .

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

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

Dockerfile.parallel

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

# Independent stage for installing system dependencies
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/*

# Independent stage for installing Python dependencies
FROM python-base AS python-deps
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Independent stage for static code analysis
FROM python-deps AS linting
COPY app.py .
RUN pip install pylint && pylint app.py || true

# Final stage that combines dependencies
FROM python-base AS final
# Copy from system deps stage
COPY --from=system-deps /usr/bin/gcc /usr/bin/gcc
# Copy from Python deps stage
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"]Didukung oleh

Mari ukur bagaimana struktur paralel ini meningkatkan waktu build:

# Ukur waktu build berurutan standar
time docker build -t myapp:standard -f Dockerfile.standard .

# Ukur waktu build yang dioptimalkan paralel dengan Buildx
time docker buildx build --load -t myapp:parallel -f Dockerfile.parallel .Didukung oleh

Sebagai referensi, build standar memakan waktu 18,48 detik sementara build paralel hanya 1,17 detik!

Untuk performa yang lebih baik lagi, Anda bisa mencoba menggunakan flag --cache-from dan --cache-to untuk memanfaatkan caching disk lokal:

# Build pertama - buat cache
docker buildx build --load -t myapp:latest --cache-to type=local,dest=./buildcache .

# Build selanjutnya - gunakan cache
docker buildx build --load -t myapp:latest --cache-from type=local,src=./buildcache .Didukung oleh

Anda juga dapat membatasi ukuran konteks dengan berkas .dockerignore yang cermat:

# Buat .dockerignore yang komprehensif
cat > .dockerignore << 'EOF'
.git
.github
.dockerignore
.pytest_cache
__pycache__
*.pyc
*.pyo
*.pyd
.Python
venv
env
node_modules
.coverage
htmlcov
.DS_Store
EOFDidukung oleh

Singkatnya, dengan menata Dockerfile Anda dengan pemikiran paralelisasi dan memanfaatkan caching tingkat lanjut Buildx, Anda akan menghabiskan lebih sedikit waktu menunggu build dan lebih banyak waktu mengembangkan fitur.

Integrasi Ekosistem

Docker Buildx tidak berdiri sendiri. Buildx dibangun untuk berintegrasi mulus dengan alat lain di lingkungan pengembangan Anda.

Mari jelajahi bagaimana Buildx bekerja dengan alat pengembang lokal dan membuat alur kerja kontainer Anda lebih efisien.

Klaster build Kubernetes

Kubernetes menawarkan kapabilitas kuat untuk menjalankan operasi Docker Buildx terdistribusi di seluruh klaster. Saat mengintegrasikan Buildx dengan Kubernetes, Anda bisa mendapatkan build yang lebih cepat dan tangguh yang dapat diskalakan sesuai kebutuhan proyek.

> Baru di Kubernetes? Baca Kubernetes vs Docker: Perbedaan yang Perlu Diketahui Setiap Pengembang sebagai langkah berikutnya.

Menggunakan Kubernetes untuk infrastruktur build menawarkan beberapa keuntungan:

1. Penskalaan otomatis: Kubernetes dapat menaikkan atau menurunkan skala node builder berdasarkan permintaan, mengalokasikan sumber daya secara efisien di seluruh klaster. Anda bahkan dapat menetapkan aturan autoscaling berdasarkan utilisasi CPU.
2. Optimasi sumber daya: Penjadwalan Kubernetes memastikan build Anda mendapatkan sumber daya yang dibutuhkan tanpa membebani node individual. Anda dapat menetapkan limit dan request sumber daya untuk kinerja yang konsisten.
3. High availability: Dengan mendistribusikan instance BuildKit di beberapa node, infrastruktur build Anda tetap tersedia bahkan jika ada node yang gagal.
4. Lingkungan konsisten: Setiap anggota tim terhubung ke infrastruktur build yang sama, menghilangkan masalah "berfungsi di mesin saya".
5. Eksekusi paralel: Build kompleks dengan banyak tahap dapat berjalan paralel di beberapa node, secara signifikan mengurangi waktu build. Proyek yang mungkin butuh 15 menit dibangun secara lokal bisa selesai dalam 3–4 menit saat terdistribusi.

Anggap bagian ini lebih "teoretis", karena menggali lebih dalam Kubernetes adalah topik lanjutan tersendiri.

Untuk memulai, buat berkas bernama buildkit-deployment.yaml dengan isi berikut:

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: buildkitDidukung oleh

Langkah berikutnya adalah menerapkan berkas ini ke klaster Kubernetes Anda:

kubectl create namespace buildkit
kubectl apply -f buildkit-deployment.yamlDidukung oleh

Terakhir, sambungkan ke deployment ini dari mesin lokal Anda:

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

Dan selesai, Anda siap melanjutkan!

Dukungan plugin IDE

IDE seperti Visual Studio Code menawarkan integrasi yang sangat baik dengan Docker Buildx melalui ekstensi Docker-nya. Integrasi ini memudahkan pengelolaan alur kerja Buildx langsung dari lingkungan pengembangan Anda.

Untuk memulai Docker Buildx di VS Code, instal ekstensi "Docker" dari marketplace VS Code.

Setelah terpasang, Anda akan mendapatkan beberapa fitur khusus Buildx:

• Klik kanan pada Dockerfile mana pun untuk melihat menu konteks dengan opsi "Build Image..." yang mendukung Buildx.
• Akses argumen build, target platform, dan opsi output melalui antarmuka.
• Kemampuan mengelola dan beralih antar instance builder yang berbeda.
• Integrasi dengan terminal VS Code untuk menjalankan perintah Buildx yang kompleks.

Gambar 11 - Ekstensi Docker untuk VSCode

Berikut contoh kustomisasi tugas VS Code untuk menggunakan Buildx dengan membuat berkas .vscode/tasks.json:

{
  "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"
    }
  ]
}Didukung oleh

Dengan konfigurasi ini, Anda dapat dengan cepat mengakses perintah Buildx yang umum dari menu Tasks VS Code (Terminal > Run Task). Ekstensi juga menyediakan penyorotan sintaks untuk Dockerfile dan pelengkapan otomatis untuk perintah Docker umum, yang semuanya membuat alur kerja Buildx Anda lebih produktif.

Pemecahan Masalah dan Debugging

Setiap alat pengembangan terkadang (terlalu sering) butuh pemecahan masalah, dan Docker Buildx tidak terkecuali. Di bagian ini, saya akan memandu Anda melalui beberapa masalah umum agar Anda bisa mendiagnosisnya sendiri dengan cepat dan kembali ke jalur semula.

Masalah umum dan penyelesaiannya

Saat bekerja dengan Buildx, Anda mungkin menemui beberapa tantangan umum. Berikut masalah yang paling sering terjadi dan solusinya:

• Pembuatan builder gagal. Jika Anda melihat galat saat membuat builder dengan docker buildx create, periksa versi Docker Anda:

docker versionDidukung oleh

Buildx memerlukan Docker 19.03 atau lebih baru. Jika Anda menggunakan versi lebih lama, tingkatkan Docker untuk mengakses fitur Buildx.

Untuk galat "no such plugin", pastikan Buildx terinstal dengan benar dengan menjalankan:

docker buildx versionDidukung oleh

• Kegagalan build multi-platform. Saat membangun untuk beberapa platform dengan galat seperti "exec format error" atau "no matching manifest", periksa apakah QEMU terpasang:

docker buildx inspect --bootstrapDidukung oleh

Jika perlu, pasang emulator platform:

docker run --privileged --rm tonistiigi/binfmt --install allDidukung oleh

• Masalah terkait cache. Untuk masalah caching, coba bersihkan cache build lokal Anda:

# Hapus cache builder tertentu
docker buildx prune -b mybuilder

# Hapus semua cache build
docker buildx prune --allDidukung oleh

> Apa sebenarnya perintah Docker prune? Pelajari dengan banyak contoh praktik.

• Masalah koneksi daemon BuildKit. Jika Anda melihat "failed to solve" atau galat koneksi, mulai ulang builder:

docker buildx rm mybuilder
docker buildx create --name mybuilder --use
docker buildx inspect --bootstrapDidukung oleh

• Masalah terkait performa. Untuk build yang lambat, coba output debug untuk mengidentifikasi bottleneck:

docker buildx build --progress=plain --no-cache .Didukung oleh

Output verbose ini membantu menelusuri tahap build mana yang paling memakan waktu, sehingga Anda bisa mengoptimalkan Dockerfile sesuai kebutuhan.

• Kegagalan perintah "load". Jika Anda menemui "error: docker exporter does not currently support exporting manifest lists" saat menggunakan --load dengan build multi-platform, ingat bahwa memuat banyak platform ke daemon Docker secara simultan tidak didukung. Sebagai gantinya:

# Build untuk platform Anda saat ini dan muat
docker buildx build --platform linux/amd64 --load -t myapp:latest .Didukung oleh

• Praktik debugging. Untuk masalah yang lebih kompleks, pendekatan debugging berikut akan membantu:

# Aktifkan log debug BuildKit
BUILDKIT_DEBUG=1 docker buildx build .

# Inspeksi status internal builder
docker buildx inspect

# Periksa persyaratan sistem
docker info

# Untuk kegagalan tahap tertentu, build hanya sampai tahap itu
docker buildx build --target problem-stage .

# Verifikasi konteks Docker Anda
docker context lsDidukung oleh

Dengan bekerja sistematis melalui langkah-langkah pemecahan masalah ini, Anda dapat menyelesaikan sebagian besar isu Buildx dan menjaga alur kerja build kontainer tetap efisien.

Ringkasan Panduan Docker Buildx

Kita telah membahas banyak hal dalam artikel Docker Buildx ini! Anda telah melihat bagaimana alat yang kuat ini dapat membuat build kontainer lebih cepat dan lebih fleksibel.

Ingat manfaat utamanya: Anda dapat membangun citra untuk banyak platform dengan satu perintah, mempercepat build dengan caching tingkat lanjut, dan menjaga citra tetap aman dengan pengelolaan secret yang tepat. Peningkatan performanya nyata, terutama saat Anda menata Dockerfile untuk memanfaatkan build paralel.

Saya menggunakannya sepanjang waktu di Macbook chip M, karena tidak semua citra tersedia untuk ARM.

Baik Anda pengembang solo atau bagian dari tim besar, Buildx memberi Anda alat yang sesuai dengan alur kerja. Anda dapat menjalankan build secara lokal, mendistribusikannya ke kontainer, atau bahkan menskalakan ke klaster Kubernetes sesuai kebutuhan yang berkembang.

Untuk mempelajari lebih lanjut tentang Docker dan Docker Buildx, saya merekomendasikan mendaftar ke kursus DataCamp berikut:

• Konsep Kontainerisasi dan Virtualisasi
• Pengantar Docker
• Docker Menengah
• Kontainerisasi dan Virtualisasi dengan Docker dan Kubernetes
• CI/CD untuk Machine Learning