Docker para sa mga Baguhan: Mula sa Unang Image Hanggang sa Production Deploy

Binago ng Docker ang paraan ng pagbuo, pagpapadala, at pagpapatakbo natin ng software. Sa halip na "gumagana sa makina ko," ginagarantiya ng Docker na pareho ang takbo ng iyong application kahit saan - sa iyong laptop, sa makina ng katrabaho, sa CI/CD, at sa production. Sa gabay na ito, magsisimula tayo mula sa zero hanggang sa pag-deploy ng isang tunay na application.

Ano ang Docker?

Ang Docker ay isang platform na nagpa-package ng iyong application at lahat ng dependencies nito sa isang standardized unit na tinatawag na container. Ang container ay isang isolated, magaan na proseso na nagbabahagi ng host OS kernel ngunit may sariling filesystem, network, at process space.

Mga Container vs Virtual Machine

Aspeto	Mga Container	Virtual Machine
Startup	Segundo	Minuto
Laki	MB	GB
OS	Nagbabahagi ng host kernel	Buong guest OS
Isolation	Antas ng proseso	Antas ng hardware
Performance	Halos native	Overhead mula sa hypervisor
Density	Daan-daan bawat host	Sampu-sampu bawat host

Pag-install ng Docker

# macOS
brew install --cask docker

# Ubuntu/Debian
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Verify installation
docker --version
docker run hello-world

Mga Pangunahing Konsepto

Mga Image

Ang image ay isang read-only template na may mga tagubilin para sa paggawa ng container. Isipin ito bilang isang snapshot ng iyong application at ng kapaligiran nito.

# Pull an image from Docker Hub
docker pull node:20-alpine

# List local images
docker images

# Remove an image
docker rmi node:20-alpine

Mga Container

Ang container ay isang tumatakbo na instance ng isang image. Maaari kang gumawa, mag-start, mag-stop, at mag-delete ng mga container.

# Run a container
docker run -d --name my-app -p 3000:3000 node:20-alpine

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop a container
docker stop my-app

# Remove a container
docker rm my-app

# View logs
docker logs my-app

# Execute a command inside a running container
docker exec -it my-app sh

Pagsulat ng Dockerfile

Ang Dockerfile ay isang text file na may mga tagubilin para sa pagbuo ng image. Bawat tagubilin ay gumagawa ng isang layer.

Basic na Dockerfile para sa isang Node.js App

# Use an official Node.js runtime as base image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy package files first (better caching)
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "server.js"]

Pagbuo at Pagpapatakbo

# Build the image
docker build -t my-node-app .

# Run the container
docker run -d -p 3000:3000 my-node-app

# Visit http://localhost:3000

Multi-Stage Build

Ang mga multi-stage build ay nagpapanatiling maliit ng iyong production image sa pamamagitan ng paghihiwalay ng build environment mula sa runtime.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

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

Gumagawa ito ng image na naglalaman lamang ng compiled output at production dependencies - walang source code, walang dev dependencies, walang build tools.

Next.js Multi-Stage Halimbawa

FROM node:20-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci

FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
EXPOSE 3000
CMD ["node", "server.js"]

Mga Volume: Persistent na Data

Bilang default, nawawala ang data sa loob ng container kapag inalis ang container. Nilulutas ito ng mga volume.

# Create a named volume
docker volume create my-data

# Run with a volume
docker run -d -v my-data:/app/data my-app

# Bind mount (map host directory to container)
docker run -d -v $(pwd)/data:/app/data my-app

# List volumes
docker volume ls

Networking

Gumagawa ang Docker ng mga isolated network para makipag-usap ang mga container.

# Create a custom network
docker network create my-network

# Run containers on the same network
docker run -d --name api --network my-network my-api
docker run -d --name db --network my-network postgres:16

# Containers can reach each other by name
# From "api" container: postgres://db:5432

Docker Compose

Hinahayaan ka ng Docker Compose na i-define at patakbuhin ang mga multi-container application gamit ang isang YAML file.

docker-compose.yml

services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  pgdata:

Mga Command

# Start all services
docker compose up -d

# View logs
docker compose logs -f

# Stop all services
docker compose down

# Rebuild and restart
docker compose up -d --build

# Scale a service
docker compose up -d --scale api=3

.dockerignore

Tulad ng .gitignore, pinipigilan ng file na ito ang mga hindi kailangang file na makopya sa image.

node_modules
.git
.env
*.md
.next
dist
coverage

Mga Pinakamahuhusay na Kasanayan para sa Production

1. Gumamit ng Maliliit na Base Image

# Bad: 1GB+
FROM node:20

# Good: ~180MB
FROM node:20-alpine

2. Huwag Patakbuhin bilang Root

FROM node:20-alpine
RUN addgroup -S app && adduser -S app -G app
USER app
WORKDIR /home/app
COPY --chown=app:app . .

3. Gumamit ng Specific na Image Tag

# Bad: can change unexpectedly
FROM node:latest

# Good: pinned version
FROM node:20.11-alpine3.19

4. Samantalahin ang Build Cache

Ayusin ang mga tagubilin ng iyong Dockerfile mula sa pinakamadalang hanggang sa pinakamadalas na nagbabago:

FROM node:20-alpine
WORKDIR /app

# These change rarely - cached
COPY package.json package-lock.json ./
RUN npm ci --only=production

# This changes often - not cached
COPY . .

5. Health Check

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

6. Gumamit ng Environment Variable

ENV NODE_ENV=production
ENV PORT=3000

Cheat Sheet ng mga Karaniwang Docker Command

# Images
docker build -t name:tag .        # Build image
docker images                      # List images
docker rmi image_name              # Remove image
docker image prune                 # Remove unused images

# Containers
docker run -d -p 3000:3000 image   # Run detached
docker ps                          # List running
docker stop container_name         # Stop
docker rm container_name           # Remove
docker logs -f container_name      # Follow logs
docker exec -it container sh       # Shell into container

# Compose
docker compose up -d               # Start services
docker compose down                # Stop services
docker compose logs -f             # Follow all logs
docker compose ps                  # List services

# Cleanup
docker system prune -a             # Remove everything unused

Mula Docker Papuntang Kubernetes

Pinangangasiwaan ng Docker ang mga indibidwal na container. Kapag kailangan mong i-orchestrate ang daan-daang container sa maraming server, kailangan mo ng Kubernetes. Nagpupunan ang Docker at Kubernetes:

1. Docker: nagbubuo at nagpapatakbo ng mga container
2. Kubernetes: nag-o-orchestrate ng mga container sa malaking sukat (scheduling, scaling, healing)

Kung interesado ka sa susunod na hakbang, tingnan ang aking artikulo tungkol sa Introduction to Kubernetes.

Konklusyon

Ang Docker ay isang pundamental na kasanayan para sa mga modernong developer. Inaalis nito ang mga hindi pagkakatugma ng kapaligiran, pinapasimple ang deployment, at pundasyon ito ng container orchestration gamit ang Kubernetes. Magsimula sa isang simpleng Dockerfile, lumipat sa Docker Compose para sa mga multi-service app, at i-adopt ang multi-stage build at security best practice habang lumalaki ka.

Ang pinakamahusay na paraan para matuto ng Docker ay i-containerize ang isang proyekto na ginagawa mo na. Magsimula ngayon.