Pipeline build lint multikomponen pada workspace Rust harus bisa menjaga konsistensi code style, memverifikasi logika bisnis, dan memproduksi artefak siap rilis. Pendekatan ini menjawab kebutuhan lint/format, unit test, build release, serta artefak lintas crate dengan caching cerdas agar waktu eksekusi tetap terkendali.

Memahami tantangan workspace Rust multikrake

Rust workspace yang terdiri dari beberapa crate (library, binary, plugin) memperkenalkan beban kompilasi yang berat dan kebutuhan lint/format terkoordinasi. Jika setiap job CI menarik dependencies, mengkompilasi ulang seluruh workspace, serta menjalankan cargo fmt/check/clippy tanpa caching, pipeline bisa memakan banyak menit dan menurunkan frekuensi feedback.

Diagram alur menyatukan langkah-langkah utama: Source checkout → Setup toolchain → Restore cache (target + .cargo/registry) → Lint/format → Unit test → Build release → Publikasi artefak lintas crate → Validasi draft release → Monitoring workflow status. Setiap tahap memiliki checkpoint yang memastikan lint dan build tidak melewati batas.

Desain pipeline lint-multicomponent dengan caching cerdas

1. Verifikasi lint/format triad

Lint di pipeline harus memanfaatkan cargo fmt, cargo check, dan cargo clippy berurutan untuk memastikan kode konsisten, tipe valid, dan aturan pedoman terpenuhi. Jalankan cargo fmt --all -- --check sebagai langkah pertama agar format tidak meluncur ke tahap berikut tanpa perbaikan.

Contoh urutan:

  1. cargo fmt --all -- --check ( penjagaan format )
  2. cargo clippy --workspace --all-targets --all-features -- -D warnings ( analisis kode )
  3. cargo check --workspace --all-features ( pemeriksaan tipe )

Ketiga langkah ini sebaiknya dijalankan dalam satu job untuk memanfaatkan cache build yang sama.

2. Artefak lintas crate

Workspace biasanya menghasilkan artifact berbeda per crate. Simpan bersama di direktori seperti target/release dan target/debug, lalu unggah ke GitHub Actions sebagai workflow artifact. Ini membantu tim QA memverifikasi setiap binari tanpa mengulangi kompilasi yang mahal.

3. Caching target dan dependency

Gunakan dua cache utama:

  • .cargo/registry menyimpan crate yang diunduh sehingga cargo build bisa memakai kembali artifacts dependency.
  • target menyimpan hasil kompilasi incremental untuk mempercepat langkah lint dan build berikutnya.

Cache key ideal: crate-lockfile-{{ hashFiles('**/Cargo.lock') }} untuk registry dan target-{{ runner.os }}-{{ hashFiles('Cargo.lock') }}-{{ env.cache-version }} untuk target incremental. Tambahkan restore-keys yang lebih longgar agar build masih bisa berjalan saat cache tidak ditemukan.

Implementasi GitHub Actions

Berikut template YAML yang menerapkan lint, test, build release, caching cerdas, serta artefak lintas crate.

name: CI Rust Workspace

on:
  pull_request:
  push:
    branches: ["main"]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
          toolchain: stable
      - name: Cache Cargo registry
        uses: actions/cache@v4
        with:
          path: ~/.cargo/registry
          key: registry-${{ hashFiles('**/Cargo.lock') }}
      - name: Cache target directory
        uses: actions/cache@v4
        with:
          path: target
          key: target-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            target-${{ runner.os }}-
      - name: Cargo fmt check
        run: cargo fmt --all -- --check
      - name: Cargo clippy
        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
      - name: Cargo check
        run: cargo check --workspace --all-features
      - name: Run unit tests
        run: cargo test --workspace --all-features
  build-release:
    needs: lint-and-test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup toolchain again
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      - name: Restore target cache
        uses: actions/cache@v4
        with:
          path: target
          key: target-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
      - name: Release build
        run: cargo build --workspace --release
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: binaries
          path: target/release/*

YAML di atas menjaga lint/format, test, dan build release terpisah sekaligus memanfaatkan cache lintas job. Jika release job memerlukan debug tambahan, bisa tambahkan langkah cargo test --lib.

Strategi fallback dan monitoring

1. Fallback saat job build lambat

Jika build release memakan waktu lebih dari batas CI (misalnya >15 menit), sediakan job fallback yang hanya membangun crate utama atau binary tertentu. Ini berguna sebelum merge: job lint tetap memastikan kode sehat, sementara fallback build memastikan binary kritis bisa dibangun sebelum deployment.

Contoh fallback:

  • Job build-core hanya menjalankan cargo build -p core --release.
  • Gunakan if: steps.check-cache.outputs.hit != 'true' untuk memicu fallback bila cache tidak tersedia.

2. Validasi draft release dan monitoring status workflow

Setelah artefak berhasil diunggah, buatlah draft release GitHub dengan informasi versi dan checksum untuk artefak lintas crate. Automasi ini bisa dijalankan di job tambahan yang tergantung pada job build-release. Verifikasi bahwa draft memiliki link artefak yang sesuai sebelum menandatanganinya.

Monitoring workflow dilakukan dengan menambahkan badge status di README dan mengaktifkan notifikasi Slack/Teams untuk job gagal. Gunakan metadata outputs dari job lint untuk menyediakan status lint dasar ke dashboard internal.

Kesimpulan

Pipeline build lint multikomponen dengan caching target dan .cargo/registry memastikan workspace Rust tetap responsif, verifikasi lint dilakukan menyeluruh dengan cargo fmt/check/clippy, dan artefak lintas crate terdokumentasi melalui upload GitHub Actions. Tambahkan fallback build untuk menghindari lama eksekusi dan pantau status workflow agar release draft selalu tervalidasi.