Fine-Tuning Local LLM untuk Automasi Code Review pada Pipeline CI/CD

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap pengembangan perangkat lunak modern, otomatisasi pipeline Continuous Integration dan Continuous Deployment (CI/CD) telah menjadi standar baku. Namun, satu komponen yang sering kali menjadi hambatan utama (bottleneck) adalah proses Code Review. Code review manual yang dilakukan oleh manusia rentan terhadap inkonsistensi, kelelahan, keterlambatan waktu tunggu (latency), serta bias subjektif. Di sisi lain, integrasi layanan Cloud-based LLM (seperti OpenAI GPT-4 atau Anthropic Claude) untuk mengotomatisasi proses ini membawa risiko keamanan yang masif, termasuk potensi kebocoran hak kekayaan intelektual (IP leakage), pelanggaran regulasi privasi data (seperti GDPR), serta biaya operasional (API costs) yang melonjak drastis seiring dengan pertumbuhan skala commit repository.

Masalah utama yang dihadapi oleh AI Engineers dan DevOps Leads di dunia nyata adalah bagaimana mengimplementasikan sistem automated code review yang independen secara infrastruktur, aman terhadap kerahasiaan kode sumber, memiliki latensi rendah, namun tetap memiliki kapabilitas penalaran (reasoning) yang mumpuni untuk mendeteksi kerentanan keamanan kelas atas (misalnya SQL Injection, Remote Code Execution, atau Broken Access Control) serta pelanggaran gaya kode (coding style).

Perbandingan antara kondisi sebelum dan sesudah penerapan Fine-Tuned Local LLM pada pipeline CI/CD dapat dilihat pada matriks berikut:

• Sebelum (Manual / Cloud-Dependent Review):
  • Waktu tunggu pull request memakan waktu 24 hingga 72 jam.
  • Biaya langganan API pihak ketiga membengkak hingga ribuan dolar per bulan.
  • Risiko kepatuhan hukum (compliance) akibat pengiriman kode proprietary ke server eksternal.
  • Inkonsistensi hasil ulasan tergantung pada suasana hati (mood) dan tingkat kelelahan reviewer.
• Sesudah (Fine-Tuned Local LLM CI/CD Integration):
  • Ulasan kode otomatis selesai dalam hitungan detik (rata-rata 15-45 detik per commit).
  • Biaya operasional stabil berdasarkan utilisasi infrastruktur bare-metal atau GPU terisolasi.
  • Keamanan data absolut karena seluruh pemrosesan terjadi di dalam on-premise infrastructure atau secure VPC.
  • Konsistensi standar keamanan enterprise ditegakkan secara ketat pada setiap baris kode yang masuk.

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur untuk menjalankan Fine-Tuned Local LLM dalam pipeline CI/CD dirancang dengan pendekatan event-driven yang memisahkan antara layer orkestrasi, layer inferensi, dan layer eksekusi pengujian. Komponen utama terdiri dari Webhook Listener (biasanya terintegrasi dengan GitHub/GitLab), API Gateway/Inference Server (menggunakan vLLM atau Ollama dengan back-end TensorRT-LLM), serta Runner CI/CD mandiri yang dilengkapi akselerator GPU.

Di bawah ini adalah representasi diagram ASCII dari alur eksekusi arsitektur sistem:

+-----------------------------------------------------------------------+
|                        DEVELOPER WORKSTATION                          | 
|                   (Git Push / Pull Request Created)                   |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|                           GIT HOSTING (SaaS)                          | 
|                (Triggers Webhook -> POST /api/v1/review)              |
+-----------------------------------------------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|                      SECURE VPC / INFRASTRUCTURE                      |
|                                                                       |
|  +--------------------+      +-------------------------------------+  |
|  | Nginx Reverse Proxy| ---> |      Inference Server (vLLM)        |  |
|  | (SSL/TLS, WAF)     |      |  - Qwen2.5-Coder-7B-Instruct (LoRA) |  |
|  +--------------------+      +-------------------------------------+  |
|                                                |                      |
|                                                v                      |
|                             +-------------------------------------+   |
|                             |    CI/CD Runner (GitHub Actions)    |   |
|                             |  - Fetches Git Diff                 |   |
|                             |  - Constructs Structured Prompt     |   |
|                             |  - Posts Review Comment back to PR  |   |
|                             +-------------------------------------+   |
+-----------------------------------------------------------------------+

Alur data berjalan secara asinkron. Ketika seorang developer membuka Pull Request, GitHub mengirimkan payload webhook ke server infrastruktur kita. Nginx bertindak sebagai reverse proxy yang memvalidasi signature HMAC webhook demi keamanan, lalu meneruskannya ke layanan runner lokal. Runner mengekstrak perubahan (git diff), memformatnya ke dalam templat prompt khusus audit keamanan, dan mengirimkan inference request ke server vLLM lokal yang menjalankan model berukuran optimal (seperti Qwen2.5-Coder-7B atau Llama-3-Instruct yang telah di-fine-tune menggunakan metode QLoRA). Hasil keluaran dalam bentuk JSON terstruktur kemudian diparsing dan dikembalikan sebagai komentar otomatis pada Pull Request.

