Docker untuk Developer: Panduan Praktis

# Update package index
sudo apt update

# Install dependencies
sudo apt install -y ca-certificates curl gnupg

# Tambah Docker GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Tambah Docker repository
echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# Tambah user ke grup docker (agar tidak perlu sudo)
sudo usermod -aG docker $USER

# Verifikasi instalasi
docker --version
docker run hello-world

# Cek versi Docker
docker --version
# Output: Docker version 27.0.3, build 7d4bcd8

# Cek info sistem Docker
docker info

# Jalankan container test
docker run --rm hello-world
# Output: Hello from Docker!
#         This message shows that your installation appears
#         to be working correctly.

# Dockerfile untuk aplikasi Node.js sederhana
# BeebaneLabs - Docker Tutorial

# 1. Base image - gunakan image resmi yang ringan
FROM node:20-alpine

# 2. Metadata (opsional tapi disarankan)
LABEL maintainer="developer@beebanelabs.com"
LABEL description="Aplikasi Node.js sederhana dengan Docker"

# 3. Set working directory di dalam container
WORKDIR /app

# 4. Copy package files dulu (manfaatkan layer caching)
COPY package*.json ./

# 5. Install dependencies
RUN npm ci --only=production

# 6. Copy source code aplikasi
COPY . .

# 7. Set environment variable
ENV NODE_ENV=production
ENV PORT=3000

# 8. Expose port yang digunakan aplikasi
EXPOSE 3000

# 9. Perintah untuk menjalankan aplikasi
CMD ["node", "server.js"]

# Dockerfile untuk aplikasi Flask/Python
FROM python:3.12-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements dan install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy aplikasi
COPY . .

# Buat user non-root untuk keamanan
RUN adduser --disabled-password --gecos "" appuser
USER appuser

EXPOSE 5000

CMD ["python", "app.py"]

# Build image dari Dockerfile
docker build -t my-app:v1.0 .

# Lihat daftar images
docker images
# REPOSITORY   TAG    IMAGE ID       SIZE
# my-app       v1.0   abc123def456   150MB

# Jalankan container dari image
docker run -d -p 3000:3000 --name web-app my-app:v1.0

# Lihat container yang berjalan
docker ps

# Lihat log container
docker logs web-app

# Masuk ke dalam container (debug)
docker exec -it web-app /bin/sh

# Hentikan dan hapus container
docker stop web-app
docker rm web-app

# Tarik image dari Docker Hub
docker pull nginx:latest
docker pull python:3.12-slim
docker pull node:20-alpine

# Lihat semua images lokal
docker images
docker image ls

# Lihat detail image
docker inspect nginx:latest

# Lihat history layer image
docker history nginx:latest

# Beri tag baru pada image
docker tag my-app:v1.0 my-app:latest
docker tag my-app:v1.0 registry.example.com/my-app:v1.0

# Hapus image
docker rmi nginx:latest
docker image rm my-app:v1.0

# Hapus semua image yang tidak digunakan
docker image prune -a

# Stage 1: Build
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /server .

# Stage 2: Production (image kecil!)
FROM alpine:3.19
RUN apk --no-cache add ca-certificates
COPY --from=builder /server /server
EXPOSE 8080
CMD ["/server"]

# Hasil: image hanya ~15MB dibanding ~800MB jika pakai golang image

# === NAMED VOLUME ===
# Buat volume baru
docker volume create my-data

# Lihat semua volumes
docker volume ls

# Inspect volume
docker volume inspect my-data

# Gunakan volume saat menjalankan container
docker run -d \
  --name postgres-db \
  -v my-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:16

# === BIND MOUNT ===
# Mount direktori lokal ke container
docker run -d \
  --name web-server \
  -v $(pwd)/html:/usr/share/nginx/html:ro \
  -p 8080:80 \
  nginx:latest

# :ro = read-only, :rw = read-write (default)

# === TMPFS MOUNT ===
docker run -d \
  --name secure-app \
  --tmpfs /app/temp:rw,size=100m \
  my-app:v1.0

# Deklarasi volume di Dockerfile
FROM postgres:16
VOLUME /var/lib/postgresql/data

# Data di /var/lib/postgresql/data akan disimpan
# di volume anonymous secara otomatis

# Backup volume ke file tar
docker run --rm \
  -v my-data:/source:ro \
  -v $(pwd):/backup \
  alpine tar czf /backup/my-data-backup.tar.gz -C /source .

# Restore volume dari file tar
docker run --rm \
  -v my-data:/target \
  -v $(pwd):/backup \
  alpine tar xzf /backup/my-data-backup.tar.gz -C /target

# Hapus volume yang tidak digunakan
docker volume prune

