Men-deploy Aplikasi dengan Docker dalam Alur CI/CD: Dari Developer ke Produksi dalam Sekejap!

Docker

Container

 

"Siapa bilang deploy aplikasi harus ribet? Dengan Docker dan CI/CD, deployment bisa sesederhana klik tombol. Tulis kode, minum kopi, dan voilà!"

Deploying aplikasi ke produksi bisa jadi hal yang menegangkan. Kalau dilakukan secara manual, bisa jadi masalah besar dan memakan banyak waktu. Tapi, dengan Docker dan CI/CD (Continuous Integration/Continuous Delivery), proses ini bisa jauh lebih mudah, cepat, dan bahkan menyenangkan (serius, kita nggak bercanda!).

Di artikel ini, kita akan membahas langkah-langkah untuk men-deploy aplikasi dengan Docker dalam alur CI/CD. Kami akan tunjukkan bagaimana Docker bekerja dengan alur kerja otomatis agar aplikasi kamu bisa berjalan di produksi tanpa drama. Siap untuk deploy? Let's go!

1. Apa Itu CI/CD dan Kenapa Docker Sangat Sesuai?

Sebelum kita membahas cara men-deploy aplikasi dengan Docker, mari kita pahami dulu apa itu CI/CD.

• Continuous Integration (CI) adalah praktek penggabungan kode secara rutin ke dalam repositori utama. Setiap kali ada perubahan, kode tersebut diuji secara otomatis agar tim bisa mendeteksi kesalahan lebih cepat.

• Continuous Delivery (CD) adalah tahap berikutnya setelah CI, yang memastikan aplikasi selalu siap untuk di-deploy ke produksi kapan saja. Jadi, tim pengembang bisa mengirimkan perubahan ke pelanggan lebih cepat.

Nah, Docker berperan sebagai penghubung dalam alur CI/CD ini. Dengan Docker, kita bisa memastikan aplikasi yang kita buat berjalan di container yang konsisten di semua lingkungan (pengembangan, pengujian, dan produksi).

Docker menyediakan Docker image yang berisi aplikasi beserta dependensinya. Jadi, aplikasi yang berjalan di laptop pengembang akan berjalan dengan cara yang sama di server produksi. Magic, kan?

2. Membangun Docker Image dan Men-deploy ke Registry Docker

Sebelum kita melakukan deploy aplikasi ke lingkungan produksi, kita perlu membangun Docker image dari aplikasi kita.

Langkah-langkahnya:

1. Membuat Dockerfile
   Di setiap aplikasi Docker, kita harus menulis file bernama Dockerfile. Ini adalah petunjuk untuk Docker tentang bagaimana cara membangun image.

   Misalnya, untuk aplikasi Node.js, Dockerfile-nya bisa seperti ini:

   # Menggunakan image Node.js sebagai base
   FROM node:14
   
   # Menetapkan direktori kerja dalam container
   WORKDIR /app
   
   # Menyalin file aplikasi ke dalam container
   COPY . .
   
   # Menginstal dependensi aplikasi
   RUN npm install
   
   # Menyediakan port yang akan digunakan oleh aplikasi
   EXPOSE 3000
   
   # Menjalankan aplikasi
   CMD ["npm", "start"]
   

   Dengan Dockerfile ini, Docker akan membangun image aplikasi kamu, menginstal dependensi, dan menjalankan aplikasi di dalam container.

2. Membangun Docker Image
   Setelah Dockerfile siap, kamu bisa membangun image menggunakan perintah:

   docker build -t username/app-name:tag .
   

   Image ini akan menjadi versi siap-deploy dari aplikasi kamu, yang bisa disalin ke server produksi.

3. Mendorong Docker Image ke Docker Registry
   Setelah image dibangun, kita perlu mendorongnya ke Docker Registry, seperti Docker Hub atau registry pribadi agar dapat digunakan di server produksi. Gunakan perintah:

   docker push username/app-name:tag
   

   Dengan Docker Hub sebagai tempat penyimpanan, kita bisa memastikan bahwa aplikasi selalu dapat diakses untuk deployment di berbagai lingkungan.

3. Mengatur CI/CD Pipeline untuk Deploy Docker Image

Sekarang saatnya untuk mengotomatiskan alur kerja dengan CI/CD pipeline. Ini adalah langkah kunci untuk membuat deployment aplikasi lebih efisien dan bebas stres.

Di sini, kita akan menggunakan Jenkins atau GitLab CI untuk mengatur pipeline otomatis yang akan membangun dan mendorong Docker image ke registry dan kemudian melakukan deployment ke server produksi.

