Cara Membuat Docker Image Node.js dan menjalankan di Kubernetes Cluster

Pengantar

Di dunia DevOps modern, proses deploy aplikasi tidak lagi dilakukan secara manual di server, melainkan menggunakan container dan orchestration, di mana dua teknologi yang paling umum digunakan adalah Docker dan Kubernetes. Docker membantu kita membungkus aplikasi menjadi image yang portable, sementara Kubernetes mengatur bagaimana aplikasi tersebut dijalankan di dalam cluster. Pada artikel ini, kita akan praktik langsung mulai dari membuat aplikasi Node.js sederhana (hello world), kemudian build Docker image, push ke Docker Hub, hingga deploy ke Kubernetes cluster.

Prasyarat

Berikut prasyarat sebelum melakukan instalasi:

Memahami dasar JavaScript dan penggunaan Node.js
Menginstall Docker di tiap node
Memiliki akun di Docker Hub untuk push image
Menyiapkan environment Kubernetes
Menginstall kubectl untuk mengelola cluster
Familiar dengan penggunaan terminal / command line

Langkah Pertama : Membuat Akun Docker Hub

Sebelum melakukan push image, Anda perlu memiliki akun di Docker Hub sebagai tempat penyimpanan image.

Langkah-langkah:

Buka website: https://hub.docker.com
Klik Sign Up
Buat username (contoh: pwh21)
Selesaikan proses registrasi

Catatan:
Username ini nantinya akan digunakan saat melakukan push image ke Docker Hub.

Langkah Kedua : Membuat Aplikasi Node.js Sederhana

Pada langkah ini, kita akan membuat aplikasi Node.js sederhana yang nantinya akan dijalankan di dalam container.

Buat folder project:
```
mkdir nodejs-app
cd nodejs-app
```

Buat file app.js:

const http = require('http');

