Pipeline otomatis untuk proyek Spring Boot harus langsung menjawab pertanyaan: apakah kode memenuhi standar, lulus pengujian, dan bisa diterbitkan tanpa campur tangan manual? Dengan Gradle dan GitHub Actions, kita bisa menyambungkan lint, build, dan release artefak secara berurutan. Artikel ini menuntun tim Java/Spring Boot membangun pipeline tersebut, lengkap dengan konfigurasi praktis, caching, strategi versi, rollback cepat, integrasi registry artefak, serta notifikasi deployment.

Arsitektur pipeline lint → build → release

Urutan lint → build → release menghindari limbah sumber daya. Saat lint gagal, pipeline berhenti sehingga kesalahan gaya atau aturan tidak menjangkau tahap berikutnya. Setelah lint terlewati, Gradle menjalankan build yang mencakup kompilasi, unit test, dan packaging. Jika semua lulus, artefak dipublikasikan baik ke snapshot registry (untuk cabang pengembangan) maupun release registry (tag stabil).

Pipeline ideal:

  • Lint: Spotless atau Checkstyle memastikan konsistensi kode.
  • Build: Gunakan ./gradlew clean build disertai unit dan integration test otomatis.
  • Publish: Gradle Publish mengirim artefak ke registry (GitHub Packages, Artifactory, Nexus).

Sebelum menjelajah konfigurasi, pastikan kode Spring Boot menyertakan plugin lint dan publikasi di build.gradle agar bisa diaktifkan lewat pipeline.

Konfigurasi Gradle lint, unit test, dan publish

Contoh konfigurasi menggunakan Gradle Groovy DSL:

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.0.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'com.diffplug.spotless' version '6.0.0'
    id 'maven-publish'
}

spotless {
    java {
        googleJavaFormat()
        target 'src/**/*.java'
    }
}

tasks.register('lint') {
    dependsOn 'spotlessCheck'
}

test {
    useJUnitPlatform()
    testLogging {
        events 'passed', 'skipped', 'failed'
    }
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifactId = 'nama-proyek'
        }
    }
    repositories {
        maven {
            name = 'artifactRegistry'
            url = uri(System.getenv('ARTIFACTORY_URL'))
            credentials {
                username = System.getenv('ARTIFACTORY_USER')
                password = System.getenv('ARTIFACTORY_TOKEN')
            }
        }
    }
}

Penjelasan:

  • Spotless menjalankan lint format; gunakan ./gradlew lint di pipeline.
  • Test logging membantu debugging ketika pipeline gagal.
  • Publishing mengarah ke registry eksternal dengan kredensial aman lewat secret environment.

Tambahkan variabel versi dinamis misalnya menggunakan plugin com.github.ben-manes.versions atau menetapkan version berdasarkan git describe --tags agar release mencerminkan tag produksi.

Workflow GitHub Actions: lint → build → publish

Berikut contoh .github/workflows/ci.yml menggambarkan lint, build, dan publish dengan caching:

name: CI-CD Spring Boot

on:
  push:
    branches: ['main', 'release/**']
  pull_request:
    branches: ['main']

jobs:
  pipeline:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup JDK
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '21'
          cache: 'gradle'

      - name: Restore Gradle cache
        uses: actions/cache@v3
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: gradle-build-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}

      - name: Lint kode
        run: ./gradlew lint

      - name: Build dan Test
        run: ./gradlew clean build --no-daemon

      - name: Publish artefak
        if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main'
        env:
          ARTIFACTORY_URL: ${{ secrets.ARTIFACTORY_URL }}
          ARTIFACTORY_USER: ${{ secrets.ARTIFACTORY_USER }}
          ARTIFACTORY_TOKEN: ${{ secrets.ARTIFACTORY_TOKEN }}
        run: ./gradlew publish

      - name: Kirim notifikasi Slack
        if: success()
        uses: 8398a7/action-slack@v3
        with:
          status: ${{ job.status }}
          fields: repo,message
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

Catatan:

  • Menggunakan actions/cache demi mempercepat task lint dan build.
  • Langkah publish hanya aktif untuk main dan tag release; saat merge PR ke main, pipeline dapat mengeluarkan snapshot.
  • Notifikasi Slack memberi sinyal deployment otomatis; dapat diganti webhook lain (Teams, Discord).

Debugging tip: jika build gagal karena cache korup, jalankan job dengan cache di-nonaktifkan untuk memastikan tidak ada artefak lama yang mengganggu. Periksa log lint lengkap dengan --info atau --debug Gradle.

Manajemen versi artefak, rollback cepat, dan integrasi registry

Strategi versi harus konsisten. Pilih pola MAJOR.MINOR.PATCH dan tambahkan suffix -SNAPSHOT saat pipeline dijalankan di main tanpa tag, sementara tag release menghilangkan suffix. Bisa otomatis dengan skrip di Gradle yang membaca:

  • version = '1.2.0-SNAPSHOT' untuk branch main.
  • Ketika push tag v1.2.0, pipeline pindah ke versi stabil dan mem-publish ke registry release.

Pemilihan registry:

  • Gunakan GitHub Packages atau Artifact Registry perusahaan untuk dependency internal, menjamin traceability.
  • Atur mavenPublishing agar publish ke registry snapshot berbeda dengan release.

Rollback cepat diterapkan dengan:

  1. Menggunakan Git tag stabil terakhir dan rerun pipeline publish untuk versi sebelumnya.
  2. Menandai artefak release dengan metadata (build number, commit SHA) sehingga bisa di-roll back pada registry.
  3. Melacak perbedaan konfigurasi release via file release-notes.md atau changelog otomatis.

Jika penerbitan gagal, selalu ambil log Gradle publish untuk melihat apakah otentikasi registry, checksum, atau network yang bersalah. Gunakan ./gradlew publish --info untuk mengekstrak detail lebih banyak.

Metrik Developer Experience dan peningkatan konsistensi workflow

Untuk menjaga workflow tetap konsisten, ukur metrik berikut:

  • Pipeline lead time (dari push hingga artefak tersedia): pastikan di bawah 5 menit untuk branch utama.
  • Failure rate tiap lint/build/test: bantu prioritaskan stabilitas lint jika sering gagal.
  • Test coverage rata-rata per modul: integrasikan laporan dengan Gradle JaCoCo.
  • Deployment frequency: pantau berapa kali snapshot atau release keluar dalam satu sprint.

Metrik ini membantu mendeteksi regresi pipeline dan memperbaiki bottleneck, misalnya mempercepat lint dengan hanya menjalankan subset file saat PR kecil.

Debugging umum:

  • Jika lint tidak menemukan file baru, cek konfigurasi target di spotless dan periksa .editorconfig.
  • Build gagal karena dependensi: bersihkan cache dengan ./gradlew clean --refresh-dependencies.
  • Publish gagal karena kredensial: pastikan secret GitHub valid dan tidak kadaluarsa.

Dengan arsitektur pipeline lint → build → release yang solid dan metrik yang terukur, tim Spring Boot bisa menjaga kualitas tanpa menunda kecepatan delivery.