Interaksi sehari-hari dengan Bazel terjadi terutama melalui beberapa perintah:
build
, test
, dan run
. Namun, terkadang hal ini mungkin terasa terbatas: Anda mungkin ingin mengirim paket ke repositori, memublikasikan dokumentasi untuk pengguna akhir, atau men-deploy aplikasi dengan Kubernetes. Namun, Bazel tidak memiliki perintah publish
atau
deploy
– sesuai dengan tindakan ini?
Perintah {i>bazel run<i}
Fokus Bazel pada hermetisitas, reproduksi, dan inkrementalitas berarti
perintah build
dan test
tidak berguna untuk tugas di atas. Tindakan ini
dapat berjalan di sandbox, dengan akses jaringan terbatas, dan tidak dijamin akan
dijalankan ulang dengan setiap bazel build
.
Sebagai gantinya, andalkan bazel run
: pekerja keras untuk tugas yang ingin Anda beri
efek samping. Pengguna Bazel sudah terbiasa dengan aturan yang membuat file yang dapat dieksekusi, dan
penulis aturan dapat mengikuti serangkaian pola umum untuk memperluasnya menjadi
"kata kerja kustom".
Di ranah liar: rules_k8s
Misalnya, pertimbangkan rules_k8s
,
aturan Kubernetes untuk Bazel. Misalkan Anda memiliki target berikut:
# BUILD file in //application/k8s
k8s_object(
name = "staging",
kind = "deployment",
cluster = "testing",
template = "deployment.yaml",
)
Aturan k8s_object
membuat file YAML Kubernetes standar saat bazel build
digunakan pada target staging
. Namun, target tambahan juga dibuat oleh makro k8s_object
dengan nama seperti staging.apply
dan :staging.delete
. Skrip build
ini untuk melakukan tindakan tersebut, dan saat dijalankan dengan bazel run
staging.apply
, skrip ini berperilaku seperti perintah bazel k8s-apply
atau bazel
k8s-delete
kita sendiri.
Contoh lain: ts_api_guardian_test
Pola ini juga dapat dilihat di project Angular. Makro
ts_api_guardian_test
menghasilkan dua target. Yang pertama adalah target nodejs_test
standar yang membandingkan
beberapa output yang dihasilkan dengan file "emas" (yaitu, file yang berisi
output yang diharapkan). Ini dapat dibuat dan dijalankan dengan pemanggilan bazel
test
normal. Di angular-cli
, Anda dapat menjalankan satu target tersebut dengan bazel test //etc/api:angular_devkit_core_api
.
Seiring waktu, file emas ini mungkin perlu diperbarui karena alasan yang sah.
Memperbarui file ini secara manual membosankan dan rentan error, sehingga makro ini juga memberikan
target nodejs_binary
yang memperbarui file emas, bukan
membandingkannya dengan file tersebut. Secara efektif, skrip pengujian yang sama dapat ditulis untuk dijalankan dalam mode "verifikasi"
atau "setuju", berdasarkan cara skrip tersebut dipanggil. Ini mengikuti pola yang sama dengan yang sudah Anda pelajari: tidak ada perintah bazel test-accept
native, tetapi efek yang sama dapat dicapai dengan bazel run //etc/api:angular_devkit_core_api.accept
.
Pola ini bisa sangat kuat, dan ternyata sangat umum setelah Anda belajar mengenalinya.
Mengadaptasi aturan Anda sendiri
Makro adalah inti dari pola ini. Makro digunakan seperti aturan, tetapi dapat membuat beberapa target. Biasanya, mereka akan membuat target dengan nama tertentu yang menjalankan tindakan build utama: mungkin mem-build biner normal, image Docker, atau arsip kode sumber. Dalam pola ini, target tambahan dibuat untuk menghasilkan skrip yang melakukan efek samping berdasarkan output target utama, seperti memublikasikan biner yang dihasilkan atau memperbarui output pengujian yang diharapkan.
Untuk menggambarkan hal ini, gabungkan aturan imajiner yang menghasilkan situs dengan Sphinx dengan makro untuk membuat target tambahan yang memungkinkan pengguna memublikasikannya jika sudah siap. Pertimbangkan aturan yang sudah ada berikut untuk membuat situs dengan Sphinx:
_sphinx_site = rule(
implementation = _sphinx_impl,
attrs = {"srcs": attr.label_list(allow_files = [".rst"])},
)
Selanjutnya, pertimbangkan aturan seperti berikut, yang membuat skrip yang, saat dijalankan, akan memublikasikan halaman yang dihasilkan:
_sphinx_publisher = rule(
implementation = _publish_impl,
attrs = {
"site": attr.label(),
"_publisher": attr.label(
default = "//internal/sphinx:publisher",
executable = True,
),
},
executable = True,
)
Terakhir, tentukan makro berikut guna membuat target untuk kedua aturan di atas secara bersamaan:
def sphinx_site(name, srcs = [], **kwargs):
# This creates the primary target, producing the Sphinx-generated HTML.
_sphinx_site(name = name, srcs = srcs, **kwargs)
# This creates the secondary target, which produces a script for publishing
# the site generated above.
_sphinx_publisher(name = "%s.publish" % name, site = name, **kwargs)
Di file BUILD
, gunakan makro seolah-olah hanya membuat target
utama:
sphinx_site(
name = "docs",
srcs = ["index.md", "providers.md"],
)
Dalam contoh ini, target "dokumen" dibuat, seolah-olah makro adalah aturan Bazel tunggal standar. Saat dibuat, aturan menghasilkan beberapa konfigurasi dan menjalankan Sphinx untuk membuat situs HTML, yang siap diperiksa secara manual. Namun, target "docs.publish" tambahan juga dibuat, yang membuat skrip untuk memublikasikan situs. Setelah memeriksa output target utama, Anda dapat
menggunakan bazel run :docs.publish
guna memublikasikannya untuk konsumsi publik, seperti
perintah bazel publish
imajiner.
Penerapan aturan _sphinx_publisher
tidak langsung terlihat jelas. Sering kali, tindakan seperti ini akan menulis skrip shell launcher.
Metode ini biasanya melibatkan penggunaan
ctx.actions.expand_template
untuk menulis skrip shell yang sangat sederhana, dalam hal ini memanggil biner penayang
dengan jalur ke output target utama. Dengan cara ini, implementasi
penayang dapat tetap umum, aturan _sphinx_site
hanya dapat menghasilkan
HTML, dan skrip kecil inilah yang diperlukan untuk menggabungkan keduanya
bersama-sama.
Di rules_k8s
, inilah yang dilakukan .apply
:
expand_template
menulis skrip Bash yang sangat sederhana, berdasarkan
apply.sh.tpl
,
yang menjalankan kubectl
dengan output target utama. Skrip ini kemudian dapat dibuat dan dijalankan dengan bazel run :staging.apply
, yang secara efektif menyediakan perintah k8s-apply
untuk target k8s_object
.