Cara Menggunakan Docker Buildx Bake untuk Membuat Pipa Pembuatan Gambar Kompleks

  • Post author:
  • Post category:Tutorial

Grup perintah docker buildx menggunakan BuildKit untuk mengekspos kemampuan pembuatan gambar tingkat lanjut. Build yang dipanggang adalah fitur tingkat tinggi yang dapat digunakan untuk menentukan pipeline build otomatis. Mereka memungkinkan Anda menghasilkan banyak gambar dari satu operasi pembuatan. Alur kerja

Baked sangat membantu saat Anda ingin memublikasikan varian gambar yang berbeda atau membuat beberapa proyek tertaut secara paralel. Dalam artikel ini kita akan membahas fitur utama dari docker buildx bake dan bagaimana Anda dapat menggunakannya untuk merampingkan build yang kompleks.

Memulai

Perintah docker buildx bake mengeksekusi beberapa “target” build yang masing-masing menghasilkan gambar container. Target berjalan secara paralel jika memungkinkan untuk memaksimalkan kinerja. Target juga dapat secara langsung merujuk pendahulunya untuk membuat pipeline berurutan.

Target build dapat ditentukan menggunakan beberapa mekanisme berbeda termasuk file Docker Compose yang ada. Buildx akan secara otomatis membuat semua gambar yang diidentifikasi dalam file.

Fitur lanjutan lainnya diperlihatkan saat Anda mencantumkan target build dalam file JSON atau HCL. Variabel pendukung, fungsi, dan interpolasi nilai ini untuk menyesuaikan builds.

Anda Perintah buildx bake mencari file berikut dalam urutan:

docker-compose.ymldocker-compose.yamldocker-bake.jsondocker-bake.override.jsondocker-bake.hcldocker- bake.override.hcl

Anda dapat menentukan file yang berbeda dengan perintah -f flag.

Build Targets

Build target merangkum semua konfigurasi yang terkait dengan build Anda. Mereka menyertakan detail seperti

jalur ke file Docker untuk membangun jalur konteks pembangunan, mendefinisikan konten yang tersedia dalam file Docker Andatag dan label untuk dilampirkan ke gambar keluaran platform untuk menghasilkan gambar untuk.

Daftar lengkap bidang konfigurasi yang didukung tersedia dalam dokumentasi. Sebelumnya Anda mungkin telah menyediakan pengaturan ini sebagai flag baris perintah ke build docker buildx (atau bahkan build docker biasa), memaksa Anda untuk mengingat nilai yang benar setiap kali. Dengan buildx bake, Anda dapat dengan andal menggunakan nilai yang sama dengan mendefinisikannya di file panggang yang dikontrol versi.

Berikut adalah contoh sederhana dari perintah docker-bake.hcl yang mendefinisikan satu target build:

target “default” {
dockerfile = “aplikasi/file Docker”
konteks = {
aplikasi = “aplikasi/src”
shared = “komponen-bersama/src”
}
tags = [“aplikasi saya: terbaru”, “docker.io/my-org/aplikasi saya: terbaru”]
}

Menjalankan docker buildx bake dengan file bake ini akan memuat app/Dockerfile Dockerfile dari direktori kerja Anda. Ini akan memiliki akses ke direktori app/src dan shared-components/src sebagai konteks build. Gambar yang dihasilkan akan diberi dua tag.

Target default dibuat secara otomatis saat Anda menjalankan docker buildx bake. Anda juga dapat menentukan target bernama yang dapat dibangun sesuai permintaan:

target “app” {
// …
}$ docker buildx bake appMenggunakan Beberapa Target

Anda dapat membuat gambar lain secara bersamaan dengan mendefinisikannya sebagai target baru di dalam file panggang Anda:

group “default” {
target = [“aplikasi”, “api”]
}

target “aplikasi” {
dockerfile = “aplikasi/file Docker”
konteks = {
aplikasi = “aplikasi/src”
shared = “komponen-bersama/src”
}
tags = [“aplikasi saya: terbaru”, “docker.io/my-org/aplikasi saya: terbaru”]
}

sasaran “api” {
file docker = “api/file docker”
konteks = {
src = “api/src”
}
tags = [“api-saya:terbaru”, “docker.io/my-org/api-saya:terbaru”]
}

Gambar-gambar ini dapat dibuat secara bersamaan karena disarangkan ke dalam grup. Gambar api dan aplikasi akan dibuat secara paralel setiap kali Anda menjalankan perintah docker buildx bake karena grup default dipilih secara otomatis. Anda dapat menggunakan grup bernama mirip dengan contoh target bernama di atas.

Build Target Inheritance

Target build dapat saling mewarisi untuk menggunakan kembali konfigurasi. Satu skenario di mana ini bisa berguna menyangkut gambar yang perlu disesuaikan untuk lingkungan yang berbeda. Anda mungkin ingin menambahkan file konfigurasi tambahan ke varian gambar yang ditujukan untuk penggunaan pengembangan. Ini adalah docker-bake.hcl yang mendemonstrasikan model ini:

