Docker Commands Cheat Sheet: 25+ Perintah Penting yang Wajib Dikuasai Developer

Halo teman-teman developer! Kalau kamu masih bingung dengan Docker atau malah baru pertama kali dengar, tenang aja. Artikel ini bakal ngebantu kamu memahami perintah-perintah Docker yang paling penting dan sering dipakai dalam pekerjaan sehari-hari.

Docker sekarang udah jadi alat wajib buat developer modern. Bayangkan aja, dulu kita sering banget ngalamin masalah “eh kok di laptop gue jalan tapi di server nggak bisa ya?”. Nah, Docker hadir buat ngatasin masalah klasik ini dengan cara yang sangat elegan.

Kenapa sih belajar Docker itu penting banget? Pertama, Docker ngasih kita konsistensi lingkungan. Aplikasi yang jalan di laptop kamu bakal jalan persis sama di server produksi. Kedua, proses deployment jadi jauh lebih mudah dan cepat. Tinggal build image, push ke registry, terus pull di server - selesai! Ketiga, manajemen sumber daya jadi lebih efisien karena container lebih ringan dibanding virtual machine tradisional.

Manfaat lainnya yang nggak kalah penting adalah kolaborasi tim jadi lebih lancar. Bayangin tim kamu ada 10 orang dengan sistem operasi yang beda-beda - Windows, macOS, Ubuntu. Tanpa Docker, setup lingkungan bisa memakan waktu berhari-hari dan seringkali ada konflik dependency. Dengan Docker, semua developer cukup jalanin docker-compose up dan boom, semua udah siap pakai!

Belum lagi soal skalabilitas. Docker memungkinkan kita buat nge-scale aplikasi dengan mudah, baik secara horizontal maupun vertikal. Mau nambahin instance aplikasi? Tinggal jalanin container baru. Mau upgrade spesifikasi? Ganti alokasi resource container-nya aja.

Dari segi keamanan juga Docker punya keunggulan. Container terisolasi satu sama lain, jadi kalau ada masalah di satu container, nggak akan ngaruh ke container lain. Plus, image Docker bisa di-scan untuk deteksi kerentanan sebelum di-deploy ke produksi.

Yang paling keren lagi, ekosistem Docker sekarang udah sangat matang. Ada Docker Hub sebagai registry publik, Docker Compose buat aplikasi multi-container, Docker Swarm dan Kubernetes buat orchestration, plus banyak alat pendukung lainnya yang bikin hidup developer jadi lebih mudah.

Makanya, artikel ini bakal ngasih kamu panduan lengkap dengan 25+ perintah Docker yang paling penting. Mulai dari perintah dasar sampai teknik advanced yang bisa langsung kamu pake di proyek nyata. Setiap perintah bakal dijelasin dengan contoh praktis dan use case yang sering kejadian di dunia kerja.

Perintah Dasar Docker yang Wajib Dikuasai

Nah, sekarang kita masuk ke bagian yang paling seru nih - praktek langsung! Sebelum kita lanjut ke perintah-perintah yang lebih ribet, mari kita kuasai dulu tiga perintah dasar yang bakal jadi fondasi kamu dalam menggunakan Docker. Ketiga perintah ini adalah docker run, docker ps, dan docker images.

Bayangkan aja Docker itu kayak sebuah apartemen besar yang punya banyak unit. Setiap unit apartemen itu adalah container, dan cetak biru buat bikin unit apartemen itu namanya image. Nah, ketiga perintah dasar ini bakal ngebantu kamu buat ngelola “apartemen Docker” kamu dengan mudah.

Perintah docker run - Menjalankan Wadah Pertama Kamu

Perintah docker run ini pada dasarnya adalah cara kita buat nyalain container baru dari sebuah image. Ini kayak kunci utama buat mulai nggunain Docker. Sintaksnya gampang banget:

docker run nama_image

Tapi sebelum kita coba, mari kita praktekin dengan contoh yang nyata. Misalnya kamu mau bikin aplikasi web sederhana buat website BuildWithAngga. Kamu bisa pake nginx sebagai web server:

docker run nginx

Eh tapi tunggu, kalau kamu jalanin perintah itu, terminal kamu bakal “hang” dan nggak bisa dipakai lagi. Kenapa? Karena container nginx itu jalan di foreground. Buat ngatasin ini, kita bisa tambahin flag -d yang artinya detached atau jalan di background:

docker run -d nginx

Sekarang container udah jalan di background, tapi masalahnya adalah kita nggak bisa akses websitenya dari browser. Kenapa? Karena port di dalam container belum di-ekspos ke host kita. Buat ngatasin ini, kita perlu mapping port:

docker run -d -p 8080:80 nginx

Perintah di atas artinya kita mapping port 8080 di host kita ke port 80 di dalam container. Sekarang coba buka browser dan akses localhost:8080, pasti udah bisa liat halaman selamat datang nginx!

Tapi tunggu lagi, gimana kalau kita mau kasih nama khusus ke container kita? Biar lebih gampang diingat dan dikelola? Tinggal tambahin flag --name:

docker run -d -p 8080:80 --name buildwithangga-web nginx

Nah sekarang container kita udah punya nama “buildwithangga-web” yang lebih mudah diingat daripada ID yang acak.

Ada lagi nih trick yang berguna. Gimana kalau kita mau container otomatis dihapus setelah berhenti jalan? Misalnya buat testing doang. Kita bisa pake flag --rm:

docker run --rm -p 8080:80 nginx

Flag --rm ini sangat berguna buat development karena nggak bikin sampah container yang nggak kepake.

Satu lagi yang penting, kadang kita perlu masuk ke dalam container buat debugging atau konfigurasi. Kita bisa pake flag -it buat terminal interaktif:

docker run -it ubuntu bash

Perintah ini bakal bikin container Ubuntu dan langsung masuk ke bash terminal di dalamnya. Kayak SSH ke server, tapi lebih cepet dan praktis.

Perintah docker ps - Melihat Daftar Wadah yang Sedang Berjalan

Setelah kita udah bikin beberapa container, pasti kita pengen tau dong container mana aja yang lagi jalan. Nah, perintah docker ps ini fungsinya buat ngeliat daftar container yang sedang aktif:

docker ps

Output dari perintah ini bakal nunjukin informasi penting kayak:

• Container ID (ID unik container)
• Image yang dipake
• Command yang dijalanin
• Waktu kapan container dibuat
• Status container
• Port mapping
• Nama container

Tapi perintah docker ps cuma nunjukin container yang lagi jalan aja. Gimana kalau kita mau liat semua container, termasuk yang udah berhenti? Tinggal tambahin flag -a:

docker ps -a

Nah ini dia yang sering bikin bingung pemula. Container yang udah berhenti itu nggak otomatis hilang lho. Mereka masih ada dan nyimpen data serta perubahan yang udah kita lakuin. Buat ngapus container yang udah berhenti, kita bisa pake perintah docker rm.

