Developer push code ke Git
        ↓
Jenkins mendeteksi perubahan
        ↓
Jenkins clone source code
        ↓
Jenkins build aplikasi
        ↓
Jenkins menjalankan test
        ↓
Jenkins membuat artifact
        ↓
Jenkins deploy ke server

java -version

sudo apt update
sudo apt upgrade -y

sudo apt install fontconfig openjdk-17-jre -y

java -version

openjdk version "17.x.x"

sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/jenkins-keyring.asc \
https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

echo "deb [signed-by=/etc/apt/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/" | \
sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null

sudo apt update

sudo apt install jenkins -y

sudo systemctl enable jenkins
sudo systemctl start jenkins
sudo systemctl status jenkins

active (running)

sudo ufw allow 8080
sudo ufw reload

http://IP_SERVER:8080

docker volume create jenkins_home

docker run -d \
  --name jenkins \
  -p 8080:8080 \
  -p 50000:50000 \
  -v jenkinshome:/var/jenkinshome \
  jenkins/jenkins:lts

docker logs -f jenkins

docker exec -it jenkins cat /var/jenkins_home/secrets/initialAdminPassword

http://localhost:8080

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

docker exec -it jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Install suggested plugins

Username: admin
Password: password-kuat
Full name: Administrator
Email: email@domain.com

http://192.168.1.10:8080/

Pipeline

Multibranch Pipeline

New Item

hello-jenkins

Freestyle project

OK

Build Steps > Execute shell

echo "Hello Jenkins"
date
whoami
pwd

Save

Build Now

Build History > Console Output

sudo apt install git -y

git --version

New Item > Freestyle project

Git

https://github.com/user/project.git

Manage Jenkins

Credentials

System > Global credentials

Add Credentials

gitlab-token
dockerhub-login
prod-server-ssh

Jenkinsfile

my-project/
├── src/
├── pom.xml
└── Jenkinsfile

pipeline {
    agent any
stages {
        stage('Checkout') {
            steps {
                echo 'Mengambil source code'
            }
        }
stage('Build') {
            steps {
                echo 'Build aplikasi'
            }
        }
stage('Test') {
            steps {
                echo 'Menjalankan test'
            }
        }
stage('Deploy') {
            steps {
                echo 'Deploy aplikasi'
            }
        }
    }
}

spring-app/
├── src/
├── pom.xml
└── Jenkinsfile

pipeline {
    agent any
tools {
        maven 'Maven-3'
        jdk 'JDK-17'
    }
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
stage('Archive Artifact') {
            steps {
                archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
            }
        }
    }
post {
        success {
            echo 'Build berhasil'
        }
failure {
            echo 'Build gagal'
        }
always {
            cleanWs()
        }
    }
}

Manage Jenkins > Tools

JDK
Name: JDK-17
JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64

Maven
Name: Maven-3
Install automatically: yes

pipeline {
    agent any
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }
stage('Lint') {
            steps {
                sh 'npm run lint'
            }
        }
stage('Test') {
            steps {
                sh 'npm test'
            }
        }
stage('Build') {
            steps {
                sh 'npm run build'
            }
        }
    }
post {
        always {
            cleanWs()
        }
    }
}

pipeline {
    agent any
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Create Virtualenv') {
            steps {
                sh '''
                    python3 -m venv venv
                    . venv/bin/activate
                    pip install --upgrade pip
                    pip install -r requirements.txt
                '''
            }
        }
stage('Test') {
            steps {
                sh '''
                    . venv/bin/activate
                    pytest
                '''
            }
        }
    }
post {
        always {
            cleanWs()
        }
    }
}

pipeline {
    agent any
environment {
        IMAGE_NAME = 'myapp'
        IMAGETAG = "${BUILDNUMBER}"
    }
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Docker Build') {
            steps {
                sh 'docker build -t $IMAGENAME:$IMAGETAG .'
            }
        }
stage('Docker Images') {
            steps {
                sh 'docker images | grep $IMAGE_NAME'
            }
        }
    }
}

dockerhub-login

pipeline {
    agent any
environment {
        IMAGE_NAME = 'username/myapp'
        IMAGETAG = "${BUILDNUMBER}"
    }
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Docker Build') {
            steps {
                sh 'docker build -t $IMAGENAME:$IMAGETAG .'
                sh 'docker tag $IMAGENAME:$IMAGETAG $IMAGE_NAME:latest'
            }
        }
stage('Docker Login and Push') {
            steps {
                withCredentials([
                    usernamePassword(
                        credentialsId: 'dockerhub-login',
                        usernameVariable: 'DOCKER_USER',
                        passwordVariable: 'DOCKER_PASS'
                    )
                ]) {
                    sh '''
                        echo "$DOCKERPASS" | docker login -u "$DOCKERUSER" --password-stdin
                        docker push $IMAGENAME:$IMAGETAG
                        docker push $IMAGE_NAME:latest
                    '''
                }
            }
        }
    }
