Zum Hauptinhalt springen
🔧 ProgrammierungWebKit Features for Safari 27.0(17.09.2026 um 13:30 Uhr)
🔧 ProgrammierungWebKit Features for Safari 27.0(17.09.2026 um 13:30 Uhr)
Intelligence View
⚡ tsecurity.de Intelligence

Docker for Developers: The Only Guide You Actually Need (2026)

Docker for Developers: The Only Guide You Actually Need (2026)

Stop memorizing Docker commands. Understand how it works once, and you'll never be confused again.

Why Docker Matters

"It works on my machine" → No longer a valid excuse.

Docker ensures your app runs the same way:
→ On your laptop
→ On your teammate's Mac
→ On the Linux server
→ In CI/CD pipeline

One command to rule them all: docker compose up

Docker vs VMs (The Key Insight)

Virtual Machine:
┌─────────────────────────────────┐
│         Host OS                 │
│  ┌─────────────────────────┐    │
│  │      Guest OS           │    │  ← Full OS (GBs of RAM)
│  │   ┌───────────────┐     │    │
│   │   │    Your App   │     │    │
│   │   └───────────────┘     │    │
│  └─────────────────────────┘    │
└─────────────────────────────────┘

Container:
┌─────────────────────────────────┐
│         Host OS (Linux)         │
│  ┌─────────────────────────┐    │
│  │    Docker Engine        │    │
│  │  ┌───────────────┐     │    │
│  │  │   Your App    │     │    │  ← Just your app + deps (MBs)
│  │  └───────────────┘     │    │
│  └─────────────────────────┘    │
└─────────────────────────────────┘

Containers share the host OS kernel. That's why they're lightweight.

Essential Concepts (5 Minutes)

Image vs Container

# Image = Blueprint (like a class)
# Container = Running instance (like an object)

docker run node:20-alpine          # Pull image + create container
docker images                       # List all images
docker ps                           # List running containers
docker ps -a                        # List ALL containers (including stopped)

Dockerfile = Your Build Recipe

# Every Dockerfile starts with a base image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy package files first (layer caching!)
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy source code
COPY . .

# Expose port
EXPOSE 3000

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

docker-compose.yml = Multi-Service Orchestration

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/myapp
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    restart: unless-stopped

volumes:
  pgdata:

The Commands I Use Every Day

# === Building & Running ===
docker compose up -d              # Start services in background
docker compose down               # Stop & remove containers
docker compose logs -f --tail 50  # Follow logs (last 50 lines)
docker compose restart app        # Restart one service

# === Debugging ===
docker exec -it app sh            # Shell into running container
docker exec -it app npm test      # Run command inside container
docker compose run --rm app npm run migrate  # Run one-off command

# === Cleanup ===
docker system df                   # See disk usage
docker system prune -a             # Remove unused images, containers, volumes
docker volume prune                # Remove unused volumes

# === Inspecting ===
docker inspect <container>         # Full JSON config of container
docker stats                       # Live resource usage (CPU, MEM, NET)
docker logs <container> -f         # Follow specific container logs

Real-World Examples

1. Node.js API with PostgreSQL

# Dockerfile
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .

FROM node:20-alpine AS runner
WORKDIR /app
RUN addgroup -g 1001 app && adduser -u 1001 -G app -s /bin/sh -D app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
USER app
EXPOSE 3000
CMD ["node", "dist/server.js"]
# docker-compose.yml
version: '3.8'
services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/appdb
      REDIS_URL: redis://redis:6379
    depends_on:
      - db
      - redis

  db:
    image: postgres:16-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"

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

volumes:
  postgres_data:

2. Static Site with Nginx

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./public:/usr/share/nginx/html:ro
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    restart: unless-stopped

3. Development Environment (Hot Reload)

version: '3.8'
services:
  dev:
    image: node:20-alpine
    working_dir: /app
    command: sh -c "npm install && npm run dev"
    ports:
      - "3000:3000"
      - "9229:9229"  # Node.js debugger
    volumes:
      - .:/app       # Live reload source changes!
      - node_modules:/app/node_modules  # Persist installed modules
    environment:
      - NODE_ENV=development

volumes:
  node_modules:

Performance Tips

1. Optimize Your Dockerfile

# ❌ BAD — Rebuilds everything on any code change
FROM node:20-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "server.js"]

