Docker init: Cara Menginisialisasi Proyek dengan Docker (Panduan Langkah demi Langkah)

Entah kenapa, menyiapkan proyek baru dengan Docker selalu memakan waktu lebih lama dari seharusnya.

Anda mencari templat di Google, menempelkannya, mengubah beberapa baris, dan berharap hasilnya baik. Build gagal, lalu Anda mengutak-atik dan mengulangi siklusnya sampai berhasil. Setiap proyek baru dimulai dengan cara yang sama — dengan file kosong dan ingatan samar tentang apa yang berhasil terakhir kali. Ini jelas masalah penyiapan, dan Docker bukan penyebabnya.

Kabar baiknya, docker init memperbaikinya. Ini adalah perintah CLI yang mendeteksi tipe proyek Anda dan menghasilkan Dockerfile, .dockerignore, dan file Compose.

Dalam artikel ini, saya akan memandu Anda tentang cara kerja docker init, cara menggunakannya langkah demi langkah dengan proyek Python nyata, dan kapan ini merupakan alat yang tepat untuk pekerjaan tersebut.

Apakah Anda benar-benar baru dalam Docker dan kontainerisasi? Pelajari mengapa ini merupakan bagian penting dari perangkat profesional data dengan mengikuti kursus Introduction to Docker kami.

Apa Itu Docker init

docker init adalah alat CLI yang menyiapkan konfigurasi Docker untuk proyek Anda. Ini menghasilkan file yang Anda perlukan untuk mengontainerkan aplikasi Anda. Jadi, tidak perlu lagi templat atau salin-tempel.

Alat ini menghasilkan tiga file:

• Dockerfile - mendefinisikan bagaimana image kontainer Anda dibangun
• .dockerignore - memberi tahu Docker file mana yang harus dikecualikan dari konteks build
• compose.yml - opsional, namun berguna untuk penyiapan multi-layanan

Bagian cerdasnya adalah deteksi proyek otomatis. docker init melihat struktur proyek Anda dan mengetahui stack yang Anda gunakan — Python, Node.js, Go, dan lainnya. Kemudian ia menghasilkan file sesuai stack tersebut alih-alih membuat templat generik.

Ini bukan alat deployment, dan tidak akan mengelola kontainer Anda di produksi. Alat ini hanya memulai konfigurasi Anda agar Anda bisa fokus pada pekerjaan sebenarnya.

Cara Kerja Docker init

docker init mengikuti alur empat langkah setiap kali Anda menjalankannya.

Pertama, Anda menjalankan docker init di dalam folder proyek Anda. Docker memindai direktori, mendeteksi tipe proyek Anda, dan memilih templat konfigurasi yang sesuai. Lalu alat ini memandu Anda melalui serangkaian prompt interaktif singkat — seperti port mana yang digunakan aplikasi Anda dan perintah apa yang menjalankannya. Setelah menjawabnya, ia akan menghasilkan file Anda.

Seluruh proses memakan waktu kurang dari satu menit.

Prompt-nya mudah dijawab dan jarang memerlukan penjelasan tambahan. Anda dapat menerima nilai default dengan menekan Enter, atau mengetikkan nilai Anda sendiri jika default tidak cocok. 

Berikut yang akan Anda lihat saat pertama kali menjalankan perintah:

Layar penyiapan Docker init

Selanjutnya, saya akan menunjukkan proses ini secara lebih detail.

Cara Menggunakan Docker init Langkah demi Langkah

Berikut gambaran umum cara beralih dari folder proyek ke kontainer yang berjalan.

Langkah 1: Masuk ke direktori proyek Anda

Buka terminal dan masuk ke root proyek Anda — folder yang berisi kode aplikasi Anda.

cd /path/to/your/project

docker init menghasilkan file relatif terhadap tempat Anda menjalankannya, jadi pastikan Anda berada di direktori yang benar sebelum melanjutkan.

Langkah 2: Jalankan Docker init

Jalankan perintah berikut:

docker init

Docker akan memindai folder proyek Anda, mendeteksi stack Anda, dan menampilkan prompt penyiapan interaktif.

Langkah 3: Jawab prompt

docker init akan menanyakan beberapa pertanyaan:

• Platform aplikasi — bahasa atau kerangka kerja yang digunakan proyek Anda (Python, Node.js, Go, dll.)
• Port — port yang didengarkan aplikasi Anda
• Perintah mulai — perintah yang harus dijalankan Docker untuk memulai aplikasi Anda

