Dockerfile di Helipod: Cara Kerja, Port Detection, dan Best Practice

Kalau kamu pernah mendengar istilah "container" atau "Docker" tapi belum yakin harus mulai dari mana — artikel ini untuk kamu.

Dockerfile adalah file konfigurasi yang memberitahu server bagaimana cara membangun dan menjalankan aplikasi kamu di dalam container. Di Helipod, kamu bisa deploy tanpa Dockerfile (kami generate otomatis), tapi memahami Dockerfile memberi kamu kontrol penuh atas bagaimana aplikasi kamu di-build.

Apa Itu Dockerfile?

Dockerfile adalah sekumpulan instruksi langkah demi langkah yang mendefinisikan environment aplikasi kamu. Bayangkan seperti resep masakan — setiap baris adalah satu instruksi yang memberitahu Docker apa yang harus dilakukan.

# 1. Mulai dari base image
FROM node:20-alpine

# 2. Set working directory
WORKDIR /app

# 3. Copy dependency files
COPY package.json package-lock.json ./

# 4. Install dependencies
RUN npm ci --production

# 5. Copy source code
COPY . .

# 6. Expose port yang dipakai aplikasi
EXPOSE 3000

# 7. Jalankan aplikasi
CMD ["node", "server.js"]

Setiap baris FROM, COPY, RUN, EXPOSE, dan CMD adalah instruksi yang Docker ikuti secara berurutan untuk menghasilkan image — yang nantinya bisa dijalankan sebagai container.

Kenapa Dockerfile Penting?

Tanpa Dockerfile, kamu bergantung pada environment server. Masalah yang sering muncul:

• "Di laptop saya jalan, di server kok error?"
• "Versi Node.js di server beda dari local"
• "Package X tidak terinstall di production"

Dockerfile menghilangkan semua ketidakpastian itu. Aplikasi kamu dijalankan dalam environment yang identik — dari local development sampai production.

Cara Menulis Dockerfile yang Baik

1. Pilih Base Image yang Tepat

Base image adalah fondasi Dockerfile kamu. Pilih yang sesuai dengan kebutuhan:

# Ringan (Alpine) — untuk production
FROM node:20-alpine

# Lengkap (Debian-based) — kalau butuh banyak system packages
FROM node:20-slim

# Specific version — untuk reproducibility
FROM node:20.11.1-alpine

2. Urutkan Layer dengan Benar

Docker menggunakan layer caching. Urutan yang benar = build yang lebih cepat:

# ✅ BENAR: dependency files di-copy dulu
COPY package.json package-lock.json ./
RUN npm ci          # Layer ini di-cache selama package.json tidak berubah

# Source code di bawah (sering berubah)
COPY . .
RUN npm run build

# ❌ SALAH: source code di-copy duluan
COPY . .
RUN npm ci          # Layer ini selalu rebuild (cache miss)

3. Gunakan Multi-Stage Build

Multi-stage build memisahkan tahap build dari tahap run — menghasilkan image production yang jauh lebih kecil:

# Stage 1: Builder
FROM node:20-alpine AS builder
WORKDIR /app
COPY . .
RUN npm ci && npm run build

# Stage 2: Runner
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

Hasilnya? Image 200MB bukan 1GB+.

4. Gunakan .dockerignore

Sama seperti .gitignore, .dockerignore mencegah file tidak perlu masuk ke dalam image:

node_modules
.env
.git
*.md
docker-compose.yml

EXPOSE — Port yang Dipakai Aplikasi

Salah satu instruksi paling penting di Dockerfile adalah EXPOSE. Ini memberitahu Docker port mana yang akan digunakan aplikasi kamu.

# Aplikasi Node.js — port 3000
EXPOSE 3000

# Aplikasi Python/FastAPI — port 8000
EXPOSE 8000

# Aplikasi Laravel — port 8000
EXPOSE 8000

EXPOSE tidak membuka port secara langsung — ini lebih seperti metadata yang memberitahu sistem (dan tools seperti Helipod) port mana yang perlu di-route ke aplikasi kamu.