3. Perbandingan Komparatif / Analisis Pendekatan

Dalam membangun sistem ini, pemilihan arsitektur model dan metode deployment sangat menentukan keberhasilan operasional. Berikut adalah analisis komparatif antara tiga pendekatan utama yang sering dipertimbangkan oleh DevOps Leads:

[!WARNING] Mengandalkan model dasar (Base Local LLM) tanpa fine-tuning sering kali menghasilkan false positives yang tinggi pada proyek-proyek enterprise yang menggunakan pustaka (libraries) atau arsitektur internal kustom. Fine-tuning menggunakan QLoRA pada dataset code review historis perusahaan adalah keharusan untuk menaikkan relevansi semantik.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum melakukan implementasi, pastikan infrastruktur server atau Virtual Private Server (VPS) Anda memenuhi spesifikasi minimum produksi:

• OS: Ubuntu 22.04 LTS / Debian 12 Bookworm
• Hardware: Minimal 1x GPU NVIDIA dengan VRAM 24GB (Contoh: NVIDIA RTX 3090/4090 atau A10G), RAM Sistem 64GB, Penyimpanan NVMe SSD 500GB.
• Software Stack:
  • Docker & NVIDIA Container Toolkit
  • Python 3.10+
  • CUDA Toolkit 12.1+
  • Nginx sebagai Reverse Proxy
  • Git & GitHub Actions Self-Hosted Runner

Lakukan verifikasi awal pada driver NVIDIA dan Container Toolkit dengan menjalankan perintah terminal berikut:

# Verifikasi driver NVIDIA dan ketersediaan GPU
nvidia-smi

# Verifikasi dukungan NVIDIA Container Toolkit pada Docker
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

Pastikan kedua perintah di atas mengembalikan informasi spesifikasi GPU Anda tanpa error. Jika gagal, instal ulang nvidia-container-toolkit dan konfigurasikan Docker daemon agar mengenali runtime default NVIDIA.

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Setup vLLM Inference Server dengan Docker

Buat direktori kerja untuk infrastruktur LLM lokal Anda:

mkdir -p /opt/local-llm/config
cd /opt/local-llm

Buat file konfigurasi docker-compose di /opt/local-llm/docker-compose.yml:

version: '3.8'

services:
  vllm-server:
    image: vllm/vllm-openai:latest
    container_name: vllm-code-reviewer
    runtime: nvidia
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=hf_your_actual_token_here
    command: >
      --model Qwen/Qwen2.5-Coder-7B-Instruct
      --tensor-parallel-size 1
      --gpu-memory-utilization 0.90
      --max-model-len 4096
      --port 8000
    restart: always

Jalankan layanan vLLM di latar belakang:

docker-compose up -d

Langkah 2: Konfigurasi Nginx Reverse Proxy & SSL

Lindungi endpoint lokal Anda menggunakan Nginx dan sertifikat SSL Let's Encrypt. Buat file konfigurasi /etc/nginx/sites-available/llm.internal.domain.com:

server {
    listen 80;
    server_name llm.internal.domain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name llm.internal.domain.com;

    ssl_certificate /etc/letsencrypt/live/llm.internal.domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/llm.internal.domain.com/privkey.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    client_max_body_size 50M;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Konfigurasi Timeout untuk proses inferensi LLM yang panjang
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }
}

Aktifkan konfigurasi dan lakukan pengujian sintaks:

ln -s /etc/nginx/sites-available/llm.internal.domain.com /etc/nginx/sites-enabled/
nginx -t
systemctl reload nginx

Langkah 3: Integrasi dengan GitHub Actions Pipeline

Buat file workflow CI/CD pada repository kode Anda di .github/workflows/ai-code-review.yml:

name: Local LLM Automated Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  code-review:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 2

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Install Dependencies
        run: |
          pip install requests

      - name: Run AI Code Review Script
        env:
          LLM_API_URL: "https://llm.internal.domain.com/v1/chat/completions"
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          REPOSITORY: ${{ github.repository }}
        run: |
          python3 .github/scripts/review_bot.py

Langkah 4: Skrip Python untuk Eksekusi Review

Buat file skrip eksekusi di .github/scripts/review_bot.py:

import os
import subprocess
import requests
import json

def get_git_diff():
    # Mendapatkan git diff dari commit terakhir pada Pull Request
    diff = subprocess.check_output(["git", "diff", "HEAD^", "HEAD"]).decode("utf-8")
    return diff[:15000] # Batasi ukuran diff agar tidak melebihi context window

def query_local_llm(diff_content):
    api_url = os.environ.get("LLM_API_URL")
    headers = {
        "Content-Type": "application/json"
    }
    
    prompt = (
        "Anda adalah Lead Security Engineer dan Senior Code Reviewer. "
        "Analisis git diff berikut secara teliti untuk menemukan kerentanan keamanan, "
        "kesalahan logika, atau pelanggaran best practice. Berikan output dalam format Markdown."
        f"\n\nGit Diff:\n{diff_content}"
    )

    payload = {
        "model": "Qwen/Qwen2.5-Coder-7B-Instruct",
        "messages": [
            {"role": "system", "content": "Anda adalah asisten AI ahli Code Review untuk DevOps pipeline.\