Anda dapat menerima nilai default yang disarankan dengan menekan Enter, atau mengetikkan nilai Anda sendiri. Jika docker init mendeteksi stack Anda, nilai default biasanya sudah cukup untuk memulai.

Langkah 4: Tinjau file yang dihasilkan

Setelah Anda menjawab prompt, docker init menulis tiga file ke folder proyek Anda:

.
├── Dockerfile
├── .dockerignore
└── compose.yaml

Buka setiap file dan bacalah. File yang dihasilkan menyertakan komentar yang menjelaskan apa fungsi setiap baris, jadi sebaiknya luangkan beberapa menit untuk memahami apa yang dibuat sebelum Anda melakukan build apa pun.

Langkah 5: Build dan jalankan kontainer Anda

Build dan mulai kontainer Anda dengan Docker Compose:

docker compose up --build

Flag --build memberi tahu Docker untuk membangun image dari Dockerfile Anda sebelum memulai kontainer. Setelah berjalan, aplikasi Anda akan dapat diakses pada port yang Anda tentukan di langkah 3.

Tipe Proyek yang Didukung di Docker init

docker init mendukung stack aplikasi paling umum secara bawaan. Berikut beberapa di antaranya:

• Python
• Node.js
• Go
• Java
• .NET

Deteksi stack dilakukan secara otomatis.. Saat Anda menjalankan docker init, alat ini memindai folder proyek Anda untuk file spesifik bahasa — seperti requirements.txt untuk Python atau package.json untuk Node.js — dan memilih templat yang tepat berdasarkan temuannya.

Setiap templat disesuaikan dengan stack-nya. Proyek Python mendapatkan base image, perintah instal, dan perintah mulai yang berbeda dari proyek Go. Anda tidak mendapatkan Dockerfile serba guna dengan variabel bahasa yang ditukar. Strukturnya sendiri berubah tergantung pada apa yang Anda bangun.

Jika docker init tidak dapat mendeteksi stack Anda, alat ini akan meminta Anda memilihnya secara manual dari daftar.

File yang Dihasilkan oleh Docker init

docker init menghasilkan tiga file, dan masing-masing memiliki peran berbeda dalam penyiapan Anda.

Dockerfile

Dockerfile mendefinisikan bagaimana Docker membangun image kontainer Anda. File ini memberi tahu Docker base image mana yang digunakan, cara menginstal dependensi Anda, dan perintah apa yang dijalankan saat kontainer dimulai.

Berikut contoh tampilan Dockerfile Python yang dihasilkan:

FROM python:3.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Sebaiknya tinjau file ini sebelum membangun. Keluaran yang dihasilkan adalah titik awal yang baik, tetapi Anda mungkin perlu menyesuaikannya — misalnya, untuk menambahkan variabel lingkungan atau menyesuaikan versi base image.

.dockerignore

File .dockerignore memberi tahu Docker file mana yang harus dikecualikan dari konteks build. Ini adalah kumpulan file yang dikirim Docker ke mesin build saat membuat image.

Tanpanya, Docker akan menyalin semua yang ada di folder proyek Anda ke dalam image, termasuk hal-hal seperti .git, node_modules, atau file konfigurasi lokal yang tidak Anda perlukan di produksi. Itu meningkatkan ukuran image Anda dan dapat mengekspos file yang tidak bermaksud Anda sertakan.

Contoh .dockerignore yang umum terlihat seperti ini:

.git
.env
__pycache__
*.pyc
node_modules

File Docker Compose

File compose.yaml digunakan untuk menjalankan penyiapan multi-kontainer. File ini mendefinisikan layanan, port, volume, dan cara kontainer saling terhubung.

Untuk aplikasi satu kontainer yang sederhana, Anda mungkin tidak memerlukannya. Namun jika proyek Anda melibatkan database, cache, atau layanan lain yang berjalan berdampingan dengan aplikasi Anda, file Compose adalah tempat Anda mengonfigurasi semuanya di satu tempat.

Contoh: Menggunakan Docker init dengan Proyek Python

Mari jalankan docker init pada proyek nyata. Saya akan menggunakan aplikasi FastAPI minimal dengan satu rute sebagai contoh.

Berikut struktur proyek sebelum menjalankan docker init:

my-fastapi-app/
├── app.py
└── requirements.txt

app.py memiliki satu rute Hello World:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, World!"}

Dan requirements.txt memiliki dua dependensi ini:

fastapi
uvicorn

Menjalankan docker init

Untuk memulai, masuk ke folder proyek dan jalankan:

docker init

Proyek terdeteksi oleh Docker init