post {
        always {
            sh 'docker logout || true'
            cleanWs()
        }
    }
}

Manage Jenkins > Credentials

Kind: SSH Username with private key
ID: prod-server-ssh
Username: deploy
Private Key: isi private key

pipeline {
    agent any
stages {
        stage('Deploy') {
            steps {
                sshagent(credentials: ['prod-server-ssh']) {
                    sh '''
                        ssh -o StrictHostKeyChecking=no deploy@192.168.1.10 "
                            cd /opt/myapp &&
                            git pull &&
                            docker compose down &&
                            docker compose up -d --build
                        "
                    '''
                }
            }
        }
    }
}

Build Now

H/5    

Configure > Build Triggers > Poll SCM

0 1   *

Developer push ke Git
        ↓
GitHub / GitLab mengirim webhook ke Jenkins
        ↓
Jenkins menjalankan pipeline

http://jenkins.domain.com/github-webhook/

pipeline {
    agent any
parameters {
        choice(
            name: 'ENVIRONMENT',
            choices: ['dev', 'staging', 'production'],
            description: 'Pilih environment deployment'
        )
string(
            name: 'BRANCH_NAME',
            defaultValue: 'main',
            description: 'Branch yang akan dibuild'
        )
booleanParam(
            name: 'RUN_TEST',
            defaultValue: true,
            description: 'Jalankan test?'
        )
    }
stages {
        stage('Show Parameters') {
            steps {
                echo "Environment: ${params.ENVIRONMENT}"
                echo "Branch: ${params.BRANCH_NAME}"
                echo "Run Test: ${params.RUN_TEST}"
            }
        }
    }
}

pipeline {
    agent any
environment {
        APP_NAME = 'myapp'
        APP_ENV = 'dev'
    }
stages {
        stage('Print Env') {
            steps {
                sh 'echo APPNAME=$APPNAME'
                sh 'echo APPENV=$APPENV'
            }
        }
    }
}

environment {
    PASSWORD = 'password123'
}

pipeline {
    agent any
stages {
        stage('Use Secret') {
            steps {
                withCredentials([
                    string(
                        credentialsId: 'api-token',
                        variable: 'API_TOKEN'
                    )
                ]) {
                    sh '''
                        curl -H "Authorization: Bearer $API_TOKEN" https://api.example.com
                    '''
                }
            }
        }
    }
}

pipeline {
    agent any
stages {
        stage('Build') {
            steps {
                sh 'echo build'
            }
        }
    }
post {
        success {
            echo 'Pipeline sukses'
        }
failure {
            echo 'Pipeline gagal'
        }
always {
            echo 'Selalu dijalankan'
            cleanWs()
        }
    }
}

pipeline {
    agent any
stages {
        stage('Parallel Test') {
            parallel {
                stage('Unit Test') {
                    steps {
                        sh 'echo unit test'
                    }
                }
stage('Integration Test') {
                    steps {
                        sh 'echo integration test'
                    }
                }
stage('Security Scan') {
                    steps {
                        sh 'echo security scan'
                    }
                }
            }
        }
    }
}

pipeline {
    agent any
stages {
        stage('Build') {
            steps {
                sh 'echo build aplikasi'
            }
        }
stage('Approval') {
            steps {
                input message: 'Deploy ke production?', ok: 'Deploy'
            }
        }
stage('Deploy Production') {
            steps {
                sh 'echo deploy production'
            }
        }
    }
}

pipeline {
    agent any
stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
stage('Archive') {
            steps {
                archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
            }
        }
    }
}

pipeline {
    agent any
stages {
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
    }
post {
        always {
            junit 'target/surefire-reports/*.xml'
        }
    }
}

post {
    always {
        cleanWs()
    }
}

Manage Jenkins > Plugins

main
develop
feature/login
feature/payment
release/v1.0

New Item

Multibranch Pipeline

Repository URL
Credential
Branch source
Scan repository

Developer membuat branch feature
        ↓
Developer push branch ke Git
        ↓
Jenkins build branch tersebut
        ↓
Jenkins menjalankan test
        ↓
Developer membuat pull request / merge request
        ↓
Jenkins validasi pull request
        ↓
Code direview
        ↓
Merge ke develop / main
        ↓
Jenkins build ulang
        ↓
Deploy ke dev / staging
        ↓
Approval manual
        ↓
Deploy production