# Lihat semua jaringan
docker network ls

# Buat jaringan custom (bridge)
docker network create my-network

# Jalankan container di jaringan tertentu
docker run -d --name app --network my-network my-app:v1.0
docker run -d --name db --network my-network postgres:16

# Container dalam jaringan yang sama bisa saling
# mengakses menggunakan nama container sebagai hostname
# Misal: app bisa akses db via "db:5432"

# Hubungkan container yang sudah berjalan ke jaringan
docker network connect my-network existing-container

# Putuskan container dari jaringan
docker network disconnect my-network existing-container

# Inspect jaringan
docker network inspect my-network

# Hapus jaringan
docker network rm my-network

# Mapping port host:container
docker run -d -p 8080:80 nginx
# Akses: http://localhost:8080 -> container port 80

# Mapping ke semua interface
docker run -d -p 0.0.0.0:3000:3000 my-app

# Mapping ke interface tertentu
docker run -d -p 127.0.0.1:5432:5432 postgres

# Docker pilih port random di host
docker run -d -P nginx
# Cek port: docker port 

# Mapping beberapa port sekaligus
docker run -d -p 80:80 -p 443:443 nginx

# docker-compose.yml
# Aplikasi Web + Database + Redis
version: "3.8"

services:
  # === Aplikasi Web (Node.js) ===
  web:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: web-app
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:password@db:5432/myapp
      - REDIS_URL=redis://cache:6379
    volumes:
      - ./uploads:/app/uploads
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    networks:
      - app-network
    restart: unless-stopped

  # === Database PostgreSQL ===
  db:
    image: postgres:16-alpine
    container_name: postgres-db
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: myapp
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d myapp"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network
    restart: unless-stopped

  # === Redis Cache ===
  cache:
    image: redis:7-alpine
    container_name: redis-cache
    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped

  # === Nginx Reverse Proxy ===
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - web
    networks:
      - app-network
    restart: unless-stopped

volumes:
  postgres-data:
  redis-data:

networks:
  app-network:
    driver: bridge

# Jalankan semua layanan (foreground)
docker compose up

# Jalankan di background (detached)
docker compose up -d

# Build ulang image sebelum start
docker compose up --build

# Hentikan semua layanan
docker compose down

# Hentikan dan hapus volumes (HATI-HATI: data hilang!)
docker compose down -v

# Lihat status layanan
docker compose ps

# Lihat log layanan tertentu
docker compose logs web
docker compose logs -f db   # -f = follow (live)

# Jalankan perintah di dalam container
docker compose exec web npm run migrate
docker compose exec db psql -U user -d myapp

# Scale layanan tertentu
docker compose up -d --scale web=3

# Restart satu layanan
docker compose restart web

# Login ke Docker Hub
docker login
# Masukkan username dan password

# Tarik image dari Docker Hub
docker pull nginx:latest
docker pull postgres:16-alpine
docker pull python:3.12-slim

# Cari image di Docker Hub
docker search mysql
docker search redis

# Push image ke Docker Hub
# 1. Tag image dengan format username/repo:tag
docker tag my-app:v1.0 username/my-app:v1.0
docker tag my-app:v1.0 username/my-app:latest

# 2. Push ke Docker Hub
docker push username/my-app:v1.0
docker push username/my-app:latest

# Logout dari Docker Hub
docker logout

# Jalankan registry lokal (untuk development)
docker run -d -p 5000:5000 --name registry registry:2

# Tag dan push ke registry lokal
docker tag my-app:v1.0 localhost:5000/my-app:v1.0
docker push localhost:5000/my-app:v1.0

# Tarik dari registry lokal
docker pull localhost:5000/my-app:v1.0

# Cloud registries:
# - AWS ECR:      aws ecr
# - Google GCR:   gcr.io
# - Azure ACR:    azurecr.io
# - GitHub GHCR:  ghcr.io
# - GitLab:       registry.gitlab.com

# ❌ JELEK — image besar dengan semua build tools
FROM node:20
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
CMD ["node", "dist/server.js"]

# ✅ BAIK — multi-stage, image kecil
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

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"]

node_modules
.git
.gitignore
.env
.env.local
*.md
docker-compose*.yml
Dockerfile
.dockerignore
coverage
.nyc_output
dist
build
*.log
.vscode
.idea

# Scan image untuk vulnerabilities
docker scout cves my-app:v1.0

# Batasi resource container
docker run -d \
  --name my-app \
  --memory="512m" \
  --cpus="1.5" \
  --restart=unless-stopped \
  my-app:v1.0

# Lihat resource usage container
docker stats

# Bersihkan semua resource tidak terpakai
docker system prune -a --volumes

# Lihat ukuran image
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"