docker init mendeteksi Python dari requirements.txt dan menanyakan beberapa pertanyaan. Berikut tampilan prompt-nya dan apa yang harus dijawab:

Prompt Docker init untuk proyek Python

Apa yang dihasilkan

Setelah menjawab prompt, folder proyek Anda akan terlihat seperti ini:

Struktur folder proyek baru

Ada tiga file baru. Mari kita lihat masing-masing.

Dockerfile

# syntax=docker/dockerfile:1

ARG PYTHON_VERSION=3.14
FROM python:${PYTHON_VERSION}-slim as base

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser

RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=bind,source=requirements.txt,target=requirements.txt \
    python -m pip install -r requirements.txt

USER appuser

COPY . .

EXPOSE 8000

CMD uvicorn 'app:app' --host=0.0.0.0 --port=8000

Ada beberapa hal yang menonjol di sini. PYTHONDONTWRITEBYTECODE=1 menghentikan Python menulis file .pyc ke disk, dan PYTHONUNBUFFERED=1 memastikan log muncul secara real time alih-alih ditahan di buffer — keduanya adalah default yang baik untuk aplikasi yang dikontainerkan.

Blok adduser membuat pengguna non-privileged bernama appuser untuk menjalankan aplikasi. Secara default, kontainer Docker berjalan sebagai root, yang merupakan risiko keamanan. Berjalan sebagai pengguna non-root membatasi apa yang dapat dilakukan penyerang jika mereka berhasil keluar dari aplikasi Anda.

Flag --mount=type=cache pada langkah pip install memberi tahu Docker untuk menyimpan cache paket yang diunduh antar build. Ini berarti build berikutnya tidak akan mengunduh ulang dependensi dari awal, sehingga mempercepat proses.

.dockerignore

**/.DS_Store
**/__pycache__
**/.venv
**/.env
**/.git
**/.gitignore
**/node_modules
**/Dockerfile*
**/compose.y*ml
README.md

File .dockerignore mengecualikan file yang tidak perlu masuk ke image Anda. File lingkungan lokal seperti .env, folder kontrol versi seperti .git, dan file cache Python seperti __pycache__ semuanya dilewati. Dockerfile dan compose.yaml itu sendiri juga dikecualikan — Docker tidak memerlukannya di dalam image yang sedang dibangun.

compose.yaml

services:
  server:
    build:
      context: .
    ports:
      - 8000:8000

File Compose mendefinisikan aplikasi Anda sebagai layanan bernama server, membangunnya dari Dockerfile di direktori saat ini, dan memetakan port 8000 pada host Anda ke port 8000 di dalam kontainer.

Ketiga file yang dihasilkan menyertakan beberapa komentar yang saya hilangkan agar tetap rapi.

Jalankan docker compose up --build dan aplikasi FastAPI Anda akan aktif di http://localhost:8000.

Aplikasi FastAPI berjalan di dalam kontainer

Docker init vs Penyiapan Dockerfile Manual

Kedua pendekatan akan menghasilkan Dockerfile yang berfungsi, jadi ini soal seberapa banyak kendali yang Anda butuhkan dan seberapa cepat Anda ingin sampai ke sana.

Docker init

docker init adalah opsi yang lebih cepat. Anda menjawab beberapa prompt dan mendapatkan konfigurasi yang berfungsi serta cukup aman dalam waktu kurang dari satu menit. File yang dihasilkan mengikuti praktik terbaik Docker — pengguna non-root, caching build, pola .dockerignore yang tepat — sehingga Anda tidak mulai dari nol.

Ini cocok saat Anda memulai proyek baru, melakukan onboarding rekan tim, atau hanya ingin dasar yang solid untuk dikembangkan tanpa menghabiskan waktu pada boilerplate.

Namun ada pertanyaan tentang fleksibilitas. Templat mencakup stack umum dengan baik, tetapi tetap saja templat. Jika proyek Anda memiliki struktur yang tidak biasa atau kebutuhan build spesifik, Anda akan menemukan batasan dari apa yang dapat dihasilkan docker init.

Penyiapan manual

Menulis Dockerfile sendiri memberi Anda kendali penuh atas setiap layer, setiap instruksi, dan setiap keputusan build. Anda dapat menerapkan multi-stage build untuk meminimalkan ukuran image, menggunakan base image kustom, atau menyetel perilaku caching dengan cara yang tidak dapat diantisipasi oleh docker init.

Namun, Anda harus tahu apa yang Anda lakukan. Dockerfile yang ditulis dengan buruk dapat menghasilkan image berukuran besar, menimbulkan masalah keamanan, atau gagal dengan cara yang sulit di-debug, terutama jika Anda belum berpengalaman sejak awal.