Ada lagi nih flag yang berguna, yaitu -q yang cuma nunjukin Container ID aja:

docker ps -q

Ini berguna banget kalau kita mau bikin skrip atau otomasi yang butuh daftar ID container.

Perintah docker images - Melihat Daftar Cetakan yang Tersedia

Sekarang kita bahas perintah docker images. Kalau tadi docker ps buat ngeliat container, maka docker images buat ngeliat daftar image yang udah ada di sistem kita:

docker images

Perintah ini bakal nunjukin informasi tentang:

• Repository (nama image)
• Tag (versi image)
• Image ID
• Kapan image dibuat
• Ukuran image

Misalnya kamu udah download nginx, ubuntu, sama mysql, semua bakal keliatan di sini. Ini penting banget buat ngecek image mana aja yang udah ada sebelum kita jalanin docker run.

Yang perlu diingat, setiap kali kita jalanin docker run dengan image yang belum ada di lokal, Docker bakal otomatis download image-nya dari registry (biasanya Docker Hub). Proses ini namanya “pulling image”.

Buat ngeliat image dengan format yang lebih ringkas, bisa pake flag --format:

docker images --format "table {{.Repository}}\\t{{.Tag}}\\t{{.Size}}"

Pentingnya Pemahaman Kontainerisasi dalam Pengembangan Modern

Sekarang kamu udah tau tiga perintah dasar Docker, tapi sebelum kita lanjut ke perintah yang lebih advanced, penting banget buat kamu pahami kenapa kontainerisasi itu sangat krusial dalam pengembangan aplikasi modern.

Jaman sekarang, aplikasi web udah nggak sesimple dulu yang cuma butuh satu server dengan satu database. Aplikasi modern itu kompleks banget - ada frontend, backend, database, cache, message queue, alat monitoring, dan masih banyak lagi. Bayangin aja kalau semua komponen ini harus di-setup manual di setiap lingkungan (development, testing, produksi), pasti ribet banget kan?

Nah, kontainerisasi dengan Docker ngebantu kita buat nge-package semua dependency dan konfigurasi jadi satu kesatuan yang portable. Aplikasi BuildWithAngga yang pake React + Node.js + PostgreSQL misalnya, bisa di-package jadi tiga container terpisah yang bisa jalan di laptop developer, server testing, sampai produksi dengan perilaku yang konsisten.

Keuntungan lain dari kontainerisasi adalah isolasi. Setiap container punya lingkungan sendiri yang terisolasi. Jadi kalau ada bug atau masalah di satu container, nggak bakal ngaruh ke container lain. Ini bikin aplikasi jadi lebih stabil dan mudah di-debug.

Dari segi manajemen resource juga lebih efisien. Container sharing kernel dengan host OS, jadi overhead-nya jauh lebih kecil dibanding virtual machine. Artinya kita bisa jalan lebih banyak container di hardware yang sama.

Yang paling keren, Docker memungkinkan kita buat nge-adopt arsitektur microservices dengan mudah. Setiap service bisa punya container sendiri, punya strategi scaling sendiri, bahkan punya tim development sendiri. Ini bikin development jadi lebih modular dan scalable.

Dorongan untuk Praktek dan Eksperimen

Nah, setelah kamu baca penjelasan di atas, jangan cuma baca doang ya! Docker itu alat yang harus dipraktekin langsung buat bener-bener paham. Mulai dari sekarang, coba eksperimen dengan berbagai macam image yang ada di Docker Hub.

Misalnya, coba jalanin database PostgreSQL buat proyek BuildWithAngga kamu:

docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=password123 --name buildwithangga-db postgres

Atau mungkin kamu mau coba Redis buat caching:

docker run -d -p 6379:6379 --name buildwithangga-cache redis

Jangan takut buat eksperimen dan “rusak-rusakin”. Container itu bisa dibuang, jadi kalau ada masalah tinggal hapus dan bikin yang baru. Ini adalah salah satu keunggulan terbesar Docker - kamu bisa eksperimen tanpa takut ngerusak sistem utama.

Coba juga buat kombinasi beberapa container buat bikin aplikasi lengkap. Misalnya frontend React, backend Node.js, sama database PostgreSQL sekaligus. Ini bakal ngasih kamu pemahaman yang lebih mendalam tentang bagaimana container-container berinteraksi satu sama lain.

Yang penting, jangan lupa buat selalu baca dokumentasi resmi Docker dan explore Docker Hub buat nemuin image-image yang menarik. Ada ribuan image yang bisa kamu coba, dari web server sampai machine learning frameworks.

Ingat, keahlian itu dateng dari latihan. Semakin sering kamu pake Docker, semakin natural rasanya. Dan percaya deh, skill Docker ini bakal sangat berguna dalam karir development kamu ke depannya!

Manajemen Wadah Docker - Mengelola Siklus Hidup Container

Nah sekarang kita masuk ke bagian yang nggak kalah penting nih - manajemen container! Setelah kamu udah bisa bikin dan ngeliat container, selanjutnya kamu harus tau cara ngelola mereka dengan baik. Bayangkan aja container itu kayak mobil - kamu nggak cuma bisa nyalain doang, tapi juga harus bisa matiin, restart, dan bahkan hapus kalau udah nggak kepake.

Dalam dunia development sehari-hari, kamu pasti bakal sering banget ngalamin situasi di mana container perlu di-restart karena ada perubahan konfigurasi, atau mungkin perlu dihentikan sementara buat maintenance. Makanya, menguasai perintah-perintah manajemen container ini adalah skill fundamental yang wajib banget dikuasai.

Yang keren dari Docker adalah semua perintah manajemen ini sangat intuitif dan mudah diingat. Nggak kayak beberapa alat lain yang perintahnya ribet dan susah dihapal. Docker dirancang dengan filosofi “sederhana tapi powerful”, jadi semua perintahnya straightforward tapi tetep fleksibel.

Perintah docker start - Menghidupkan Kembali Wadah yang Berhenti

Perintah docker start ini fungsinya buat menjalankan kembali container yang udah ada tapi dalam status berhenti. Ini beda sama docker run ya - kalau docker run itu bikin container baru dari image, sedangkan docker start cuma nyalain container yang udah pernah dibuat sebelumnya.

Misalnya tadi kamu udah bikin container buildwithangga-web tapi udah dihentikan:

docker start buildwithangga-web

Gampang banget kan? Tinggal sebutin nama container atau ID-nya, terus container langsung hidup lagi dengan semua konfigurasi dan data yang sama kayak sebelumnya.

Kalau kamu pengen ngeliat output dari container yang lagi di-start, bisa tambahin flag -a (attach):

docker start -a buildwithangga-web

Flag -a ini berguna banget kalau kamu mau monitoring proses startup dari aplikasi di dalam container. Misalnya aplikasi Node.js BuildWithAngga yang butuh waktu beberapa detik buat loading semua module.

