Dockerfile Best Practices: Menulis Kode yang Lebih Cepat, Ringkas, dan Aman untuk Produksi

Menulis Dockerfile terlihat mudah. Anda cukup menyusun beberapa perintah seperti FROM, COPY, dan RUN, dan dalam sekejap, Anda memiliki sebuah image Docker. Namun, sebuah Dockerfile yang asal-asalan bisa menghasilkan image yang membengkak, lambat untuk dibangun, dan yang lebih parah, rentan terhadap masalah keamanan. Menguasai best practices dalam menulis Dockerfile adalah langkah krusial untuk memastikan aplikasi Anda siap untuk produksi. Artikel ini akan memandu Anda melalui praktik-praktik terbaik yang akan membuat image Anda lebih cepat, ringkas, dan aman.

Baca juga:Lebih dari Sekadar Mainan: Mengupas Teknologi Canggih di Balik Drone Parrot, Pesaing Serius DJI dari Eropa

1. Memanfaatkan Cache Build Docker

Salah satu fitur paling kuat dari Docker adalah sistem caching-nya. Setiap perintah dalam Dockerfile akan membuat layer baru. Jika sebuah perintah dan file yang terlibat tidak berubah, Docker akan menggunakan cache dari layer tersebut, melewati eksekusi perintah dan mempercepat proses build secara signifikan.

Praktik Terbaik: Atur perintah dari yang paling jarang berubah ke yang paling sering berubah.

• Hindari:DockerfileCOPY . . RUN npm install Dengan pendekatan ini, setiap perubahan kecil pada kode sumber (file apapun di direktori) akan memicu npm install kembali, bahkan jika dependensi tidak berubah. Ini sangat tidak efisien.
• Lakukan:DockerfileCOPY package*.json ./ RUN npm install COPY . . Dengan memisahkan COPY file manifest (package.json) dari kode sumber, Docker dapat menggunakan cache untuk RUN npm install selama file manifest tidak berubah. Ini menghemat waktu build yang berharga, terutama saat Anda hanya melakukan perubahan pada kode aplikasi.

2. Memilih Base Image yang Tepat

Ukuran image adalah faktor utama dalam kecepatan build dan distribusi. Image yang besar akan memakan waktu lebih lama untuk diunduh dan di-deploy.

Praktik Terbaik: Gunakan base image yang minimalis.

• Hindari: Menggunakan image seperti ubuntu atau centos sebagai base image dasar. Image ini sering kali mengandung banyak package yang tidak dibutuhkan oleh aplikasi Anda, yang hanya akan menambah ukuran image.
• Lakukan: Gunakan image yang dirancang khusus untuk ringkas. Contohnya, Alpine Linux (alpine), yang terkenal sangat kecil. Untuk aplikasi berbasis Node.js, gunakan node:18-alpine daripada node:18. Untuk Python, gunakan python:3.11-slim atau python:3.11-alpine. slim mengandung dependensi minimal yang dibutuhkan, sementara alpine menggunakan sistem operasi Alpine yang super ringan.

3. Mengurangi Layer dan Mengoptimalkan Perintah RUN

Seperti yang disebutkan, setiap perintah RUN membuat layer baru. Semakin banyak layer, semakin besar potensi ukuran image Anda.

Praktik Terbaik: Gabungkan perintah RUN menjadi satu baris menggunakan && (AND).

• Hindari:DockerfileRUN apt-get update RUN apt-get install -y --no-install-recommends \ package1 \ package2 RUN rm -rf /var/lib/apt/lists/*
• Lakukan:DockerfileRUN apt-get update && \ apt-get install -y --no-install-recommends \ package1 \ package2 && \ rm -rf /var/lib/apt/lists/* Menggabungkan perintah ini menjadi satu RUN tidak hanya mengurangi jumlah layer, tetapi juga memastikan image akhir tidak mengandung cache package manager (/var/lib/apt/lists/*) yang tidak diperlukan. Perintah rm -rf ini sangat penting untuk membersihkan layer dari file-file sementara.

4. Memanfaatkan Multi-Stage Builds

Ini adalah salah satu praktik terbaik terpenting untuk mengurangi ukuran image secara drastis, terutama untuk aplikasi yang memerlukan proses build yang kompleks (seperti kompilasi kode dari sumber).

Konsep Dasar: Multi-stage build menggunakan lebih dari satu FROM dalam Dockerfile. Setiap FROM memulai tahapan build yang baru. Anda dapat menyalin artefak yang dibutuhkan dari satu tahapan ke tahapan berikutnya, meninggalkan semua alat build yang tidak diperlukan di belakang.

Praktik Terbaik: Gunakan satu tahap untuk build (tahap "builder") dan tahap lain untuk menjalankan aplikasi (tahap "runtime").

• Contoh untuk Aplikasi Go:Dockerfile# Tahap 1: Builder FROM golang:1.19 AS builder WORKDIR /app COPY . . RUN CGO_ENABLED=0 GOOS=linux go build -o /app/main . # Tahap 2: Runtime FROM alpine:latest WORKDIR /app COPY --from=builder /app/main . CMD ["./main"] Di sini, image golang:1.19 digunakan untuk mengompilasi kode. Hanya binary yang dihasilkan (main) yang disalin ke image alpine yang jauh lebih kecil. Semua dependensi Go, source code, dan alat compiler dibiarkan di tahap "builder", menghasilkan image final yang sangat ringkas.

5. Keamanan: Menjalankan Sebagai Non-Root User

Secara default, perintah di Dockerfile dijalankan sebagai pengguna root. Ini menimbulkan risiko keamanan. Jika ada celah pada aplikasi, penyerang bisa mendapatkan akses root ke dalam kontainer.

Praktik Terbaik: Beralih ke pengguna non-root segera setelah diperlukan.

• Lakukan:DockerfileFROM node:18-alpine # Buat user baru RUN adduser -D myuser # Ganti kepemilikan direktori kerja WORKDIR /app RUN chown -R myuser /app # Jalankan perintah selanjutnya sebagai user baru USER myuser COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["npm", "start"] Dengan menambahkan USER myuser, semua perintah selanjutnya akan dijalankan dengan hak akses yang lebih rendah, mengurangi potensi kerusakan jika terjadi kompromi keamanan.

Baca juga: Mahasiswa Teknokrat Juara KTI dan Best Expodi PIMPI 2025 IPB University

Dockerfile yang Sempurna

Menulis Dockerfile yang efektif adalah kombinasi dari seni dan sains. Ini bukan hanya tentang membuat aplikasi berjalan, tetapi juga tentang memastikan ia berjalan dengan optimal. Dengan menerapkan praktik-praktik terbaik ini—memanfaatkan cache Docker, memilih base image yang ringkas, mengurangi layer, menggunakan multi-stage builds, dan meningkatkan keamanan—Anda tidak hanya akan membuat image yang lebih kecil dan lebih cepat, tetapi juga akan membangun fondasi yang kokoh untuk alur kerja CI/CD yang kuat dan efisien. Menguasai Dockerfile adalah investasi berharga bagi setiap pengembang yang serius tentang produksi perangkat lunak modern.

Penulis: Fiska Anggraini