COPY --link adalah fitur BuildKit baru yang secara substansial dapat mempercepat pembuatan gambar Docker Anda. Ia bekerja dengan menyalin file ke lapisan gambar independen yang tidak bergantung pada kehadiran pendahulunya. Anda dapat menambahkan konten baru ke gambar tanpa gambar dasar bahkan yang ada di sistem Anda.



Kemampuan ini ditambahkan sebagai bagian dari Buildx v0.8 pada Maret 2022. Ini termasuk dalam versi 20.10.14 dari Docker CLI sehingga Anda seharusnya sudah memiliki akses jika Anda menjalankan rilis terbaru.



Dalam artikel ini, kami akan menunjukkan apa yang dilakukan --link dan menjelaskan cara kerjanya. Kita juga akan melihat beberapa situasi di mana seharusnya tidak digunakan.

Apa Itu “–link”?


--link adalah argumen opsional baru untuk instruksi Dockerfile COPY yang ada. Ini mengubah cara kerja salinan dengan membuat layer snapshot baru setiap kali Anda menggunakannya.



Pernyataan COPY Reguler menambahkan file ke layer yang mendahuluinya di Dockerfile. Isi lapisan itu harus ada di disk Anda sehingga konten baru dapat digabungkan di:

FROM alpine SALIN file-saya /file-saya SALIN file lain /file-lai

Dockerfile di atas menyalin file-saya ke dalam lapisan yang dihasilkan oleh perintah sebelumnya. Setelah instruksi FROM, gambar terdiri dari konten Alpine:

bin/ dev/ etc/ ...

Instruksi COPY pertama menghasilkan gambar yang mencakup segala sesuatu dari Alpine, serta file my-file:

my-file bin/ dev/ etc/ ...

Dan instruksi COPY kedua menambahkan file lain di atas gambar ini:

another-file my-file bin/ dev/ etc/ ...

Lapisan yang dihasilkan oleh setiap instruksi mencakup semua yang ada sebelumnya, juga sebagai sesuatu yang baru ditambahkan. Di akhir build, Docker menggunakan proses diffing untuk mengerjakan perubahan di dalam setiap layer. Gumpalan gambar akhir hanya berisi file yang ditambahkan di setiap tahap snapshot tetapi ini tidak tercermin dalam proses perakitan selama build.

Memperkenalkan “–link”


“–link” memodifikasi COPY untuk membuat sistem file mandiri baru setiap kali digunakan. Alih-alih menyalin file baru di atas lapisan sebelumnya, mereka dikirim ke lokasi yang sama sekali berbeda untuk menjadi lapisan independen. Lapisan kemudian dihubungkan bersama untuk menghasilkan gambar akhir.



Mari kita ubah contoh Dockerfile menjadi --link:

FROM alpine COPY --link my-file /my-file COPY --link another-file /another-file

Hasil dari FROM instruksi tidak berubah – ia menghasilkan lapisan Alpine, dengan semua konten gambar itu:

bin/ dev/ etc/ ...

Instruksi COPY pertama memiliki efek yang sangat berbeda. Kali ini lapisan independen lain dibuat. Ini adalah sistem file baru yang hanya berisi file-saya:

my-file

Kemudian instruksi COPY kedua membuat snapshot baru lainnya dengan hanya file lain:

another-file

Ketika pembangunan selesai, Docker menyimpan snapshot independen ini sebagai arsip lapisan baru (tarball). Tarbal dihubungkan kembali ke rantai lapisan sebelumnya, membangun gambar akhir. Ini terdiri dari ketiga snapshot yang digabungkan bersama, menghasilkan sistem file yang cocok dengan yang asli saat kontainer dibuat:

my-file another-file bin/ dev/ etc/ ...

Gambar ini dari proyek BuildKit mengilustrasikan perbedaan antara keduanya approach.





Menambahkan “COPY –link” ke Builds Anda


COPY --link hanya tersedia saat Anda menggunakan BuildKit untuk membuat gambar. Jalankan build Anda dengan docker buildx --create atau gunakan docker build dengan variabel lingkungan DOCKER_BUILDKIT=1 set.



Anda juga harus ikut serta ke sintaks Dockerfile v1.4 menggunakan komentar di bagian atas file Anda:

# syntax= docker/dockerfile:1.4 FROM alpine:latest COPY --link my-file /my-file COPY --link another-file /another-file

Sekarang Anda dapat membuat gambar Anda dengan dukungan untuk salinan tertaut:

DOCKER_BUILDKIT=1 docker build -t my -image:.

Images terbaru yang dibuat dari Dockerfiles menggunakan COPY --link dapat digunakan seperti yang lain. Anda dapat memulai wadah dengan menjalankan buruh pelabuhan dan mendorongnya langsung ke pendaftar. Bendera --link hanya memengaruhi cara konten ditambahkan ke lapisan gambar selama pembuatan.

Mengapa Salinan Tertaut Penting


Menggunakan tanda --link memungkinkan cache build digunakan kembali bahkan ketika konten yang Anda SALIN dalam perubahan. Selain itu, build mungkin dapat diselesaikan tanpa image dasarnya meskipun sudah ada di mesin Anda.



Kembali ke contoh di atas, perilaku COPY standar mengharuskan image alpine ada di host Docker Anda sebelum konten baru dapat ditambahkan. Gambar akan diunduh secara otomatis selama pembuatan jika Anda belum pernah menariknya.