Ada juga flag -i (interactive) yang bisa dikombinasiin sama -a kalau container kamu butuh input dari user:

docker start -ai buildwithangga-app

Perintah ini sering dipake kalau container kamu punya interactive shell atau butuh input manual saat startup.

Yang perlu diingat, docker start itu akan menjalankan container dengan perintah yang sama kayak waktu pertama kali container dibuat pake docker run. Jadi semua konfigurasi, environment variable, dan port mapping bakal sama persis.

Perintah docker stop - Menghentikan Wadah dengan Aman

Sekarang kita bahas kebalikannya - gimana cara menghentikan container yang lagi jalan. Perintah docker stop ini fungsinya buat ngehentiin container dengan cara yang aman dan graceful.

docker stop buildwithangga-web

Yang menarik dari perintah ini adalah Docker nggak langsung “bunuh” container-nya. Pertama, Docker ngirim sinyal SIGTERM ke proses utama di dalam container, ngasih waktu buat aplikasi melakukan cleanup yang diperlukan. Kalau setelah 10 detik proses masih belum berhenti, baru Docker ngirim sinyal SIGKILL buat force stop.

Timeout default 10 detik ini bisa kamu ubah pake flag -t:

docker stop -t 30 buildwithangga-web

Perintah di atas ngasih waktu 30 detik buat aplikasi buat shutdown dengan bersih. Ini penting banget buat aplikasi yang butuh waktu lebih lama buat nge-save data atau ngelakuin proses cleanup.

Kalau kamu mau stop beberapa container sekaligus, tinggal sebutin nama atau ID-nya:

docker stop buildwithangga-web buildwithangga-db buildwithangga-cache

Ada juga cara buat stop semua container yang lagi jalan sekaligus pake kombinasi perintah:

docker stop $(docker ps -q)

Perintah ini ngambil semua Container ID yang lagi aktif pake docker ps -q, terus nge-pass semuanya ke docker stop. Hati-hati pake perintah ini ya, karena bakal ngehentiin SEMUA container yang lagi jalan.

Perintah docker restart - Memulai Ulang Wadah

Kadang-kadang kamu butuh restart container, entah karena ada perubahan konfigurasi, memory leak, atau sekedar mau “refresh” aplikasi. Perintah docker restart ini pada dasarnya kombinasi dari docker stop diikuti docker start.

docker restart buildwithangga-web

Proses restart ini akan:

• Ngirim sinyal SIGTERM ke container
• Nunggu sampai container berhenti (dengan timeout yang bisa disetting)
• Menjalankan container lagi dengan konfigurasi yang sama

Sama kayak docker stop, kamu bisa atur timeout dengan flag -t:

docker restart -t 30 buildwithangga-web

Perintah restart ini sangat berguna dalam development. Misalnya kamu lagi develop aplikasi Node.js BuildWithAngga dan udah mount source code ke dalam container, setiap kali ada perubahan code yang butuh restart server, kamu tinggal jalanin docker restart.

Buat restart beberapa container sekaligus juga bisa:

docker restart buildwithangga-web buildwithangga-api buildwithangga-db

Ada satu tips berguna nih - kalau kamu sering restart container tertentu, tapi ini tidak bisa digunakan di PowerShell (Windows), kamu bisa bikin alias di shell:

alias restart-bwa="docker restart buildwithangga-web"

Jadi tinggal ketik restart-bwa aja udah langsung restart container BuildWithAngga kamu.

Perintah docker remove - Menghapus Wadah yang Tidak Dibutuhkan

Terakhir, ada perintah docker rm buat ngapus container yang udah nggak dipake. Ini penting banget buat menjaga kebersihan sistem dan ngirit storage.

Tapi ingat ya, kamu cuma bisa hapus container yang statusnya udah stopped. Kalau container masih jalan, kamu harus stop dulu baru bisa dihapus:

docker stop buildwithangga-web
docker rm buildwithangga-web

Atau kalau mau praktis, bisa pake flag -f (force) buat stop dan remove sekaligus:

docker rm -f buildwithangga-web

Tapi hati-hati pake flag -f ini, karena bakal force stop container tanpa ngasih kesempatan buat graceful shutdown.

Kalau kamu mau hapus container sekaligus sama volume yang di-attach ke container tersebut, pake flag -v:

docker rm -v buildwithangga-web

Buat hapus beberapa container sekaligus:

docker rm buildwithangga-web buildwithangga-api buildwithangga-db

Ada juga perintah powerful buat cleanup container yang udah stopped semua:

docker container prune

Perintah ini bakal nanya konfirmasi dulu sebelum hapus semua container yang statusnya exited. Ini sangat berguna buat maintenance rutin.

Kombinasi Perintah yang Sering Digunakan dalam Development

Dalam development sehari-hari, kamu bakal sering kombinasiin beberapa perintah ini. Misalnya workflow yang umum banget:

Pertama, cek container apa aja yang lagi jalan:

docker ps

Terus stop container yang mau diupdate:

docker stop buildwithangga-web

Hapus container lama:

docker rm buildwithangga-web

Bikin container baru dengan image yang udah diupdate:

docker run -d -p 8080:80 --name buildwithangga-web nginx:latest

Atau kalau cuma mau restart aja:

docker restart buildwithangga-web

Tips dan Trik Manajemen Wadah yang Efisien

Ada beberapa tips yang bisa bikin workflow manajemen container kamu jadi lebih efisien:

Pertama, selalu kasih nama yang deskriptif ke container kamu. Jangan cuma andalin Container ID yang acak. Nama kayak buildwithangga-frontend, buildwithangga-backend, atau buildwithangga-database jauh lebih mudah diingat dan dikelola.

Kedua, pake labels buat kategorisasi container. Misalnya:

docker run -d --label project=buildwithangga --label environment=development --name bwa-web nginx

Terus kamu bisa filter container berdasarkan label:

docker ps --filter label=project=buildwithangga

Ketiga, bikin skrip atau alias buat workflow yang sering dipake. Misalnya skrip bash sederhana:

#!/bin/bashecho "Restarting BuildWithAngga services..."docker restart buildwithangga-web
docker restart buildwithangga-api
docker restart buildwithangga-db
echo "All services restarted successfully!"

Keempat, gunain docker-compose buat manajemen multi-container yang lebih complex. Tapi ini topik terpisah yang bakal kita bahas nanti.

Yang paling penting, jangan lupa buat rutin cleanup container dan image yang udah nggak kepake. Storage disk itu mahal, dan Docker bisa cepet banget memakan storage kalau nggak dikelola dengan baik.

Dengan menguasai empat perintah dasar ini - start, stop, restart, sama remove - kamu udah punya foundation yang solid buat ngelola container Docker dalam proyek apapun. Praktek terus sama jangan takut eksperimen, karena container itu bisa dibuang dan gampang buat dibuat ulang!

Manajemen Image Docker - Mengelola Cetakan Aplikasi Kamu

