Bagi seorang developer, proses deployment sering kali menjadi salah satu bagian yang menantang dalam pengembangan aplikasi. Setelah berjuang keras menyusun kode, rasanya tidak lucu kalau proses deployment justru menghambat performa aplikasi di lingkungan production. Itulah mengapa Jenkins dan Docker adalah dua senjata andalan yang bisa bikin hidup kita jauh lebih simpel, terutama ketika kita ingin mengotomatisasi build dan deploy aplikasi Node.js API.

Jadi, di artikel ini, kita akan membahas secara mendalam bagaimana melakukan deployment aplikasi Node.js API menggunakan Jenkins, lengkap dengan alur build, artifacts, dan deploy menggunakan Docker. Siapkan kopi, duduk santai, dan mari kita mulai!

Apa Itu Jenkins?

Sebelum kita mulai masuk ke teknis, mari kita bahas singkat apa itu Jenkins bagi yang belum akrab. Jenkins adalah alat automasi open-source yang banyak digunakan untuk continuous integration/continuous deployment (CI/CD). Dalam proyek pengembangan, Jenkins membantu kita mengotomatisasi tugas-tugas berulang seperti testing, build, dan deployment. Bayangkan Jenkins seperti asisten yang tidak pernah tidur dan siap kapan saja untuk menjalankan perintah build dan deploy aplikasi kamu, tanpa lelah.

Alur CI/CD untuk Node.js API

Dalam alur CI/CD menggunakan Jenkins, biasanya ada beberapa tahap yang harus dilalui, yaitu:

1. Build: Proses build aplikasi Node.js kamu, di mana dependencies di-install dan aplikasi dipersiapkan untuk lingkungan production.
2. Artifacts: Hasil build yang disimpan sebagai artifacts, yang bisa berupa file hasil kompilasi atau dependencies yang telah diinstal.
3. Deploy: Proses mengirim aplikasi ke server produksi menggunakan Docker.

Kenapa Docker?

Mungkin kamu bertanya, “Kenapa Docker?” Singkatnya, Docker memungkinkan kita untuk membuat aplikasi berjalan di lingkungan yang seragam di mana pun. Dengan Docker, kita bisa mengemas semua dependencies aplikasi ke dalam satu image, memastikan tidak ada masalah yang sering muncul karena perbedaan konfigurasi server atau lingkungan.

Nah, sekarang mari kita masuk ke inti dari artikel ini: bagaimana melakukan deployment aplikasi Node.js API dengan Jenkins dan Docker.

Langkah-langkah Implementasi

1. Persiapan Jenkins dan Docker

Sebelum kita melangkah lebih jauh, pastikan bahwa kamu sudah menyiapkan Jenkins dan server target yang memiliki Docker. Kamu juga perlu menyiapkan akses SSH agar Jenkins bisa terhubung ke server target. Selain itu, pastikan Dockerfile sudah ada di direktori root proyek Node.js kamu.

2. Membuat Dockerfile untuk Node.js API

Sebelum Jenkins bisa melakukan build aplikasi Node.js kamu, kita perlu membuat Dockerfile. Ini adalah contoh sederhana Dockerfile untuk aplikasi Node.js API:

FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install --only=production
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Dockerfile ini memberitahu Docker untuk:

• Menggunakan image Node.js versi 14.
• Menyalin package.json dan menginstal dependencies untuk production.
• Menyalin semua file aplikasi ke dalam container.
• Mengekspos port 3000 (karena aplikasi Node.js biasanya berjalan di port ini).
• Menjalankan aplikasi menggunakan npm start.

3. Jenkinsfile: Automatisasi Build, Artifacts, dan Deploy

Sekarang saatnya kita membuat file Jenkinsfile yang akan menjalankan pipeline dari build hingga deployment.

