Docker Compose for local development in Microservices - System Design Exercise

Design: Local Development Environment with Docker Compose

Includes designing the Docker Compose setup for local microservices development. Excludes production deployment, CI/CD pipelines, and cloud infrastructure.

Functional Requirements

FR1: Run multiple microservices locally with a single command

FR2: Services should communicate with each other over a private network

FR3: Support environment variable configuration for each service

FR4: Allow easy rebuilding and restarting of services

FR5: Persist data for stateful services like databases

FR6: Expose necessary ports to host machine for testing

FR7: Enable logs viewing for all services in one place

Non-Functional Requirements

NFR1: Should work on developer machines with Docker installed

NFR2: Startup time for all services should be under 1 minute

NFR3: Services must be isolated but able to communicate internally

NFR4: Configuration should be simple and maintainable

NFR5: Support scaling of services locally (e.g., multiple instances)

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

❓ Question 7

Key Components

Docker Compose YAML file

Individual Dockerfiles for each microservice

Docker networks for service communication

Volumes for data persistence

Environment variable files (.env)

Service scaling configuration

Logging configuration

Design Patterns

Service discovery via Docker Compose network

Volume mounting for code hot-reloading

Multi-stage Docker builds for efficient images

Dependency ordering with depends_on

Using environment files for configuration management

Reference Architecture

Host Machine
   |
Docker Engine
   |
+-----------------------------+
|        Docker Compose        |
| +-----------+  +-----------+ |
| | Service A |  | Service B | |
| +-----------+  +-----------+ |
|       |            |         |
|    Network: dev-net          |
|       |            |         |
| +-----------+  +-----------+ |
| |  Database |  |  Cache    | |
| +-----------+  +-----------+ |
+-----------------------------+

Components

Docker Compose

Docker Compose YAML

Defines and manages multi-container application for local development

Microservices

Docker containers built from Dockerfiles

Individual services running isolated but networked together

Docker Network

User-defined bridge network

Allows services to discover and communicate with each other internally

Volumes

Docker volumes or bind mounts

Persist data and optionally mount source code for live reload

Environment Variables

.env files and environment section in Compose

Configure services dynamically without changing images

Ports

Port mapping in Compose

Expose service ports to host machine for testing and debugging

Logging

Docker logs and Compose logging options

Aggregate and view logs from all services easily

Request Flow

1. Developer runs 'docker compose up' command on host machine.

2. Docker Compose reads the YAML file and builds or pulls images for each service.

3. Docker Compose creates a private network 'dev-net' for services.

4. Each service container starts and connects to 'dev-net'.

5. Services communicate internally using service names as hostnames.

6. Persistent volumes are mounted for databases or stateful services.

7. Ports are mapped from containers to host for external access.

8. Logs from all containers are streamed to the terminal or log files.

9. Developer can stop or restart services with Docker Compose commands.

Database Schema

Not applicable as this design focuses on local environment orchestration rather than data schema.

Scaling Discussion

Bottlenecks

Limited CPU and memory resources on developer machines restrict number of running containers.

Network latency and port conflicts when scaling many services locally.

Long startup times if images are large or services have heavy dependencies.

Complexity in managing environment variables and configuration for many services.

Difficulty in replicating production environment exactly.

Solutions

Use lightweight base images and multi-stage builds to reduce image size.

Limit number of service instances locally; use mocks or stubs for some dependencies.

Use Docker Compose profiles to start only needed services.

Leverage bind mounts for faster code iteration without rebuilding images.

Use environment variable files and templates to manage configurations cleanly.

Consider container resource limits to avoid overloading host machine.

Interview Tips

Time: Spend 10 minutes understanding requirements and constraints, 20 minutes designing the Docker Compose setup and explaining components, 10 minutes discussing scaling and trade-offs, and 5 minutes for questions.

Explain how Docker Compose simplifies running multiple microservices locally.

Discuss service isolation and internal networking via Docker networks.

Highlight use of volumes for persistence and bind mounts for code changes.

Mention environment variable management for flexible configuration.

Address how to handle scaling and resource constraints on developer machines.

Show awareness of differences between local development and production environments.