> ## Documentation Index
> Fetch the complete documentation index at: https://docs.skanesgalab.my.id/llms.txt
> Use this file to discover all available pages before exploring further.

# Jenkins Automation Server

> Panduan lengkap Jenkins: arsitektur Controller-Agent, instalasi Docker, Jenkinsfile (Declarative vs Scripted), dan pipeline CI/CD tingkat lanjut.

## Apa itu Jenkins?

**Jenkins** adalah server otomatisasi sumber terbuka (*open-source automation server*) berbasis Java yang paling lama dan banyak digunakan di dunia enterprise. Jenkins memungkinkan tim untuk mengotomatisasi seluruh proses pembuatan (*building*), pengujian (*testing*), dan penyebaran (*deploying*) perangkat lunak.

***

## Arsitektur Jenkins: Controller & Agent (Master-Worker)

Dalam lingkungan produksi, Jenkins tidak mengeksekusi proses build berat di server utamanya. Jenkins menggunakan arsitektur terdistribusi:

```mermaid theme={null}
flowchart TD
    Controller["Jenkins Controller (Master)\n- Manajemen UI\n- Penjadwalan Tugas\n- Manajemen Kredensial"]
    Agent1["Jenkins Agent 1 (Linux VM)\n- Eksekusi Docker Build"]
    Agent2["Jenkins Agent 2 (Windows VM)\n- Eksekusi .NET Build"]
    Agent3["Jenkins Agent 3 (Kubernetes Pod)\n- Dynamic On-demand Worker"]

    Controller -->|SSH / JNLP| Agent1
    Controller -->|SSH / JNLP| Agent2
    Controller -->|Kube API| Agent3
```

1. **Jenkins Controller (Master):** Bertanggung jawab menyajikan antarmuka web, mengelola plugin, menyimpan kredensial, dan membagikan tugas build.
2. **Jenkins Agents (Node):** Mesin eksekutor terpisah yang bertugas menjalankan perintah build yang diperintahkan oleh Controller.

***

## Menjalankan Jenkins Menggunakan Docker

Cara tercepat dan paling bersih untuk menjalankan Jenkins adalah menggunakan image resmi:

```bash theme={null}
# Membuat volume persisten untuk data Jenkins
docker volume create jenkins_home

# Menjalankan container Jenkins LTS
docker run -d \
  --name jenkins \
  -p 8080:8080 \
  -p 50000:50000 \
  -v jenkins_home:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \
  jenkins/jenkins:lts-jdk17
```

### Langkah Setup Awal:

1. Buka peramban ke `http://ip-server-kamu:8080`.
2. Dapatkan password administrator awal dengan menjalankan:
   ```bash theme={null}
   docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
   ```
3. Pilih opsi **Install suggested plugins**.
4. Buat akun Admin pertama dan URL Jenkins siap dipakai.

***

## Pipeline as Code (`Jenkinsfile`)

Sama seperti GitHub Actions yang menggunakan YAML, praktik terbaik di Jenkins adalah menyimpan alur pipeline dalam berkas bernama `Jenkinsfile` di dalam repositori Git.

### Declarative Pipeline (Format Modern & Direkomendasikan)

```groovy theme={null}
pipeline {
    agent any

    environment {
        APP_NAME = 'myapp'
        DOCKER_CREDENTIALS_ID = 'dockerhub-credentials'
    }

    stages {
        stage('Checkout') {
            steps {
                echo 'Mengambil kode dari repositori...'
                checkout scm
            }
        }

        stage('Test & Quality') {
            steps {
                echo 'Menjalankan unit test...'
                sh 'npm install'
                sh 'npm test'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    echo "Membangun Docker image: ${APP_NAME}:${BUILD_NUMBER}"
                    sh "docker build -t username/${APP_NAME}:${BUILD_NUMBER} ."
                }
            }
        }

        stage('Deploy to Staging') {
            steps {
                echo 'Menyebarkan aplikasi ke server staging...'
                sh 'docker compose -f docker-compose.staging.yml up -d'
            }
        }
    }

    post {
        always {
            cleanWs() // Membersihkan workspace setelah build selesai
        }
        success {
            echo 'Pipeline berhasil diselesaikan dengan sukses!'
        }
        failure {
            echo 'Pipeline gagal! Kirim notifikasi peringatan.'
        }
    }
}
```

***

## Fitur Tingkat Lanjut Jenkins (Advanced Jenkins)

### 1. Eksekusi Tahapan Paralel (`parallel`)

Menjalankan pengujian multi-platform atau unit testing independen secara serentak untuk menghemat waktu total pipeline:

```groovy theme={null}
stage('Parallel Testing') {
    parallel {
        stage('Unit Tests') {
            steps {
                sh 'npm run test:unit'
            }
        }
        stage('Integration Tests') {
            steps {
                sh 'npm run test:integration'
            }
        }
        stage('Security Vulnerability Scan') {
            steps {
                sh 'npm audit --audit-level=high'
            }
        }
    }
}
```

### 2. Konfirmasi Manual untuk Rilis Produksi (`input`)

Menerapkan konsep Continuous Delivery yang aman dengan meminta persetujuan manusia sebelum deploy ke server produksi:

```groovy theme={null}
stage('Approval Rilis Produksi') {
    steps {
        input message: 'Apakah Anda yakin ingin melakukan rilis ke server PRODUKSI?', ok: 'Ya, Deploy Sekarang'
    }
}

stage('Deploy to Production') {
    steps {
        echo 'Melakukan rolling update ke kluster server produksi...'
        sh 'docker stack deploy -c stack.yml prod_app'
    }
}
```

### 3. Dynamic Kubernetes Agents (Jenkins di atas K8s)

Alih-alih menyalakan server agent yang memakan biaya terus-menerus, Jenkins dapat membuat Pod agent di Kubernetes saat ada antrean build, lalu Pod tersebut otomatis dihancurkan ketika build selesai (*Ephemerally Scaled*).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.