Cara Helipod Mendeteksi Port dari Dockerfile

Ketika kamu deploy dengan Dockerfile sendiri ke Helipod, sistem kami secara otomatis membaca Dockerfile dan mendeteksi port dari instruksi EXPOSE. Port yang terdeteksi akan digunakan untuk merutekan traffic ke aplikasi kamu.

Contoh:

FROM node:20-alpine
WORKDIR /app
COPY . .
RUN npm ci
EXPOSE 3000
CMD ["node", "server.js"]

Helipod akan mendeteksi port 3000 secara otomatis dari baris EXPOSE.

Penting: Hanya Satu EXPOSE yang Didukung

Helipod mendeteksi satu port pertama dari baris EXPOSE di Dockerfile kamu. Jika kamu menulis beberapa EXPOSE:

EXPOSE 3000
EXPOSE 8080

Helipod akan menggunakan 3000 (port pertama yang ditemukan).

Ini karena Helipod mengarahkan traffic ke satu port utama per pod. Jika aplikasi kamu butuh listen di beberapa port, pertimbangkan untuk:

1. Gunakan satu port utama — proxy semua traffic ke port itu
2. Gunakan TCP mode — untuk service yang butuh port non-HTTP
3. Split ke beberapa pod — pisahkan service yang butuh port berbeda

Best Practice Dockerfile untuk Helipod

1. Selalu Sertakan EXPOSE

# ✅ Baik — Helipod bisa detect port
EXPOSE 3000
CMD ["node", "server.js"]

# ❌ Kurang baik — Helipod tidak tahu port-nya
CMD ["node", "server.js", "--port", "3000"]

2. Gunakan Port Standar

3. Jangan Hardcode Port di CMD

# ❌ Buruk — port di-hardcode di CMD
CMD ["node", "server.js", "--port", "3000"]

# ✅ Baik — baca dari ENV, EXPOSE sebagai metadata
ENV PORT=3000
EXPOSE 3000
CMD ["node", "server.js"]

4. Gunakan .dockerignore

Mencegah file besar dan sensitif masuk ke image:

node_modules
.env
.git
.github
*.log
coverage
dist

Contoh Dockerfile Lengkap

Node.js + Express

FROM node:20-alpine
WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci --production

COPY . .

ENV NODE_ENV=production
EXPOSE 3000
CMD ["node", "server.js"]

Laravel + PHP

FROM php:8.3-fpm-alpine
WORKDIR /var/www/html

COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader --prefer-dist

COPY . .
RUN composer dump-autoload --optimize --no-dev

EXPOSE 8000
CMD ["php-fpm"]

Python + FastAPI

FROM python:3.12-slim
WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

ENV PYTHONUNBUFFERED=1
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Deploy Dockerfile ke Helipod

1. Push Dockerfile ke root repository kamu
2. Connect repo ke Helipod (GitHub/GitLab)
3. Klik Deploy — Helipod akan mendeteksi Dockerfile dan menggunakannya
4. Port akan di-detect otomatis dari EXPOSE di Dockerfile kamu

Jika port tidak ter-detect, pastikan:

• EXPOSE ada di Dockerfile
• Port ditulis sebagai angka: EXPOSE 3000 bukan EXPOSE $PORT
• Tidak ada syntax error di Dockerfile

Kesimpulan

Dockerfile adalah kunci untuk kontrol penuh atas bagaimana aplikasi kamu di-build dan dijalankan. Di Helipod:

• Tanpa Dockerfile → Helipod auto-detect framework dan generate Dockerfile otomatis
• Dengan Dockerfile → Helipod menggunakannya dan mendeteksi port dari EXPOSE

Mau mulai? Tulis Dockerfile di root repo kamu, push, dan deploy ke helipod.io. Gratis, tanpa kartu kredit.

Punya pertanyaan? Hubungi kami di support@helipod.id atau bergabung ke komunitas di hangar.helipod.io.