Jenkins Pipeline untuk Deploy Aplikasi dengan Docker:

1. Install Plugin Docker di Jenkins
   Pastikan Jenkins kamu sudah terpasang plugin Docker, yang memungkinkan Jenkins menjalankan perintah Docker di dalam pipeline.

2. Menulis Jenkinsfile untuk Pipeline CI/CD
   Berikut adalah contoh Jenkinsfile untuk membangun dan mendorong Docker image, lalu men-deploy aplikasi ke server produksi menggunakan Docker:

   pipeline {
       agent any
       
       environment {
           DOCKER_REGISTRY = "docker.io"
           DOCKER_IMAGE_NAME = "username/app-name"
           DOCKER_IMAGE_TAG = "latest"
           PROD_SERVER = "prod.server.com"
       }
   
       stages {
           stage('Build') {
               steps {
                   script {
                       // Membangun Docker image
                       sh 'docker build -t $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG .'
                   }
               }
           }
   
           stage('Push') {
               steps {
                   script {
                       // Login ke Docker Registry
                       sh 'docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD'
                       
                       // Mendorong Docker image ke registry
                       sh 'docker push $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG'
                   }
               }
           }
   
           stage('Deploy to Production') {
               steps {
                   script {
                       // Deploy Docker container ke server produksi
                       sh """
                           ssh user@$PROD_SERVER 'docker pull $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG'
                           ssh user@$PROD_SERVER 'docker stop app-container || true'
                           ssh user@$PROD_SERVER 'docker rm app-container || true'
                           ssh user@$PROD_SERVER 'docker run -d --name app-container $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG'
                       """
                   }
               }
           }
       }
   }
   

   Di Jenkinsfile ini:

   • Stage 'Build': Membangun Docker image dari Dockerfile.
   • Stage 'Push': Mendorong image ke Docker Registry.
   • Stage 'Deploy to Production': Menggunakan SSH untuk login ke server produksi dan menarik (pull) image terbaru, kemudian menjalankan container dengan image tersebut.

GitLab CI Pipeline untuk Deploy Docker:

Jika kamu menggunakan GitLab CI, berikut adalah contoh file .gitlab-ci.yml:

stages:
  - build
  - push
  - deploy

variables:
  DOCKER_REGISTRY: "docker.io"
  DOCKER_IMAGE_NAME: "username/app-name"
  DOCKER_IMAGE_TAG: "latest"
  PROD_SERVER: "prod.server.com"

build:
  stage: build
  script:
    - docker build -t $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG .

push:
  stage: push
  script:
    - docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
    - docker push $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG

deploy:
  stage: deploy
  script:
    - ssh user@$PROD_SERVER 'docker pull $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG'
    - ssh user@$PROD_SERVER 'docker stop app-container || true'
    - ssh user@$PROD_SERVER 'docker rm app-container || true'
    - ssh user@$PROD_SERVER 'docker run -d --name app-container $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG'

4. Manfaat Deploy Aplikasi dengan Docker dalam CI/CD

• Automasi: Dengan CI/CD, kamu bisa mengotomatisasi seluruh proses deployment. Cukup klik tombol, dan semua pekerjaan berat ditangani oleh pipeline.
• Konsistensi: Aplikasi yang dibangun dengan Docker berjalan di container yang konsisten di semua lingkungan. Kamu nggak perlu khawatir tentang masalah “Works on my machine”.
• Keamanan: CI/CD memastikan bahwa hanya image yang sudah teruji yang bisa di-deploy ke produksi.
• Cepat dan Efisien: Proses deploy bisa berlangsung hanya dalam hitungan menit, memungkinkan kamu untuk melakukan deployment sering dan dengan cepat.

5. Kesimpulan: Deployment dengan Docker Itu Asik dan Cepat!

Men-deploy aplikasi dengan Docker dalam alur CI/CD memberikan banyak keuntungan—kecepatan, konsistensi, dan kemudahan. Dengan pipeline otomatis, kamu bisa menghindari kerumitan manual deployment dan memastikan bahwa setiap aplikasi yang di-deploy sudah siap dan teruji dengan baik.

Jadi, jika kamu belum menggunakan Docker dalam CI/CD pipeline, sudah saatnya mulai! Dengan Docker, kamu bisa deploy aplikasi dengan cepat, aman, dan tanpa drama!

Punya tips deployment Docker lainnya? Share yuk di kolom komentar!