Nah sekarang kita masuk ke bagian yang lebih seru lagi nih - manajemen image! Kalau tadi kita udah bahas cara ngelola container (yang pada dasarnya adalah instance yang lagi jalan), sekarang kita bahas cara ngelola image atau cetakan dari aplikasi kamu. Bayangkan aja image itu kayak cetak biru atau template yang dipake buat bikin container.

Dalam dunia development modern, manajemen image itu krusial banget. Kamu nggak cuma butuh tau cara download image dari registry, tapi juga harus bisa bikin image sendiri, upload ke registry, dan ngapus image yang udah nggak kepake. Skill ini terutama penting kalau kamu kerja di tim yang pake CI/CD pipeline atau deploy aplikasi ke cloud.

Yang keren dari manajemen image Docker adalah workflow-nya yang sangat natural. Mulai dari pull image buat development, build image custom buat aplikasi kamu sendiri, push ke registry buat sharing sama tim, sampai remove image yang udah kadaluarsa. Semua perintahnya intuitif dan gampang diingat.

Perintah docker pull - Mengunduh Image dari Registry

Perintah docker pull ini fungsinya buat download image dari registry (biasanya Docker Hub). Ini kayak download aplikasi dari app store, tapi bedanya ini buat image container.

Sintaks dasarnya gampang banget:

docker pull nginx

Perintah di atas bakal download image nginx versi terbaru (tag latest) dari Docker Hub. Tapi sebagai praktik terbaik, lebih baik specify versi spesifik buat hindari perilaku yang nggak terduga:

docker pull nginx:1.21-alpine

Kenapa harus specify versi? Karena kalau kamu cuma pake nginx tanpa tag, Docker bakal otomatis ambil tag latest. Masalahnya, tag latest itu bisa berubah sewaktu-waktu, jadi aplikasi kamu bisa tiba-tiba rusak karena ada perubahan yang merusak di versi baru.

Buat proyek BuildWithAngga, misalnya kamu butuh Node.js versi spesifik:

docker pull node:16-alpine

Tag alpine di sini refer ke distribusi Linux yang sangat ringan, perfect buat produksi karena ukurannya kecil tapi tetep powerful.

Kalau kamu mau download image dari registry selain Docker Hub, tinggal specify path lengkapnya:

docker pull ghcr.io/buildwithangga/buildwithangga-app:v1.0.0

Perintah ini download image dari GitHub Container Registry milik BuildWithAngga.

Ada juga flag --all-tags kalau kamu mau download semua versi dari image tertentu:

docker pull --all-tags node

Tapi hati-hati pake flag ini karena bisa download image dalam jumlah besar dan makan storage banyak.

Yang perlu diingat, proses pull ini bisa lemot tergantung ukuran image dan kecepatan internet kamu. Image yang besar kayak image yang include sistem operasi lengkap bisa sampe beratus MB atau bahkan beberapa GB.

Perintah docker build - Membuat Image Custom dari Dockerfile

Nah ini dia bagian yang paling menarik! Perintah docker build memungkinkan kamu buat image custom berdasarkan Dockerfile. Ini pada dasarnya cara kamu package aplikasi kamu sendiri jadi image Docker.

Pertama, kamu butuh bikin file namanya Dockerfile (tanpa extension) di root directory proyek kamu. Misalnya buat aplikasi BuildWithAngga yang pake React:

FROM node:24-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

Terus jalanin perintah build:

docker build -t buildwithangga-frontend .

Flag -t itu buat ngasih nama (tag) ke image yang bakal dibuat. Titik (.) di akhir itu nunjukin lokasi Dockerfile, dalam hal ini current directory.

Proses build ini bakal ngikutin setiap instruksi di Dockerfile langkah demi langkah. Docker pake sistem layer caching yang bikin proses build jadi lebih cepet kalau ada langkah yang nggak berubah.

Kalau kamu mau kasih tag yang lebih spesifik:

docker build -t buildwithangga-frontend:v1.0.0 .

Atau bahkan multiple tags sekaligus:

docker build -t buildwithangga-frontend:v1.0.0 -t buildwithangga-frontend:latest .

Buat proyek yang lebih complex, misalnya aplikasi Node.js backend BuildWithAngga:

FROM node:24-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm ci --only=production
COPY src/ ./src/
EXPOSE 5000
USER node
CMD ["node", "src/app.js"]

Build dengan perintah:

docker build -t buildwithangga-backend:latest .

Ada beberapa flag berguna lainnya buat docker build:

Flag --no-cache buat build tanpa pake cache (berguna kalau ada masalah dengan cached layers):

docker build --no-cache -t buildwithangga-app .

Flag --build-arg buat pass argument ke Dockerfile:

docker build --build-arg NODE_ENV=production -t buildwithangga-app .

Flag -f kalau Dockerfile kamu nggak ada di current directory atau punya nama yang beda:

docker build -f docker/Dockerfile.prod -t buildwithangga-app .

Perintah docker push - Mengunggah Image ke Registry

Setelah kamu berhasil build image custom, langkah selanjutnya biasanya adalah upload ke registry biar bisa diakses sama tim atau buat deployment. Perintah docker push ini fungsinya buat upload image ke registry.

Tapi sebelum bisa push, kamu harus tag image dengan format yang sesuai registry tujuan:

docker tag buildwithangga-frontend docker.io/buildwithangga/frontend:v1.0.0

Atau kalau mau push ke GitHub Container Registry:

docker tag buildwithangga-frontend ghcr.io/buildwithangga/frontend:v1.0.0

Terus jalanin push:

docker push docker.io/buildwithangga/frontend:v1.0.0

Sebelum bisa push, kamu harus login dulu ke registry:

docker login

Atau buat GitHub Container Registry:

docker login ghcr.io

Proses push ini pada dasarnya kebalikan dari pull - Docker bakal upload semua layer dari image kamu ke registry. Yang keren, Docker cuma upload layer yang belum ada di registry, jadi prosesnya lebih efisien.

Buat deployment otomatis atau CI/CD pipeline, biasanya ada workflow kayak gini:

Pertama, build image dengan commit hash sebagai tag:

docker build -t buildwithangga-app:$(git rev-parse --short HEAD) .

Terus tag dengan format registry:

docker tag buildwithangga-app:$(git rev-parse --short HEAD) ghcr.io/buildwithangga/app:$(git rev-parse --short HEAD)

Dan push ke registry:

docker push ghcr.io/buildwithangga/app:$(git rev-parse --short HEAD)

Kalau kamu mau push semua tag dari image tertentu:

docker push --all-tags ghcr.io/buildwithangga/app

Perintah docker rmi - Menghapus Image yang Tidak Dibutuhkan

Terakhir tapi nggak kalah penting, ada perintah docker rmi (remove image) buat ngapus image yang udah nggak dipake. Ini penting banget buat maintenance dan ngirit storage disk.

Sintaks dasarnya:

docker rmi nginx

Atau specify tag spesifik:

docker rmi nginx:1.21-alpine