Yang mana yang digunakan

Berikut cara sederhana untuk memikirkannya:

Perbandingan Docker init versus penyiapan manual

Pendekatan yang baik adalah mulai dengan docker init lalu mengedit file yang dihasilkan secara manual seiring bertumbuhnya kebutuhan Anda.

Kapan Menggunakan Docker init

docker init bukan alat yang tepat untuk setiap situasi. Berikut kapan masuk akal digunakan dan kapan tidak.

Gunakan docker init saat:

• Anda memulai proyek baru: Alat ini mengawali konfigurasi Docker Anda dalam waktu kurang dari satu menit, sehingga Anda bisa fokus menulis kode alih-alih menyiapkan kontainerisasi

• Anda sedang belajar Docker: File yang dihasilkan diberi komentar dengan baik dan mengikuti praktik terbaik. Ini titik awal yang lebih baik daripada cuplikan acak dari Stack Overflow

• Anda membuat prototipe: Saat Anda membutuhkan lingkungan terkontainer dengan cepat dan tidak peduli menyetel build secara mendetail, docker init memberi Anda sesuatu yang langsung berfungsi

• Anda melakukan standarisasi di seluruh tim: Alih-alih setiap pengembang membuat Dockerfile sendiri, docker init memberi semua orang titik awal yang konsisten dengan struktur dan default yang sama

Meski begitu, Anda sebaiknya melewatkan docker init saat:

• Anda memerlukan multi-stage build: Jika Anda mengoptimalkan ukuran image dengan membagi build menjadi beberapa tahap — kompilasi di satu tahap, menjalankan di tahap lain — Anda harus menulisnya secara manual. Dockerfile yang dihasilkan adalah single-stage

• Anda memiliki kebutuhan produksi yang kompleks: Base image kustom, strategi caching tingkat lanjut, tata letak proyek non-standar — ini bukan hal yang dapat diantisipasi oleh docker init. Anda akan menghabiskan lebih banyak waktu mengakali file yang dihasilkan daripada menulisnya sendiri

Sebagai penutup, docker init adalah titik awal. Gunakan untuk mulai bergerak, lalu edit file yang dihasilkan seiring bertambahnya kebutuhan Anda.

Keterbatasan Docker init

Anda bisa menemui beberapa keterbatasan seiring berkembangnya proyek. Berikut beberapa di antaranya.

File yang dihasilkan bersifat berbasis templat. File tersebut dirancang untuk mencakup kasus paling umum untuk setiap stack yang didukung, yang berarti bekerja dengan baik untuk proyek umum dan kurang baik untuk hal-hal di luar rentang itu. Jika proyek Anda memiliki struktur yang tidak biasa, file yang dihasilkan mungkin tidak mengakomodasinya.

Keterbatasan umum lainnya adalah penyetelan manual hampir selalu diperlukan. Default-nya bagus, tetapi tetap saja default. Anda kemungkinan perlu menyesuaikan versi base image, menyetel variabel lingkungan, atau mengubah perintah mulai sebelum konfigurasi sesuai dengan proyek Anda. Anggap file yang dihasilkan sebagai draf pertama, tidak lebih.

docker init juga tidak mendukung pola build tingkat lanjut. Multi-stage build, argumen build kustom, logika kondisional, dan teknik lain yang diandalkan pengguna Docker berpengalaman untuk image produksi berada di luar cakupan yang dihasilkan alat ini. Namun jika Anda membutuhkan semua itu, Anda memang akan menulis Dockerfile sendiri.

Semua ini tidak membuat docker init menjadi alat yang buruk. Ini hanya berarti Anda perlu memiliki ekspektasi yang tepat — alat ini menghilangkan masalah halaman kosong, tetapi tidak menggantikan kebutuhan untuk memahami isi Dockerfile Anda.

Praktik Terbaik Setelah Menggunakan Docker init

File yang dihasilkan docker init adalah titik awal. Berikut langkah-langkah yang perlu Anda ambil untuk menjadikannya siap produksi.

• Tinjau file yang dihasilkan: Baca Dockerfile, .dockerignore, dan compose.yaml baris demi baris. File-file tersebut diberi komentar dengan baik, jadi ini tidak akan memakan waktu lama. Anda ingin memahami isinya sebelum mulai membangun di atasnya

• Optimalkan ukuran image Anda: Base image default adalah python:3.x-slim, yang sudah ringan. Namun Anda bisa melangkah lebih jauh dengan memastikan .dockerignore mengecualikan semua yang semestinya, dan memeriksa bahwa Anda tidak menyalin file ke dalam image yang tidak perlu ada di sana

