Pipeline CI linting paralel dan security scan untuk tim cepat memungkinkan tim mengunci kualitas kode sekaligus menjaga kecepatan iterasi. Pendekatan ini menjalankan linting, unit test, dan security scan secara bersamaan, cocok untuk monorepo frontend/backend agar tidak menunggu serial job. Berikut langkah perancangan lengkap yang menjawab kebutuhan tersebut.

1. Mengapa linting dan security scan paralel diperlukan dalam monorepo

Monorepo frontend/backend biasanya memiliki linting berbasis JavaScript/TypeScript untuk UI dan backend linting/formatting lainnya. Serial pipeline memperlambat feedback loop karena linting frontend menunggu unit test backend selesai. Menjalankan linting, unit test, dan security scan secara paralel memanfaatkan kapabilitas runner modern dan memberikan feedback cepat kepada pengembang, khususnya saat PR membutuhkan validasi lint dan keamanan sebelum merging.

Strategi ini juga memungkinkan mengisolasi error: jika linting gagal, job lain tetap berjalan sehingga log otomatis muncul. Tetapkan status check terpisah sehingga hasil linting, unit test, dan security scan masing-masing dapat dipantau sebelum release gated.

2. Desain pipeline CI linting paralel dan security scan

2.1. Struktur job dan dependency

Desain pipeline terdiri dari tiga job utama yang berjalan paralel:

  • Linting — jalankan ESLint/Stylelint di frontend/ dan backend formatter seperti ruff atau prettier.
  • Unit test — jalankan test suite frontend (misal Jest/Vitest) dan backend (misal pytest) sekaligus.
  • Security scan — jalankan dependency scan (misal npm audit, pip-audit) dan container/image scan (misal Trivy atau Snyk).

Job ini tidak saling tergantung, namun job release atau deploy sebaiknya memiliki dependency needs terhadap ketiganya agar tidak berjalan sebelum semuanya sukses.

2.2. Caching dependency dan artifact

Untuk menghindari pengunduhan ulang dependency, gunakan mekanisme cache runner. GitHub Actions menyediakan actions/cache untuk folder node_modules atau {backend}/.venv. GitLab CI menggunakan directive cache:. Cache membantu linting dan test menjalankan lebih cepat, terutama di pipeline paralel.

Job security scan kadang menghasilkan laporan (example: SARIF atau JSON), yang bisa dibagikan ke job selanjutnya melalui artifacts. Upload artifact dari job security scan kemudian diunduh oleh job release untuk dikumpulkan di dashboard.

2.3. Strategi fail-fast dan status checks untuk gating release

Aktifkan fail-fast (GitHub strategy fail-fast: true atau GitLab interruptible: true) agar pipeline berhenti ketika satu job gagal. Kombinasikan dengan status check pada branch protection (GitHub) atau rules:exists di GitLab untuk memastikan release hanya jika linting, test, dan security scan sukses. Ini memastikan gating release tidak di-trigger saat ada error kritis di job tadi.

3. Contoh konfigurasi GitHub Actions

Contoh berikut menunjukkan pipeline linting, unit test, dan security scan paralel untuk monorepo frontend/backend dengan caching dependency serta artefak security scan.

name: CI Parallel Pipeline

on:
  pull_request:
    paths: ["frontend/**", "backend/**"]

jobs:
  lint:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: true
    steps:
      - uses: actions/checkout@v4
      - name: Cache frontend npm
        uses: actions/cache@v4
        with:
          path: frontend/node_modules
          key: frontend-node-modules-${{ hashFiles('frontend/package-lock.json') }}
      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      - name: Install frontend deps
        run: |
          cd frontend
          npm ci
      - name: Run frontend lint
        run: |
          cd frontend
          npm run lint
      - name: Run backend lint
        run: |
          cd backend
          pip install -r requirements.txt
          ruff check .

  unit-test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: true
    steps:
      - uses: actions/checkout@v4
      - name: Cache backend venv
        uses: actions/cache@v4
        with:
          path: backend/.venv
          key: backend-venv-${{ hashFiles('backend/requirements.txt') }}
      - name: Setup Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - name: Install backend deps
        run: |
          python -m venv backend/.venv
          source backend/.venv/bin/activate
          pip install -r backend/requirements.txt
      - name: Run backend tests
        run: |
          source backend/.venv/bin/activate
          pytest backend/tests
      - name: Run frontend tests
        run: |
          cd frontend
          npm ci
          npm run test -- --runInBand

  security-scan:
    runs-on: ubuntu-latest
    needs: [lint, unit-test]
    steps:
      - uses: actions/checkout@v4
      - name: Run npm audit
        run: |
          cd frontend
          npm ci
          npm audit --json > frontend-audit.json
      - name: Run pip-audit
        run: |
          pip install pip-audit
          pip-audit > backend-audit.txt
      - name: Upload reports
        uses: actions/upload-artifact@v4
        with:
          name: security-reports
          path: |
            frontend/frontend-audit.json
            backend/backend-audit.txt