Kalau mau hapus beberapa image sekaligus:

docker rmi buildwithangga-frontend:v1.0.0 buildwithangga-backend:v1.0.0

Tapi ingat ya, kamu nggak bisa hapus image yang masih dipake sama container yang lagi jalan. Harus stop dan remove container dulu:

docker stop buildwithangga-app
docker rm buildwithangga-app
docker rmi buildwithangga-frontend:v1.0.0

Kalau mau force remove (hapus image sekaligus sama untagged references):

docker rmi -f buildwithangga-frontend:v1.0.0

Ada perintah yang sangat berguna buat cleanup massal - remove semua dangling images (image yang nggak punya tag):

docker image prune

Atau kalau mau remove semua unused images:

docker image prune -a

Perintah prune -a ini bakal hapus semua image yang nggak dipake sama container manapun, jadi hati-hati pakenya.

Workflow Manajemen Image dalam Tim Development

Dalam tim development yang proper, biasanya ada workflow manajemen image yang terstruktur. Misalnya di tim BuildWithAngga:

Developer bikin feature branch dan build image:

git checkout -b feature/new-landing-page
# develop the featuredocker build -t buildwithangga-frontend:feature-landing .

Test image secara lokal:

docker run -p 3000:3000 buildwithangga-frontend:feature-landing

Kalau udah OK, merge ke main branch dan build production image:

git checkout main
git merge feature/new-landing-page
docker build -t buildwithangga-frontend:latest .
docker tag buildwithangga-frontend:latest ghcr.io/buildwithangga/frontend:v2.1.0
docker push ghcr.io/buildwithangga/frontend:v2.1.0

Deploy ke staging environment:

docker pull ghcr.io/buildwithangga/frontend:v2.1.0
docker run -d -p 80:3000 --name staging-frontend ghcr.io/buildwithangga/frontend:v2.1.0

Kalau test di staging berhasil, deploy ke produksi dengan tag yang sama.

Tips Optimasi Ukuran Image dan Performa Build

Ada beberapa tips yang bisa bikin image kamu lebih efisien:

Pertama, gunain multi-stage build buat aplikasi yang butuh proses build. Contoh buat aplikasi React:

# Build stageFROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Production stageFROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Multi-stage build ini bikin image akhir jadi jauh lebih kecil karena nggak include build dependencies.

Kedua, gunain .dockerignore file buat exclude file yang nggak perlu:

node_modules
.git
.gitignore
README.md
.env
.nyc_output
coverage
.nyc_output

Ketiga, combine perintah RUN buat reduce layers:

RUN apt-get update && \\    apt-get install -y curl git && \\    apt-get clean && \\    rm -rf /var/lib/apt/lists/*

Dengan menguasai empat perintah manajemen image ini - pull, build, push, dan rmi - kamu udah bisa handle siklus hidup lengkap dari image Docker. Mulai dari download image buat development, bikin image custom buat aplikasi kamu, share ke tim lewat registry, sampai cleanup image yang udah nggak kepake. Praktek terus dan eksperimen dengan berbagai macam konfigurasi Dockerfile!

Perintah Debugging dan Monitoring Docker - Menyelidiki Masalah Container

Nah sekarang kita masuk ke bagian yang super penting tapi sering diabaikan sama developer pemula - debugging dan monitoring! Ini adalah skill yang bakal ngasih kamu kekuatan super buat nge-solve masalah yang muncul saat development atau produksi. Bayangin aja kamu kayak detektif yang harus nyari tau kenapa aplikasi BuildWithAngga kamu tiba-tiba crash atau kenapa performa jadi lemot.

Dalam dunia container, masalah bisa muncul dari berbagai sumber - aplikasi error, resource habis, masalah network, atau bahkan masalah di level container itu sendiri. Makanya penting banget buat kamu tau cara ngecek kesehatan container, ngeliat log, monitor penggunaan resource, dan bahkan masuk ke dalam container buat investigasi lebih lanjut.

Yang keren dari Docker adalah dia provide alat yang sangat powerful buat debugging dan monitoring. Semua perintahnya dirancang buat ngasih insight yang detail tentang apa yang terjadi di dalam container kamu. Dari log aplikasi sampe penggunaan CPU dan memory, semua bisa dimonitor dengan mudah.

Perintah docker logs - Melihat Catatan Aktivitas Container

Perintah docker logs ini pada dasarnya adalah sahabat terbaik kamu buat debugging. Setiap kali aplikasi di dalam container nge-print sesuatu ke stdout atau stderr, Docker bakal capture dan simpen sebagai logs. Ini kayak ngeliat console output, tapi buat container.

Sintaks dasarnya simple banget:

docker logs buildwithangga-web

Perintah ini bakal nunjukin semua log dari container buildwithangga-web dari pertama kali container jalan sampai sekarang. Tapi kadang log-nya bisa panjang banget, jadi ada beberapa flag yang berguna buat filter output.

Flag -f atau --follow buat monitoring realtime, kayak tail -f di Linux:

docker logs -f buildwithangga-web

Dengan flag ini, kamu bisa liat log yang muncul secara realtime. Sangat berguna waktu kamu lagi develop dan mau tau apakah ada error yang muncul saat testing.

Flag --tail buat ngeliat beberapa baris terakhir aja:

docker logs --tail 50 buildwithangga-web

Perintah ini cuma nunjukin 50 baris terakhir dari log, perfect buat quick check tanpa kewalahan sama log yang panjang.

Flag --since dan --until buat filter berdasarkan waktu:

docker logs --since "2024-01-01T00:00:00" buildwithangga-web

Atau kombinasi beberapa flag:

docker logs -f --tail 20 --since "1h" buildwithangga-web

Perintah ini bakal nunjukin 20 baris terakhir dari log dalam 1 jam terakhir, terus follow buat log baru.

Buat aplikasi Node.js BuildWithAngga yang pake multiple services, kamu bisa monitoring semua sekaligus dengan buka beberapa terminal:

Terminal 1:

docker logs -f buildwithangga-frontend

Terminal 2:

docker logs -f buildwithangga-backend

Terminal 3:

docker logs -f buildwithangga-database

Ada juga flag --timestamps buat nunjukin kapan setiap log entry dibuat:

docker logs --timestamps buildwithangga-web

Perintah docker exec - Masuk ke Dalam Container untuk Investigasi

Kadang-kadang ngeliat log aja nggak cukup, kamu butuh masuk langsung ke dalam container buat investigasi lebih detail. Perintah docker exec memungkinkan kamu njalanin command di dalam container yang lagi running.

Yang paling sering dipake adalah masuk ke shell:

docker exec -it buildwithangga-web bash

Flag -i (interactive) ngasih kamu kemampuan buat input, sedangkan -t (pseudo-TTY) ngasih proper terminal interface. Kombinasi -it ini pada dasarnya bikin kamu bisa interact dengan shell di dalam container kayak SSH ke server.

Kalau container kamu pake Alpine Linux (yang nggak punya bash), gunain sh:

docker exec -it buildwithangga-web sh

Setelah masuk ke dalam container, kamu bisa ngecek berbagai hal:

Ngecek file system:

ls -la /app

Ngecek environment variables:

env | grep NODE

Ngecek proses yang jalan:

ps aux

Ngecek port yang listen:

netstat -tlnp

Kamu juga bisa jalanin command spesifik tanpa masuk ke shell:

docker exec buildwithangga-web ls -la /app

Atau ngecek config file:

docker exec buildwithangga-web cat /app/config.json

Buat debugging aplikasi Node.js BuildWithAngga, kamu bisa ngecek package.json atau environment:

docker exec buildwithangga-backend cat package.json
docker exec buildwithangga-backend node --versiondocker exec buildwithangga-backend npm list

Perintah docker inspect - Melihat Detail Konfigurasi Container

Perintah docker inspect ini ngasih kamu informasi super detail tentang container atau image. Output-nya dalam format JSON yang comprehensive banget, berisi segala macam metadata dan konfigurasi.

docker inspect buildwithangga-web

Output dari perintah ini bakal nunjukin informasi kayak:

• Network settings (IP address, port mappings)
• Volume mounts
• Environment variables
• Resource limits
• Container state
• Image information
• Dan masih banyak lagi

Karena output-nya bisa overwhelming, kamu bisa pake jq buat filter informasi spesifik:

docker inspect buildwithangga-web | jq '.[0].NetworkSettings.IPAddress'

Atau tanpa jq, pake format flag:

docker inspect --format='{{.NetworkSettings.IPAddress}}' buildwithangga-web

Beberapa query yang sering dipake:

Ngecek IP address container:

docker inspect --format='{{.NetworkSettings.IPAddress}}' buildwithangga-web

Ngecek port mapping:

docker inspect --format='{{.NetworkSettings.Ports}}' buildwithangga-web

Ngecek environment variables:

docker inspect --format='{{.Config.Env}}' buildwithangga-web

Ngecek volume mounts:

docker inspect --format='{{.Mounts}}' buildwithangga-web

Buat ngecek kapan container dibuat:

docker inspect --format='{{.Created}}' buildwithangga-web

Perintah inspect juga bisa dipake buat image:

docker inspect buildwithangga-frontend:latest

Perintah docker stats - Monitoring Penggunaan Resource Real-time

Perintah docker stats ini kayak task manager buat container. Dia nunjukin penggunaan resource secara real-time, termasuk CPU, memory, network I/O, sama disk I/O.

docker stats

Perintah ini bakal nunjukin stats dari semua container yang lagi running dalam format table yang update terus. Kamu bisa liat:

• Container ID dan nama
• CPU percentage
• Memory usage dan limit
• Memory percentage
• Network I/O
• Block I/O
• Number of processes (PIDs)

Buat monitoring container spesifik:

docker stats buildwithangga-web

Atau beberapa container sekaligus:

docker stats buildwithangga-web buildwithangga-backend buildwithangga-db

Flag --no-stream buat one-time snapshot (nggak continuous):

docker stats --no-stream

Flag --format buat custom output format:

docker stats --format "table {{.Container}}\\t{{.CPUPerc}}\\t{{.MemUsage}}"

Ini sangat berguna buat identify performance bottlenecks. Misalnya kalau aplikasi BuildWithAngga kamu jadi lemot, kamu bisa liat apakah ada container yang makan CPU atau memory terlalu banyak.

Perintah docker top - Melihat Proses yang Berjalan dalam Container

Perintah docker top ngasih kamu informasi tentang proses yang lagi jalan di dalam container. Ini pada dasarnya ps command yang di-run di dalam container, tapi di-access dari host.

docker top buildwithangga-web

Output-nya bakal nunjukin:

• UID (User ID)
• PID (Process ID)
• PPID (Parent Process ID)
• C (CPU usage)
• STIME (Start time)
• TTY
• TIME (CPU time)
• CMD (Command)

Perintah ini berguna buat ngecek apakah aplikasi di dalam container jalan dengan proper, atau ada proses zombie, atau bahkan ada proses yang nggak seharusnya jalan.

Buat aplikasi Node.js BuildWithAngga, kamu expect ngeliat proses node yang jalan. Kalau nggak ada, berarti ada masalah dengan startup script.

Kombinasi Perintah untuk Workflow Debugging yang Efektif

Dalam prakteknya, debugging container issue biasanya butuh kombinasi beberapa perintah. Ini adalah workflow yang sering saya pake:

Pertama, ngecek apakah container masih hidup:

docker ps

Kalau container mati, ngecek log buat tau kenapa:

docker logs buildwithangga-web

Kalau container hidup tapi aplikasi nggak response, ngecek penggunaan resource:

docker stats buildwithangga-web

Masuk ke container buat investigasi lebih lanjut:

docker exec -it buildwithangga-web bash

Di dalam container, ngecek apakah aplikasi bener-bener jalan:

ps aux | grep node
netstat -tlnp | grep :3000

Ngecek detail konfigurasi container:

docker inspect buildwithangga-web

Tips Debugging untuk Aplikasi BuildWithAngga yang Complex

Buat aplikasi yang complex kayak platform BuildWithAngga dengan multiple services, ada beberapa tips yang bisa ngebantu:

Pertama, always use proper logging di aplikasi kamu. Pastikan semua error, warning, dan info penting di-log dengan level yang sesuai.

Kedua, gunain health checks di Dockerfile:

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
  CMD curl -f <http://localhost:3000/health> || exit 1

Ketiga, set resource limits buat avoid resource starvation:

docker run -d --memory="512m" --cpus="1.0" buildwithangga-backend

Keempat, gunain labels buat better organization:

docker run -d --label service=backend --label environment=production buildwithangga-backend

Terus kamu bisa filter berdasarkan labels:

docker ps --filter label=service=backend

Monitoring Production Environment

Buat production environment, debugging dan monitoring jadi lebih critical. Beberapa praktik yang recommended:

Gunain centralized logging. Kamu bisa forward Docker logs ke external logging system:

docker run -d --log-driver=syslog --log-opt syslog-address=tcp://logserver:514 buildwithangga-web

Set up monitoring alerts berdasarkan penggunaan resource. Misalnya alert kalau memory usage lebih dari 80%.

Gunain docker events buat monitoring siklus hidup container:

docker events --filter container=buildwithangga-web

Regular health checks dengan otomasi skrip:

#!/bin/bashfor container in buildwithangga-web buildwithangga-backend buildwithangga-db; do  if ! docker exec $container curl -f <http://localhost/health> > /dev/null 2>&1; then    echo "Health check failed for $container"    # Send alert or restart container  fidone

Dengan menguasai perintah-perintah debugging dan monitoring ini, kamu bakal jadi jauh lebih percaya diri dalam nge-handle issue yang muncul di produksi. Ingat, skill debugging itu develop over time, jadi jangan frustasi kalau awalnya susah. Praktek terus dan eventually kamu bakal jadi ahli troubleshooting Docker!

Perintah Volume dan Network Docker - Mengelola Data dan Komunikasi Container

Nah sekarang kita masuk ke bagian yang agak lebih advanced tapi super penting - manajemen volume dan network! Ini adalah topik yang sering bikin developer pemula pusing, tapi sebenernya conceptnya cukup simple kalau udah paham. Volume itu pada dasarnya cara kamu nge-persist data dari container, sedangkan network itu cara container berkomunikasi satu sama lain.

Bayangin aja aplikasi BuildWithAngga kamu punya frontend React, backend Node.js, database PostgreSQL, sama Redis buat caching. Semua komponen ini butuh komunikasi yang seamless dan data yang persistent. Nah, volume dan network Docker ini yang bakal ngatasin kedua tantangan tersebut.

Yang keren dari Docker volume dan network adalah mereka provide lapisan abstraksi yang powerful. Kamu nggak perlu mikirin detail low-level tentang storage atau networking di host OS. Docker handle semuanya dengan cara yang portable dan konsisten across different environments.

Perintah Volume Docker - Mengelola Penyimpanan Data Persisten

Pertama-tama, mari kita pahami kenapa volume itu penting. Secara default, semua data yang disimpen di dalam container itu sementara - artinya hilang kalau container di-remove. Buat aplikasi produksi seperti BuildWithAngga yang punya data user, ini jelas nggak acceptable.

Volume Docker provide solusi buat masalah ini. Ada beberapa tipe volume: named volumes, bind mounts, dan tmpfs mounts. Yang paling sering dipake adalah named volumes dan bind mounts.

Membuat dan Mengelola Named Volumes

Named volume adalah cara paling recommended buat produksi. Docker yang handle lokasi storage dan manajemen-nya. Buat bikin volume baru:

docker volume create buildwithangga-data

Perintah ini bikin volume dengan nama buildwithangga-data yang bisa dipake sama container manapun. Buat liat daftar volume yang ada:

docker volume ls

Output-nya bakal nunjukin driver type sama volume name. Buat ngecek detail volume:

docker volume inspect buildwithangga-data

Perintah ini ngasih informasi detail tentang volume, termasuk mount point di host system, driver yang dipake, dan metadata lainnya.

Sekarang cara pake volume di container. Misalnya buat database PostgreSQL BuildWithAngga:

docker run -d \\  --name buildwithangga-postgres \\  -e POSTGRES_PASSWORD=secretpassword \\  -e POSTGRES_DB=buildwithangga \\  -v buildwithangga-data:/var/lib/postgresql/data \\  -p 5432:5432 \\  postgres:13

Flag -v buildwithangga-data:/var/lib/postgresql/data ini mount volume buildwithangga-data ke directory /var/lib/postgresql/data di dalam container. Dengan cara ini, semua data database bakal persist meskipun container di-remove.

Buat aplikasi Node.js yang butuh persistent log files:

docker run -d \\  --name buildwithangga-backend \\  -v buildwithangga-logs:/app/logs \\  -p 5000:5000 \\  buildwithangga/backend:latest

Menggunakan Bind Mounts untuk Development

Bind mounts itu cara mount directory atau file dari host langsung ke container. Ini sangat berguna buat development karena perubahan di host langsung reflected di container.

Misalnya kamu lagi develop aplikasi React BuildWithAngga:

docker run -d \\  --name buildwithangga-frontend \\  -v /path/to/buildwithangga-frontend:/app \\  -v /app/node_modules \\  -p 3000:3000 \\  buildwithangga/frontend:dev

Perintah ini mount source code dari host ke /app di container, tapi exclude node_modules dengan anonymous volume. Jadi kalau kamu edit code di editor, perubahan langsung keliatan di running application.

Buat Windows user, sintaks-nya sedikit beda:

docker run -d \\  --name buildwithangga-frontend \\  -v "C:\\Users\\username\\buildwithangga-frontend:/app" \\  -v /app/node_modules \\  -p 3000:3000 \\  buildwithangga/frontend:dev

Menghapus Volume yang Tidak Digunakan

Volume yang nggak dipake bisa terkumpul over time dan makan storage. Buat ngapus volume spesifik:

docker volume rm buildwithangga-data

Tapi pastikan dulu nggak ada container yang pake volume tersebut. Kalau ada, stop dan remove container dulu.

Buat cleanup semua unused volumes sekaligus:

docker volume prune

Perintah ini bakal hapus semua volume yang nggak di-attach ke container manapun. Hati-hati pakenya karena data yang dihapus nggak bisa di-recover.

Backup dan Restore Data Volume

Buat backup data dari volume, kamu bisa pake container temporary:

docker run --rm \\  -v buildwithangga-data:/data \\  -v $(pwd):/backup \\  alpine tar czf /backup/buildwithangga-backup.tar.gz /data

Perintah ini bikin container temporary yang mount volume dan current directory, terus create compressed backup.

Buat restore:

docker run --rm \\  -v buildwithangga-data:/data \\  -v $(pwd):/backup \\  alpine tar xzf /backup/buildwithangga-backup.tar.gz -C /

Perintah Network Docker - Mengelola Komunikasi Antar Container

Sekarang kita bahas manajemen network. Secara default, Docker bikin network bridge buat semua container, tapi buat aplikasi complex kayak platform BuildWithAngga, kamu butuh konfigurasi network yang custom.

Docker support beberapa network drivers: bridge, host, overlay, macvlan, dan none. Yang paling sering dipake adalah bridge buat aplikasi single-host.

Membuat Custom Network

Buat bikin custom network:

docker network create buildwithangga-network

Atau dengan driver dan subnet spesifik:

docker network create \\  --driver bridge \\  --subnet=172.20.0.0/16 \\  buildwithangga-network

Buat liat daftar network:

docker network ls

Ngecek detail network:

docker network inspect buildwithangga-network

Menjalankan Container dalam Custom Network

Sekarang jalanin container dalam network yang udah dibuat:

docker run -d \\  --name buildwithangga-postgres \\  --network buildwithangga-network \\  -e POSTGRES_PASSWORD=secretpassword \\  -e POSTGRES_DB=buildwithangga \\  -v buildwithangga-data:/var/lib/postgresql/data \\  postgres:13

docker run -d \\  --name buildwithangga-backend \\  --network buildwithangga-network \\  -e DATABASE_URL=postgresql://postgres:secretpassword@buildwithangga-postgres:5432/buildwithangga \\  -p 5000:5000 \\  buildwithangga/backend:latest

Yang keren dari custom network adalah container bisa communicate using container names as hostnames. Backend bisa connect ke database pake hostname buildwithangga-postgres instead of IP address.

Menghubungkan Container ke Multiple Networks

Container bisa connect ke beberapa network sekaligus. Misalnya frontend perlu akses ke backend network dan juga external network:

docker network connect buildwithangga-network buildwithangga-frontend

Atau disconnect dari network:

docker network disconnect buildwithangga-network buildwithangga-frontend

Setup Complete Application Stack BuildWithAngga

Mari kita combine volume dan network buat setup aplikasi stack BuildWithAngga yang lengkap:

Pertama, bikin network dan volumes:

docker network create buildwithangga-net
docker volume create buildwithangga-db-data
docker volume create buildwithangga-redis-data
docker volume create buildwithangga-uploads

Jalanin database:

docker run -d \\  --name buildwithangga-postgres \\  --network buildwithangga-net \\  -e POSTGRES_PASSWORD=strongpassword123 \\  -e POSTGRES_DB=buildwithangga \\  -e POSTGRES_USER=bwa_user \\  -v buildwithangga-db-data:/var/lib/postgresql/data \\  postgres:13-alpine

Jalanin Redis untuk caching:

docker run -d \\  --name buildwithangga-redis \\  --network buildwithangga-net \\  -v buildwithangga-redis-data:/data \\  redis:6-alpine

Jalanin backend API:

docker run -d \\  --name buildwithangga-backend \\  --network buildwithangga-net \\  -e DATABASE_URL=postgresql://bwa_user:strongpassword123@buildwithangga-postgres:5432/buildwithangga \\  -e REDIS_URL=redis://buildwithangga-redis:6379 \\  -v buildwithangga-uploads:/app/uploads \\  -p 5000:5000 \\  buildwithangga/backend:latest

Jalanin frontend:

docker run -d \\  --name buildwithangga-frontend \\  --network buildwithangga-net \\  -e REACT_APP_API_URL=http://localhost:5000 \\  -p 3000:3000 \\  buildwithangga/frontend:latest

Network Troubleshooting dan Debugging

Kalau ada masalah dengan network connectivity, ada beberapa perintah yang berguna buat debugging:

Ngecek container apa aja yang ada di network:

docker network inspect buildwithangga-net | grep -A 5 "Containers"

Test connectivity antar container:

docker exec buildwithangga-backend ping buildwithangga-postgres

Ngecek port yang open di container:

docker exec buildwithangga-backend netstat -tlnp

Test HTTP connectivity:

docker exec buildwithangga-frontend curl <http://buildwithangga-backend:5000/health>

Network Security Best Practices

Buat production environment, ada beberapa praktik keamanan yang harus diikuti:

Jangan ekspos port database ke host, biarkan cuma accessible dari internal network:

docker run -d \\  --name buildwithangga-postgres \\  --network buildwithangga-net \\  -e POSTGRES_PASSWORD=strongpassword123 \\  postgres:13-alpine

Gunain secrets management instead of environment variables buat data sensitif. Docker support secrets di swarm mode:

echo "strongpassword123" | docker secret create db_password -

Create separate networks buat different tiers (frontend, backend, database):

docker network create frontend-net
docker network create backend-net
docker network create database-net

Cleanup Network dan Volume Resources

Buat maintain clean environment, regularly cleanup unused resources:

Remove unused networks:

docker network prune

Remove specific network:

docker network rm buildwithangga-network

Remove unused volumes:

docker volume prune

Complete cleanup (hati-hati pake ini):

docker system prune -a --volumes

Perintah terakhir ini bakal hapus semua unused containers, networks, images, dan volumes. Jangan pake di produksi!

Penutup - Saatnya Praktek!

Nah, sampai di sini kita udah bahas lengkap perintah-perintah Docker yang penting. Dari docker run sampai pengelolaan volume dan network, semua udah dibahas dengan contoh praktis.

Tapi ingat, baca doang nggak cukup! Docker itu keahlian yang harus dipraktekin terus. Mulai sekarang, coba containerize aplikasi yang udah kamu bikin. Eksperimen dan jangan takut buat "rusak-rusakin" - itulah cara terbaik belajar.

Docker bukan cuma alat biasa. Ini keahlian fundamental yang bakal berguna bertahun-tahun ke depan. Containerization udah jadi standar industri dan bisa tingkatkan karir plus gaji kamu secara signifikan.

Kenapa Keahlian Docker Itu Penting Banget

Perusahaan-perusahaan modern lagi aktif nyari developer dengan keahlian Docker. Cloud computing, microservices, DevOps - semua sangat bergantung pada containerization. Developer dengan kemampuan ini biasanya bisa dapat gaji lebih tinggi.

Belum lagi peningkatan produktivitas yang bakal kamu rasain - setup lingkungan jadi cepet, deployment jadi dapat diprediksi, kolaborasi dengan tim jadi lancar.

BuildWithAngga - Tempat Terbaik Belajar Docker

Kalau kamu serius mau tingkatkan keahlian Docker, BuildWithAngga adalah pilihan tepat. Platform ini fokus pada pengalaman hands-on yang langsung bisa diterapin di dunia kerja.

Yang bikin istimewa adalah mentor-mentornya punya pengalaman industri nyata. Mereka nggak cuma ngajarin teori, tapi juga berbagi wawasan tentang tantangan di produksi dan cara mengatasinya.

Course yang Direkomendasikan

Course "Mastering Docker untuk Developer Modern" sangat lengkap, mencakup dasar sampai tingkat lanjut dengan penekanan pada aplikasi dunia nyata.

"Full Stack Development dengan Docker" cocok buat memahami gimana containerization cocok dalam gambaran besar.

"CI/CD Pipeline dengan Docker" pas buat yang tertarik jalur DevOps.

Pembelajaran Terstruktur dengan Bimbingan

BuildWithAngga ngasih jalur belajar yang jelas dengan kemajuan sistematis. Bimbingan dari praktisi berpengalaman plus komunitas yang aktif ngasih kesempatan jaringan dengan profesional industri.

Investasi dalam pendidikan Docker yang tepat bener-bener menguntungkan jangka panjang. Pembelajaran terstruktur lebih efisien dibanding belajar sendiri dari berbagai sumber.

Langkah-langkah Tindakan

Pertama, praktek semua perintah yang udah dibahas. Setup lingkungan lokal dan eksperimen.

Kedua, pertimbangkan mendaftar di BuildWithAngga buat pemahaman menyeluruh dengan bimbingan mentor.

Ketiga, bangun proyek portfolio yang tunjukin kemampuan Docker dan bagikan di GitHub.

Mulai Perjalanan Docker Kamu Sekarang

Setiap ahli dulu pernah jadi pemula. Docker yang kelihatan menakutkan sekarang bakal jadi kebiasaan dengan latihan konsisten. Keahlian containerization bakal tetap relevan bertahun-tahun.

BuildWithAngga siap dukung perjalanan kamu dengan kurikulum terstruktur dan komunitas. Diri kamu di masa depan akan berterima kasih karena mengambil tindakan hari ini.

Jadi jangan tunggu - mulai perjalanan menguasai Docker sekarang dan ubah kemampuan development kamu!