group “default” {
target = [“backend”, “backend-dev”]
}

target “backend” {
dockerfile = “backend/file Docker”
konteks = {
src = “api/src”
konfigurasi = “api/config”
}
tag = [“backend:terbaru”]
}

target “backend-dev” {
mewarisi = [“backend”]
konteks = {
config = “api/config-dev”
}
tag = [“backend:dev”]
}

Target backend-dev mewarisi semua properti dari target backend tetapi mengesampingkan konteks konfigurasi dan menerapkan tag yang berbeda.

Anda dapat melihat pratinjau struktur file yang digabungkan dengan menjalankan perintah bake dengan –print flag:

$ docker buildx bake – -mencetak

“backend-dev”: {
“konteks”: “.”,
“konteks”: {
“config”: “api/config-dev”,
“src”: “api/src”
},
“dockerfile”: “backend/Dockerfile”,
“tag”: [
“latar belakang: dev”
]
}
…Menggunakan Target Sebelumnya sebagai Gambar Dasar

Terkadang Anda mungkin ingin target build menggunakan gambar yang dibuat oleh target sebelumnya sebagai basisnya sendiri. Ini adalah alternatif untuk build multi-tahap yang dapat digunakan ketika Dockerfile Anda saling bergantung tetapi tidak dapat digabungkan, mungkin karena mereka ada di project yang berbeda.

group “default” {
target = [“org-base-image”, “api”]
}

target “org-base-image” {
dockerfile = “docker-base/Dockerfile”
tags = [“gambar-dasar-org:terbaru”]
}

sasaran “api” {
file docker = “api/file docker”
konteks = {
base = “target: org-base-image”
}
tag = [“api:terbaru”]
}

Contoh pertama-tama membangun target gambar-dasar-org. Ini dapat berisi beberapa utilitas yang umum untuk beban kerja kemas organisasi Anda. Target api kemudian dibangun dengan output dari target org-base-image yang dapat diakses sebagai konteks build dasar. API Dockerfile sekarang dapat mereferensikan konten di dalam gambar dasar:

COPY –from=base /utilities/example /usr/bin/example-utility

Ini adalah pola yang kuat yang memungkinkan Anda membuat tautan ketergantungan antara gambar sambil mempertahankan Dockerfiles.

Overriding Properties yang terpisah dari Target pada Waktu Pembuatan

Perintah docker buildx bake memungkinkan Anda mengganti properti target saat menjalankan build:

$ docker buildx bake –set api.dockerfile=”api/Dockerfile-dev”

Contoh ini mengubah Dockerfile dari target api. Wildcard * didukung saat mengidentifikasi target yang akan diubah. * dengan sendirinya memilih setiap target sementara api* akan memodifikasi semua target yang dimulai dengan api.

Setting Variables

HCL file dapat menentukan variabel yang dapat Anda rujuk dalam target build Anda. gunakan blok variabel untuk menyiapkannya:

variable “TAG” {
default = “terbaru”
}

grup “bawaan” {
target = [“aplikasi”]
}

target “aplikasi” {
dockerfile = “src/Dockerfile”
tags = [“aplikasi saya:${TAG}”]
}

Menjalankan docker buildx bake dengan konfigurasi ini akan menandai target aplikasi sebagai my-app:latest. Anda dapat mengubah nilai variabel TAG dengan menyetel variabel lingkungan sebelum menjalankan perintah:

$ TAG=v1 docker buildx bake

Anda dapat menggunakan semua interpolasi variabel dan kemampuan perbandingan bahasa HCL untuk membuat target build Anda dapat digunakan kembali. Fungsi juga tersedia untuk menguraikan dan mengubah nilai Anda. Buildx

Kesimpulan

Baked Buildx memungkinkan Anda merangkum konfigurasi build gambar sebagai “target” yang ditentukan dalam file. Saat Anda menjalankan buildx bake, gambar untuk semua target yang direferensikan dibuat secara paralel.

Target dapat mewarisi dan bergantung satu sama lain. Anda juga dapat menggunakan variabel dan fungsi untuk membuat pipeline build yang sangat kompleks dan dapat dikonfigurasi.

Perintah docker buildx bake adalah operasi tingkat tinggi yang tidak diperlukan di setiap alur kerja. Anda tidak perlu menggunakannya saat membuat gambar sederhana tanpa ketergantungan lintas proyek. Menggunakan build docker compose adalah alternatif yang lebih baik untuk sebagian besar kasus penggunaan yang menyimpan konfigurasi build di file docker-compose.yml Anda. Beralih ke build yang dipanggang harus dipertimbangkan saat Anda membuat banyak gambar secara bersamaan menggunakan variabel yang berbeda, platform, konteks build, dan config overrides.

Itulah berita seputar Cara Menggunakan Docker Buildx Bake untuk Membuat Pipa Pembuatan Gambar Kompleks, semoga bermanfaat. Disadur dari HowToGeek.com.