Dengan salinan tertaut, Docker tidak memerlukan konten gambar alpine. Itu menarik manifes alpine, membuat lapisan independen baru untuk file yang disalin, lalu membuat manifes yang direvisi yang menghubungkan lapisan ke lapisan yang disediakan oleh alpine. Konten gambar alpine – gumpalan lapisannya – hanya akan diunduh jika Anda memulai wadah dari gambar baru Anda atau mengekspornya ke arsip tar. Saat Anda mendorong gambar ke registri, registri itu akan menyimpan lapisan barunya dan memperoleh lapisan alpine dari jarak jauh.



Fungsi ini juga memfasilitasi rebase gambar yang efisien. Mungkin saat ini Anda sedang mendistribusikan image Docker menggunakan rilis terbaru Ubuntu 20.04 LTS:

FROM golang AS build ... RUN go build -o /app . DARI ubuntu:20.04 SALIN --link --from=build /app /bin/app ENTRYPOINT ["/bin/app"]

Anda dapat membuat gambar dengan caching diaktifkan menggunakan flag --cache-to BuildKit. Cache inline menyimpan data cache build di dalam gambar keluaran, yang dapat digunakan kembali di build berikutnya:

docker buildx build --cache-to type=inline -t example-image:20.04 .

Sekarang katakanlah Anda ingin memberikan gambar yang didasarkan pada LTS berikutnya setelah dirilis, Ubuntu 22.04:

FROM golang AS build ... RUN go build -o /app . DARI ubuntu:22.04 SALIN --link --from=build /app /bin/app ENTRYPOINT ["/bin/app"]

Rebuild gambar menggunakan data cache yang disematkan dalam versi asli:

docker buildx build --cache-from contoh -image:20.04 -t example-image:22.04 .

Build akan selesai hampir seketika. Menggunakan data cache dari gambar yang ada, Docker dapat memverifikasi file yang diperlukan untuk membangun / aplikasi tidak berubah. Ini berarti cache untuk lapisan independen yang dibuat oleh instruksi COPY tetap valid. Karena lapisan ini tidak bergantung pada yang lain, gambar ubuntu:22.04 juga tidak akan ditarik. Docker hanya menautkan lapisan snapshot yang berisi /bin/app ke dalam manifes baru di dalam rantai lapisan ubuntu:22.04. Lapisan snapshot secara efektif "didasarkan ulang" ke gambar induk baru, tanpa operasi sistem file apa pun yang terjadi.



Model ini juga mengoptimalkan pembangunan multi-tahap di mana perubahan dapat terjadi di antara setiap tahap:

FROM golang AS build RUN go build -o /app . DARI config-builder AS config RUN generate-config --out /config.yaml DARI ubuntu:latest COPY --link --from=config /config.yaml build.conf COPY --link --from=build /app /bin /app

Without --link, setiap perubahan pada config.yaml yang dihasilkan menyebabkan ubuntu:latest ditarik dan file akan disalin. Biner kemudian harus dikompilasi ulang karena cache-nya tidak valid oleh perubahan sistem file. Dengan salinan tertaut, perubahan ke config.yaml memungkinkan build untuk melanjutkan tanpa menarik ubuntu:latest atau mengkompilasi ulang biner. Lapisan snapshot dengan build.conf di dalamnya hanya diganti dengan versi baru yang independen dari semua lapisan lainnya.

Ketika Tidak Digunakan


Ada beberapa situasi di mana tanda --link tidak akan berfungsi dengan benar. Karena menyalin file ke lapisan baru, alih-alih menambahkannya di atas yang sebelumnya, Anda tidak dapat menggunakan referensi ambigu sebagai jalur tujuan Anda:

COPY --link my-file /data

Dengan instruksi COPY biasa, my-file akan disalin ke /data/file-saya jika /data sudah ada sebagai direktori dalam gambar. Dengan --link, sistem file lapisan target akan selalu kosong, sehingga file saya akan ditulis ke /data.



Pertimbangan yang sama berlaku untuk resolusi symlink. SALINAN standar secara otomatis menyelesaikan jalur tujuan yang merupakan symlink dalam gambar. Saat Anda menggunakan --link, perilaku ini tidak didukung karena symlink tidak akan ada di lapisan independen salinan.



Sebaiknya Anda mulai menggunakan --link di mana pun batasan ini tidak berlaku. Mengadopsi fitur ini akan mempercepat build Anda dan membuat caching lebih kuat. Jika Anda tidak dapat segera menghapus jalur tujuan yang ambigu atau symlink, Anda dapat tetap menggunakan instruksi COPY yang ada. Karena perubahan mundur yang tidak kompatibel inilah --link adalah flag opsional, alih-alih default baru.

Summary


BuildKit's COPY --link adalah fitur Dockerfile baru yang dapat membuat build lebih cepat dan lebih efisien. Gambar yang menggunakan salinan tertaut tidak perlu menarik lapisan sebelumnya hanya agar file dapat disalin ke dalamnya. Sebagai gantinya, Docker membuat lapisan independen baru untuk setiap SALIN, lalu menautkan kembali lapisan tersebut ke dalam rantai.



Anda dapat mulai menggunakan salinan tertaut sekarang jika Anda membuat gambar dengan BuildKit dan Buildx atau Docker CLI versi terbaru. Mengadopsi “–link” adalah langkah build Docker praktik terbaik baru, asalkan Anda tidak terpengaruh oleh perubahan pada resolusi jalur tujuan yang diperlukan.



Itulah berita seputar Cara Mempercepat Pembuatan Docker dan Mengoptimalkan Caching Dengan “COPY –link”, semoga bermanfaat. Disadur dari HowToGeek.com.