• Pindahkan rahasia dan nilai spesifik lingkungan ke variabel lingkungan: Jangan hardcode kunci API, URL database, atau flag lingkungan di Dockerfile Anda. Gunakan variabel lingkungan, dan kelola melalui file .env secara lokal atau pengelolaan rahasia di platform deployment Anda untuk produksi

• Uji secara lokal sebelum mendorong ke mana pun: Jalankan docker compose up --build dan verifikasi bahwa aplikasi Anda berperilaku sama di dalam kontainer seperti di luar. Periksa log Anda, kunjungi endpoint Anda, dan pastikan pemetaan port berfungsi

• Perhalus langkah build seiring pertumbuhan proyek: Dockerfile yang dihasilkan menginstal dependensi dalam satu layer. Saat proyek Anda matang, pikirkan tentang urutan layer. Artinya, letakkan langkah yang jarang berubah lebih awal di file agar Docker bisa melakukan caching. Jika waktu build mulai meningkat, biasanya itu tempat pertama yang perlu diperiksa

Masalah Umum dan Pemecahan Masalah

Seperti biasa dalam teknologi, beberapa hal bisa salah. Berikut yang perlu dicari dan cara memperbaikinya.

Deteksi proyek yang tidak tepat

Jika docker init memilih stack yang salah, alat ini akan menghasilkan file yang tidak sesuai dengan proyek Anda. Ini biasanya terjadi saat folder proyek Anda memiliki file campuran beberapa bahasa atau kehilangan file yang dicari docker init — seperti requirements.txt untuk Python atau package.json untuk Node.js.

Saat prompt menanyakan platform aplikasi Anda, cukup pilih yang benar secara manual alih-alih menerima default yang terdeteksi.

Konflik port

Jika kontainer Anda berjalan namun Anda tidak dapat mengakses aplikasi, atau Docker menampilkan error tentang port yang sudah digunakan, kemungkinan proses lain di mesin Anda menggunakan port yang sama.

Cari dan hentikan proses yang bertentangan, atau ubah port sisi host di compose.yaml Anda:

ports:
  - 8001:8000  # maps host port 8001 to container port 8000

Sisi kiri adalah port pada mesin Anda. Sisi kanan harus cocok dengan port yang didengarkan aplikasi Anda di dalam kontainer.

Dependensi hilang

Jika kontainer Anda terbangun tetapi crash saat mulai, dependensi yang hilang sering menjadi penyebabnya. Periksa apakah requirements.txt (atau yang setara) lengkap dan terbaru. Jika Anda menambahkan paket secara lokal tanpa memperbarui file itu, kontainer tidak akan memilikinya.

Jalankan docker compose logs untuk melihat keluaran error:

docker compose logs

Pesan error biasanya akan memberi tahu Anda paket mana yang hilang.

Kontainer tidak mulai

Jika kontainer sama sekali tidak mau mulai, masalahnya hampir selalu ada pada baris CMD di Dockerfile Anda. Periksa apakah perintah mulai sesuai dengan cara Anda benar-benar menjalankan aplikasi.

Untuk contoh FastAPI, seharusnya terlihat seperti ini:

CMD uvicorn 'app:app' --host=0.0.0.0 --port=8000

Jika nama file entry point berbeda atau jalur modul salah, kontainer akan keluar. Perbaiki CMD, build ulang dengan docker compose up --build, dan periksa log lagi.

Kesimpulan

docker init tidak akan menggantikan pemahaman mendalam tentang Docker, tetapi akan menghilangkan masalah halaman kosong.

Dengan satu perintah, Anda mendapatkan Dockerfile, .dockerignore, dan file compose.yml yang berfungsi — semuanya mengikuti praktik terbaik Docker sendiri. Itu fondasi yang baik untuk proyek baru mana pun, dan titik awal yang jauh lebih baik daripada templat salin-tempel dari Stack Overflow atau ChatGPT.

Hanya saja jangan berhenti di situ. File yang dihasilkan memang dimaksudkan untuk diedit. Tinjau, sesuaikan langkah build, kunci versi base image Anda, dan tambahkan variabel lingkungan Anda. Semakin berkembang proyek Anda, semakin Anda akan menjauh dari default.

Jika Anda sudah memahami dasar-dasar Docker, langkah logis berikutnya adalah mempelajari multi-stage build, alat jaringan, dan Docker Compose — semuanya dibahas dalam kursus Intermediate Docker kami.