Dalam contoh ini, job security-scan ditandai needs pada lint dan unit test agar hanya berjalan saat semuanya lulus. Artifact report dapat digunakan pada job release atau dibaca manual.

4. Konfigurasi serupa di GitLab CI

GitLab CI menggunakan stages dan needs untuk menjalankan job paralel. Berikut snippet konfigurasi dengan cache dan artifact sharing:

stages:
  - lint
  - test
  - security

lint-frontend:
  stage: lint
  tags: [docker]
  script:
    - cd frontend
    - npm ci
    - npm run lint
  cache:
    key: frontend-node-modules-${CI_COMMIT_REF_SLUG}
    paths:
      - frontend/node_modules

lint-backend:
  stage: lint
  script:
    - cd backend
    - pip install -r requirements.txt
    - ruff check .
  cache:
    key: backend-venv-${CI_COMMIT_REF_SLUG}
    paths:
      - backend/.venv

unit-test:
  stage: test
  needs: [lint-frontend, lint-backend]
  script:
    - cd backend
    - source .venv/bin/activate || python -m venv .venv
    - pip install -r requirements.txt
    - pytest tests
    - cd ../frontend
    - npm ci
    - npm run test -- --runInBand
  cache:
    paths:
      - backend/.venv
      - frontend/node_modules

security-scan:
  stage: security
  needs: [unit-test]
  script:
    - npm ci
    - npm audit --json > frontend-audit.json
    - pip install pip-audit
    - pip-audit > backend-audit.txt
  artifacts:
    paths:
      - frontend-audit.json
      - backend-audit.txt
    expire_in: 1 week

GitLab memanfaatkan caching untuk dependency, dan job security menghasilkan artifacts yang bisa diunduh atau dianalisis dalam pipeline review. needs memastikan security scan berjalan setelah unit test.

5. Tooling linting dan security yang umum

Untuk linting frontend, ESLint + Stylelint dengan konfigurasi shareable (misal eslint-config-airbnb) cocok. Backend Python bisa memakai Ruff, Black, Flake8. Unit test gunakan Jest/Vitest (frontend) dan Pytest/Testsuite (backend). Untuk security scan, pilih tooling yang bisa dijalankan headless seperti npm audit, pip-audit, Trivy (images), atau Snyk (dependency/scan code). Pastikan semuanya mendukung output machine-readable agar dapat di-integrasikan ke laporan CI.

6. Strategi gating release dengan status checks

GitHub: gunakan branch protection settings untuk mengharuskan job linting, unit-test, dan security-scan sukses sebelum merging. Aktifkan Require status checks to pass di protection rule dan pilih nama job yang sesuai.
GitLab: pakai Protected Branch + only/except atau rules untuk memblokir pipeline release sebelum semua stage sukses.

Jika pipeline memiliki job release/deploy, tambahkan needs: [security-scan] agar release otomatis tertunda sampai job utama dinyatakan sehat.

7. Troubleshooting job otomatis yang gagal

  • Linting crash: jalankan linting secara lokal pada commit yang sama dengan command pipeline, pastikan versi dependency identik dan cache tidak korup.
  • Cache invalid: gunakan hash file (package-lock, requirements) di key cache agar cache rebuild saat dependency berubah. Jika job terus pakai cache lama, bersihkan cache manual di UI runner.
  • Security scan false positive: periksa log scan terkait paths, gunakan flag untuk meng-ignore vulnerability yang sudah di-understand (misal pip-audit --ignore), namun dokumentasi ke tim.
  • Artifact tidak muncul: pastikan job security scan selesai dan definisi artifacts benar. Cek expiration dan paths, serta pastikan job tidak di-skip oleh rules.

Setiap job paralel harus log detail agar debugging mudah, misalnya dengan mencetak versi tooling, path, dan command yang dijalankan.

Kesimpulan

Pipeline CI yang menjalankan linting, unit test, dan security scan secara paralel membantu tim cepat mendapatkan feedback kualitas kode tanpa mengorbankan keamanan. Desain job hati-hati, caching dependency, artifact sharing, dan fail-fast memastikan pipeline efisien. Implementasi di GitHub Actions dan GitLab CI serupa secara konsep, hanya berbeda sintaks YAML dan fitur kustom masing-masing.