Docker Deployment

Run Data Stream with Docker and Docker Compose.

Quick Start

# Start everything
docker compose up -d

# Check status
docker compose ps

# View logs
docker compose logs -f

Architecture

docker-compose.yml

version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    container_name: ds-postgres
    environment:
      POSTGRES_DB: datastream
      POSTGRES_USER: datastream
      POSTGRES_PASSWORD: datastream
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./postgres/init:/docker-entrypoint-initdb.d
    command:
      - postgres
      - -c
      - wal_level=logical
      - -c
      - max_replication_slots=4
      - -c
      - max_wal_senders=4
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U datastream"]
      interval: 5s
      timeout: 5s
      retries: 5

  nats:
    image: nats:2.10-alpine
    container_name: ds-nats
    ports:
      - "4222:4222"
      - "8222:8222"
    command: ["--jetstream", "--http_port", "8222"]
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:8222/healthz"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: ds-redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 5s
      retries: 5

  debezium:
    image: debezium/server:2.5
    container_name: ds-debezium
    ports:
      - "8080:8080"
    volumes:
      - ./debezium/application.properties:/debezium/conf/application.properties
    depends_on:
      postgres:
        condition: service_healthy
      nats:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/q/health"]
      interval: 10s
      timeout: 5s
      retries: 10

  consumer:
    build:
      context: ./consumer
      dockerfile: Dockerfile
    container_name: ds-consumer
    environment:
      NATS_URL: nats://nats:4222
      REDIS_URL: redis://redis:6379
      POSTGRES_URL: postgres://datastream:datastream@postgres:5432/datastream?sslmode=disable
    depends_on:
      postgres:
        condition: service_healthy
      nats:
        condition: service_healthy
      redis:
        condition: service_healthy
      debezium:
        condition: service_healthy

  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: ds-backend
    ports:
      - "3000:3000"
    environment:
      PORT: "3000"
      REDIS_URL: redis://redis:6379
    depends_on:
      redis:
        condition: service_healthy

volumes:
  postgres_data:
  redis_data:

Building Images

Backend

# backend/Dockerfile
FROM golang:1.22-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 go build -o backend ./cmd/main.go

FROM alpine:3.19
RUN apk --no-cache add ca-certificates
WORKDIR /app
COPY --from=builder /app/backend .
COPY --from=builder /app/public ./public

EXPOSE 3000
CMD ["./backend"]

Consumer

# consumer/Dockerfile
FROM golang:1.22-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 go build -o consumer ./cmd/main.go

FROM alpine:3.19
RUN apk --no-cache add ca-certificates
WORKDIR /app
COPY --from=builder /app/consumer .

CMD ["./consumer"]

Commands

Start Services

# Start all
docker compose up -d

# Start specific service
docker compose up -d backend

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

View Logs

# All logs
docker compose logs -f

# Specific service
docker compose logs -f backend

# Last 100 lines
docker compose logs --tail 100 backend

Stop Services

# Stop all
docker compose down

# Stop and remove volumes
docker compose down -v

Scale

# Scale backend to 3 instances
docker compose up -d --scale backend=3

Health Checks

# Check all services
docker compose ps

# Individual health
docker inspect --format='{{.State.Health.Status}}' ds-postgres
docker inspect --format='{{.State.Health.Status}}' ds-redis

Networking

Services communicate via Docker network:

Service	Internal Host	Port
PostgreSQL	postgres	5432
NATS	nats	4222
Redis	redis	6379
Debezium	debezium	8080
Backend	backend	3000

Volumes

Volume	Purpose
postgres_data	PostgreSQL data
redis_data	Redis persistence

Environment Variables

Backend

Variable	Default	Description
PORT	3000	HTTP port
REDIS_URL	redis://redis:6379	Redis connection

Consumer

Variable	Default	Description
NATS_URL	nats://nats:4222	NATS connection
REDIS_URL	redis://redis:6379	Redis connection
POSTGRES_URL	-	PostgreSQL connection

Troubleshooting

Service Won't Start

# Check logs
docker compose logs service_name

# Check health
docker compose ps

# Restart service
docker compose restart service_name

Database Connection Failed

# Check PostgreSQL is healthy
docker compose exec postgres pg_isready

# Check replication
docker compose exec postgres psql -U datastream -c "SELECT * FROM pg_replication_slots;"

CDC Not Working

# Check Debezium health
curl http://localhost:8080/q/health

# Check NATS streams
curl http://localhost:8222/jsz | jq