pipeline {
    agent any
parameters {
        choice(
            name: 'DEPLOY_ENV',
            choices: ['dev', 'staging'],
            description: 'Pilih environment deployment'
        )
    }
environment {
        APP_NAME = 'plato-app'
        IMAGE_NAME = 'registry.example.com/plato-app'
        IMAGETAG = "${BUILDNUMBER}"
    }
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Build App') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
stage('Unit Test') {
            steps {
                sh 'mvn test'
            }
post {
                always {
                    junit 'target/surefire-reports/*.xml'
                }
            }
        }
stage('Build Docker Image') {
            steps {
                sh '''
                    docker build -t $IMAGENAME:$IMAGETAG .
                    docker tag $IMAGENAME:$IMAGETAG $IMAGE_NAME:latest
                '''
            }
        }
stage('Push Docker Image') {
            steps {
                withCredentials([
                    usernamePassword(
                        credentialsId: 'registry-login',
                        usernameVariable: 'REGISTRY_USER',
                        passwordVariable: 'REGISTRY_PASS'
                    )
                ]) {
                    sh '''
                        echo "$REGISTRYPASS" | docker login registry.example.com -u "$REGISTRYUSER" --password-stdin
                        docker push $IMAGENAME:$IMAGETAG
                        docker push $IMAGE_NAME:latest
                    '''
                }
            }
        }
stage('Deploy') {
            steps {
                sshagent(credentials: ['staging-server-ssh']) {
                    sh '''
                        ssh -o StrictHostKeyChecking=no deploy@192.168.1.20 "
                            cd /opt/plato-app &&
                            export IMAGETAG=$IMAGETAG &&
                            docker compose pull &&
                            docker compose up -d
                        "
                    '''
                }
            }
        }
    }
post {
        success {
            echo "Pipeline sukses: $BUILD_URL"
        }
failure {
            echo "Pipeline gagal: $BUILD_URL"
        }
always {
            cleanWs()
        }
    }
}

services:
  jenkins:
    image: jenkins/jenkins:lts
    container_name: jenkins
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - jenkinshome:/var/jenkinshome
volumes:
  jenkins_home:

docker compose up -d

docker compose logs -f

server {
    listen 80;
    server_name jenkins.example.com;
location / {
        proxy_pass http://127.0.0.1:8080;
proxysetheader Host $host;
        proxysetheader X-Real-IP $remote_addr;
        proxysetheader X-Forwarded-For $proxyaddxforwardedfor;
        proxysetheader X-Forwarded-Proto $scheme;
proxyhttpversion 1.1;
        proxyrequestbuffering off;
    }
}

sudo nginx -t
sudo systemctl reload nginx

/var/lib/jenkins

/var/jenkins_home

sudo tar -czvf jenkins-backup.tar.gz /var/lib/jenkins

docker run --rm \
  -v jenkins_home:/data \
  -v $(pwd):/backup \
  alpine \
  tar -czvf /backup/jenkins-backup.tar.gz /data

sudo systemctl stop jenkins

sudo tar -xzvf jenkins-backup.tar.gz -C /

sudo chown -R jenkins:jenkins /var/lib/jenkins

sudo systemctl start jenkins

Manage Jenkins > Security

Credentials

Manage Jenkins > Plugins

Jenkinsfile

dev
staging
production

cleanWs()

archiveArtifacts

junit

plato-api-dev
plato-api-staging
plato-api-production
plato-web-dev
plato-web-staging

sudo systemctl status jenkins

sudo ss -tulpn | grep 8080

sudo journalctl -u jenkins -f

sudo systemctl stop jenkins

sudo nano /var/lib/jenkins/config.xml

<useSecurity>true</useSecurity>

<useSecurity>false</useSecurity>

sudo systemctl start jenkins

sudo -u jenkins git ls-remote https://github.com/user/repo.git

permission denied while trying to connect to the Docker daemon socket

sudo usermod -aG docker jenkins
sudo systemctl restart jenkins

groups jenkins

Manage Jenkins > Tools

tools {
    maven 'Maven-3'
}

Manage Jenkins > Plugins > Updates

sudo systemctl restart jenkins

pipeline {
    agent any
environment {
        APP_NAME = 'my-app'
    }
stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
stage('Install / Build') {
            steps {
                sh '''
                    echo "Build $APP_NAME"
                    ./mvnw clean package -DskipTests
                '''
            }
        }
stage('Test') {
            steps {
                sh './mvnw test'
            }
post {
                always {
                    junit 'target/surefire-reports/*.xml'
                }
            }
        }
stage('Package') {
            steps {
                archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
            }
        }
    }
post {
        success {
            echo 'Build sukses'
        }
failure {
            echo 'Build gagal'
        }
always {
            cleanWs()
        }
    }
}

1. Install Jenkins

Buat Freestyle Job
Integrasi dengan Git
Buat Pipeline sederhana
Simpan Jenkinsfile di repository
Tambahkan build project nyata
Tambahkan test
Tambahkan artifact
Tambahkan credential
Tambahkan deploy ke server
Tambahkan webhook
Gunakan Multibranch Pipeline
Tambahkan Docker build
Tambahkan approval production
Tambahkan backup dan security

Git + Jenkinsfile + Pipeline + Credential + Webhook + Docker + Deploy otomatis