Docker Deployment

Why Docker for Microservices?

In a microservices architecture, you might have 10, 20, or even 50 independent services, each with its own dependencies, runtime versions, and configuration. Without containerization, deploying and managing these services becomes a nightmare of conflicting library versions, port conflicts, and environment inconsistencies. A developer's machine might have Java 17, the test server has Java 11, and production has Java 21 — and suddenly your service behaves differently everywhere.

Docker solves this by packaging each microservice along with its exact runtime environment into a self-contained unit called a container. The container includes the JRE, application JAR, configuration, and all dependencies. It runs identically on a developer's laptop, a CI/CD server, and a production cluster.

Docker Compose for Multi-Service Orchestration

Real microservices projects need multiple services running together. Docker Compose defines and manages all of them in a single YAML file:

Key design decisions explained:

• depends_on with condition: service_healthy ensures startup ordering — Eureka must be healthy before other services register
• Environment variables override Spring Boot's application.properties for container-specific configuration
• Named volumes (pgdata) persist database data across container restarts and recreations
• Service names act as DNS hostnames — user-service can connect to postgres-db:5432 by name
• deploy.replicas: 2 runs two instances of user-service for load testing

Docker Networking

Docker Compose automatically creates a bridge network for all services in the file. Services communicate using their service names as DNS hostnames:

For production, you might create separate networks for frontend/backend isolation:

Essential Docker Commands

Production Best Practices

From Docker Compose to Kubernetes

Docker Compose is excellent for development and small deployments. For production at enterprise scale, Kubernetes adds:

• Auto-scaling: HPA (Horizontal Pod Autoscaler) adds/removes instances based on CPU, memory, or custom metrics
• Self-healing: Automatically restarts crashed containers and reschedules them on healthy nodes
• Rolling updates: Zero-downtime deployments with configurable rollout strategies
• Service mesh (Istio/Linkerd): Advanced traffic management, mTLS, observability between services
• Secret management: Encrypted storage for database passwords, API keys, TLS certificates

The same Docker images work in both Docker Compose and Kubernetes — only the orchestration layer changes.

Summary

Docker containerization is the foundation of modern microservices deployment. Multi-stage Dockerfiles create optimized, secure images. Docker Compose orchestrates multi-service environments for development and testing. Proper networking, health checks, and volume management ensure reliable operation. Following production best practices — non-root execution, resource limits, vulnerability scanning, and centralized logging — prepares your containerized Spring Boot microservices for enterprise-grade deployment, whether on Docker Compose for smaller systems or Kubernetes for large-scale production.