# ✅ GOOD — Leverages layer caching
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci                    # Only re-runs if package.json changes
COPY . .
CMD ["node", "server.js"]

# ✅ BETTER — Multi-stage build (smaller final image)
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
CMD ["node", "server.js"]

2. Use .dockerignore

# .dockerignore — like .gitignore for Docker
node_modules
npm-debug.log
.git
.env
coverage
.next
build
.DS_Store
*.md
!README.md

This can cut build time from minutes to seconds.

3. Smaller Base Images

Image Size When to use
node:20 ~1 GB Development
node:20-alpine ~180 MB Production (most cases)
node:20-slim ~200 MB Need glibc compatibility

Common Problems & Solutions

"Permission denied" in mounted volumes

# Add this to your service
user: "${UID:-1000}:${GID:-1000}"

Then run: UID=$(id -u) GID=$(id -g) docker compose up -d

Container eats all memory

# Add memory limits
services:
  app:
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

Port already in use

# Find what's using the port
lsof -i :3000

# Kill it or change your mapping
ports:
  - "3001:3000"  # Map host 3001 → container 3000

Images getting too large

# Check what's taking space
docker history your-image:latest

# Clean up in Dockerfile
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

Docker for Side Projects (My Setup)

I run 4 projects on one VPS using Docker Compose:

# docker-compose.yml (production)
version: '3.8'

services:
  agentvote:
    build: ./agentvote
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production

  signal:
    build: ./crypto-signal
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - signal_data:/app/data

  blog:
    image: nginx:alpine
    restart: unless-stopped
    volumes:
      - ./blog/public:/usr/share/nginx/html:ro
    ports:
      - "8080:80"

  formatter:
    build: ./text-formatter
    restart: unless-stopped
    ports:
      - "3099:3099"

volumes:
  signal_data:
# Deploy everything
docker compose up -d --build

# Update one service
docker compose up -d --build agentvote

# Check everything's running
docker compose ps

Quick Reference Card

# Lifecycle
docker compose up -d        # Start
docker compose down         # Stop
docker compose restart      # Restart

# Debugging
docker exec -it <svc> sh    # Shell in
docker compose logs -f      # Logs
docker compose ps           # Status

# Maintenance
docker system prune -a      # Cleanup
docker compose pull         # Update images
docker compose up -d --build # Rebuild & restart

What's your Docker setup look like? Still avoiding it?

Follow @armorbreak for more practical DevOps guides.

Ähnliche Beiträge
🔍 Verwandte News

Auch interessante Nachrichten Docker for Developers: The Only Guide You Actually Need (2026)

Thematisch verwandte Begriffe: Docker, Developers, Only, Guide · 6 Treffer

Laden...

Videos werden geladen ...

Laden...

Beiträge werden geladen ...

Laden...

Videos werden geladen ...

Laden...

Beiträge werden geladen ...

Laden...

Videos werden geladen ...

Laden...

Beiträge werden geladen ...

Laden...

Videos werden geladen ...

Laden...

Beiträge werden geladen ...

Laden...

Videos werden geladen ...

Zum Aktualisieren ziehen
ZERO-DAY CVE-2026-61591 | djust provides Phoenix LiveView-style reactive server-side rendering for…
Advisory →
TTS Reader • tsecurity.de Voice
tsecurity.de Icon
tsecurity.de App
Offline-Lesen, Eilmeldungen & 0ms Ladezeit

Installiere tsecurity.de direkt auf deinen Home-Bildschirm für das ultimative Vollbild-Magazinerlebnis ohne Browser-Leisten.

Nächster Beitrag
Themen-Radar & Intelligence Matrix
Echtzeit-Taxonomie nach Angriffsvektoren & Plattformen
Community Radar & Live Chat
Sentinel Bot online • Live-Stream
Dein Cluster: Security Explorer
Match:
lädt…
Verbindung zum Community-Stream wird aufgebaut...
Aktivitäten deiner Analysten
lädt…
Neues Thema oder Eilmeldung einreichen

Reiche interessante Links, Zero-Days oder Debatten ein. Die Community entscheidet per Upvote über die Veröffentlichung.

Heiß diskutierte Einreichungen
🔖 Gespeicherte Artikel
📂 Keine gespeicherten Artikel vorhanden.
News ⏱️ 3 Min vor 10 Min
Artikeldaten werden geladen...

↗ Original-Quelle