const hostname = '0.0.0.0';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.end('Hello World from Kubernetes!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Penjelasan:

Aplikasi menggunakan module http bawaan Node.js
Berjalan di port 3000
Merespon dengan teks Hello World from Kubernetes

Buat file package.json:
```
{
  "name": "nodejs-app",
  "version": "1.0.0",
  "main": "app.js"
}
```
Keterangan:
File ini digunakan untuk mendefinisikan informasi dasar aplikasi Node.js.

Langkah Ketiga : Membuat Dockerfile

Dockerfile digunakan untuk membangun image dari aplikasi Node.js yang sudah dibuat.

Buat file Dockerfile:
```
FROM node:18-alpine

WORKDIR /app

COPY package.json .
RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "app.js"]
```
Penjelasan:
- FROM node:18-alpine menggunakan base image Node.js yang ringan
- WORKDIR /app menentukan direktori kerja di dalam container
- COPY package.json . menyalin file dependency
- RUN npm install menginstall dependency aplikasi
- COPY . . menyalin semua file project
- EXPOSE 3000 membuka port aplikasi
- CMD menjalankan aplikasi saat container start

Langkah Keempat : Build Docker Image

Pastikan Docker sudah terinstall dan berjalan, kemudian build image dari Dockerfile yang sudah dibuat.

Jalankan perintah berikut:
```
docker build -t nodejs-hello:1.0 .
```
Penjelasan:
- -t nodejs-hello:1.0 digunakan untuk memberi nama dan tag pada image
- . menandakan build dilakukan dari direktori saat ini
Cek Docker Image
```
docker images
```
Keterangan :
Perintah ini akan menampilkan daftar image yang tersedia di sistem.

Sebelum melakukan push image, Anda perlu login ke akun Docker Hub terlebih dahulu.

Jalankan perintah berikut:
```
docker login
```
Masukkan informasi berikut saat diminta:
- Username Docker Hub
- Password Docker Hub
Jika berhasil, akan muncul pesan Login Succeeded.

Langkah Keenam : Tag dan Push Image ke Docker Hub

Setelah login, langkah selanjutnya adalah melakukan tag dan push image ke Docker Hub.

Misalnya username Docker Hub Anda:
```
pwh21
```

Tag image:

docker tag nodejs-hello:1.0 pwh21/nodejs-hello:1.0

Push ke Docker Hub:
```
docker push pwh21/nodejs-hello:1.0
```
Penjelasan:
- docker tag digunakan untuk menyesuaikan nama image dengan format Docker Hub
- docker push digunakan untuk mengupload image ke repository Docker Hub
Jika berhasil, image akan tersedia di akun Docker Hub Anda dan siap digunakan untuk deployment di Kubernetes.

Langkah Ketujuh : Membuat Deployment Kubernetes

Setelah image berhasil di-push ke Docker Hub, langkah selanjutnya adalah membuat deployment di Kubernetes.

Buat file konfigurasi:
```
nano deployment.yaml
```

Isi konfigurasi berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nodejs-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nodejs-app
  template:
    metadata:
      labels:
        app: nodejs-app
    spec:
      containers:
      - name: nodejs-container
        image: robertdev/nodejs-hello:1.0
        ports:
        - containerPort: 3000

Penjelasan:

replicas: 2 → Menjalankan 2 pod sekaligus
image → Menggunakan image dari Docker Hub
containerPort: 3000 → Port aplikasi di dalam container

Apply ke cluster
```
kubectl apply -f deployment.yaml
```
Cek Pod
```
kubectl get pods -o wide
```
Catatan :
Pastikan semua pod berstatus Running.

Langkah Kedelapan : Membuat Service

Agar aplikasi dapat diakses dari luar cluster, Anda perlu membuat Service dengan tipe NodePort.

Buat file konfigurasi:
```
nano service.yaml
```
Isi konfigurasi berikut:
```
apiVersion: v1
kind: Service
metadata:
  name: nodejs-service
spec:
  type: NodePort
  selector:
    app: nodejs-app
  ports:
    - port: 3000
      targetPort: 3000
      nodePort: 30007
```
Penjelasan:
- type: NodePort → Membuka akses dari luar cluster
- selector → Menghubungkan service ke pod Node.js
- port → Port service di dalam cluster
- targetPort → Port aplikasi di container
- nodePort → Port yang digunakan untuk akses dari luar (range: 30000–32767)
Apply konfigurasi
```
kubectl apply -f service.yaml
```
Cek Service
```
kubectl get svc
```
Catatan:
Gunakan IP Node dan nodePort untuk mengakses aplikasi dari browser.

Langkah Kesembilan : Akses Aplikasi

Setelah service berhasil dibuat, Anda dapat mengakses aplikasi melalui browser menggunakan IP node dan port yang telah ditentukan.

Format akses:
```
http://IP_NODE:30007
```
Contoh:
```
http://192.168.1.10:30007
```
Jika berhasil, akan muncul tampilan:

Keterangan :
Hal ini menandakan bahwa aplikasi Node.js sudah berhasil berjalan dan dapat diakses dari luar cluster.

Tips atau Catatan Penting

Gunakan tag versi (misalnya 1.0), hindari latest
Pastikan image sudah di-push ke Docker Hub sebelum deploy
Cek detail pod: kubectl describe pod
Lihat log: kubectl logs
Hindari error ImagePullBackOff (image tidak ditemukan)
Pastikan username Docker Hub benar
Sesuaikan port aplikasi dengan konfigurasi Kubernetes

Kesimpulan

Membuat Docker image Node.js dan menjalankannya di Kubernetes cluster sebenarnya cukup sederhana jika dilakukan secara bertahap. Dalam artikel ini, kamu sudah belajar mulai dari membuat aplikasi Node.js sederhana, build Docker image, push ke Docker Hub, deploy ke Kubernetes, hingga mengakses aplikasi dari luar. Selanjutnya, kamu bisa mengeksplorasi penggunaan Ingress agar aplikasi dapat diakses dengan domain, setup CI/CD untuk otomatisasi build dan deploy, serta monitoring menggunakan Prometheus dan Grafana.