pipeline {
    agent any

    environment {
        DOCKER_REGISTRY = 'registry-url'
        DOCKER_CREDENTIALS = 'registry-credentials-id'
        APP_NAME = 'nodejs-api-app'
        SERVER_USER = 'your-server-user'
        SERVER_IP = 'your-server-ip'
    }

    stages {
        // Stage 1: Install dependencies & Build Node.js API
        stage('Build') {
            steps {
                script {
                    echo "Building the Node.js API..."
                    sh 'npm install'
                    sh 'npm run build'
                    archiveArtifacts artifacts: '**/*', fingerprint: true
                }
            }
        }

        // Stage 2: Build Docker Image
        stage('Build Docker Image') {
            steps {
                script {
                    echo "Building Docker image for Node.js API..."
                    dockerImage = docker.build("${DOCKER_REGISTRY}/${APP_NAME}:${env.BUILD_ID}")
                }
            }
        }

        // Stage 3: Push Docker Image to Registry
        stage('Push to Registry') {
            steps {
                script {
                    echo "Pushing Docker image to registry..."
                    docker.withRegistry("https://${DOCKER_REGISTRY}", "${DOCKER_CREDENTIALS}") {
                        dockerImage.push('latest')
                        dockerImage.push("${env.BUILD_ID}")
                    }
                }
            }
        }

        // Stage 4: Deploy to Server
        stage('Deploy') {
            steps {
                script {
                    echo "Deploying the Node.js API to server..."
                    sh """
                    ssh ${SERVER_USER}@${SERVER_IP} << EOF
                        docker pull ${DOCKER_REGISTRY}/${APP_NAME}:${env.BUILD_ID}
                        docker stop ${APP_NAME} || true
                        docker rm ${APP_NAME} || true
                        docker run -d --name ${APP_NAME} -p 3000:3000 ${DOCKER_REGISTRY}/${APP_NAME}:${env.BUILD_ID}
                    EOF
                    """
                }
            }
        }
    }

    post {
        always {
            echo "Cleaning up local Docker images..."
            sh "docker rmi ${DOCKER_REGISTRY}/${APP_NAME}:${env.BUILD_ID} || true"
        }
        success {
            echo "Node.js API successfully deployed!"
        }
        failure {
            echo "Deployment failed!"
        }
    }
}

4. Penjelasan Pipeline

• Build Stage: Jenkins akan menjalankan perintah npm install untuk menginstal dependencies, lalu menjalankan npm run build untuk mempersiapkan aplikasi Node.js untuk production. Artifacts hasil build akan disimpan di Jenkins untuk referensi di masa depan.
• Build Docker Image: Jenkins akan membuat Docker image berdasarkan Dockerfile yang sudah kita buat sebelumnya.
• Push Docker Image: Setelah image selesai dibangun, Jenkins akan mengirimkan image ke Docker registry (misalnya Docker Hub atau registry internal).
• Deploy Stage: Jenkins akan SSH ke server produksi, menarik Docker image terbaru dari registry, dan menjalankan container Node.js API di server tersebut.

5. Finalisasi

Setelah pipeline ini selesai diimplementasikan, setiap kali kamu melakukan commit atau perubahan di kode aplikasi Node.js API, Jenkins akan secara otomatis melakukan build, menyimpan artifacts, dan melakukan deploy ke server. Hasilnya? Deployment jadi otomatis dan jauh lebih efisien!

Kesimpulan

Dengan menggunakan Jenkins dan Docker, proses deployment aplikasi Node.js API menjadi lebih cepat, otomatis, dan bebas dari error lingkungan. Kamu tidak lagi perlu khawatir soal “It works on my machine” saat aplikasi di-deploy ke server.

Jadi, kalau kamu belum pernah mencoba integrasi Jenkins dan Docker dalam alur CI/CD untuk aplikasi Node.js kamu, mungkin sekarang adalah waktu yang tepat! Bayangkan waktu yang bisa kamu hemat (dan stres yang bisa kamu hindari) dengan mengotomatisasi semua proses ini.