Docker Compose for local development in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

Designing a Docker Compose setup for a multi-service app

You have three microservices: a frontend, a backend API, and a database. You want to run them locally using Docker Compose. Which of the following docker-compose.yml snippets correctly defines the services with proper network and volume setup for local development?

A

version: '3'
services:
  frontend:
    build: ./frontend
    ports:
      - '3000:3000'
    depends_on:
      - backend
  backend:
    build: ./backend
    ports:
      - '8000:8000'
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/app
    depends_on:
      - db
  db:
    image: postgres:15
    volumes:
      - db-data:/var/lib/postgresql/data
volumes:
  db-data: {}

B

version: '2'
services:
  frontend:
    image: node:latest
    ports:
      - '3000:3000'
  backend:
    image: python:3.9
    ports:
      - '8000:8000'
  db:
    image: postgres:latest
    volumes:
      - ./data:/var/lib/postgresql/data

C

version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - '3000:3000'
  backend:
    build: ./backend
    ports:
      - '8000:8000'
    environment:
      DATABASE_URL: postgres://user:pass@localhost:5432/app
  db:
    image: postgres:15
    volumes:
      - db-data:/var/lib/postgresql/data
volumes:
  db-data: {}

D

version: '3'
services:
  frontend:
    build: ./frontend
    ports:
      - '3000:3000'
    depends_on:
      - backend
  backend:
    build: ./backend
    ports:
      - '8000:8000'
    environment:
      - DATABASE_URL=postgres://user:pass@localhost:5432/app
    depends_on:
      - db
  db:
    image: postgres:15
    volumes:
      - db-data:/var/lib/postgresql/data
volumes:
  db-data: {}

💡 Hint

Check how services communicate using service names and how volumes are defined for persistent data.

Option A correctly uses service names for database connection (db), defines volumes for data persistence, and sets dependencies so services start in order. Options C and D incorrectly use localhost in the backend environment, which won't resolve inside Docker network. Option A uses version 2 and lacks proper build context and network setup.

❓ scaling

intermediate

Scaling services with Docker Compose

You want to test how your backend service handles multiple instances locally using Docker Compose. Which command correctly scales the backend service to 3 instances?

A docker-compose up --scale backend=3

B docker-compose scale backend=3

C docker-compose run --scale backend=3

D docker-compose up -d backend=3

💡 Hint

Remember the modern syntax for scaling services with docker-compose up.

The correct command is docker-compose up --scale backend=3. The scale command is deprecated. The run command does not support scaling.

❓ tradeoff

advanced

Tradeoffs of using Docker Compose for local development

Which of the following is a common tradeoff when using Docker Compose for local development of microservices?

A It guarantees identical performance and behavior as production environments.

B It simplifies environment setup but may not perfectly mimic production networking and scaling.

C It eliminates the need for any configuration files or environment variables.

D It automatically scales services to production-level traffic without manual setup.

💡 Hint

Think about differences between local and production environments.

Docker Compose is great for local setups but does not fully replicate production environments, especially in networking and scaling. It requires configuration files and environment variables. Scaling is manual and limited.

🧠 Conceptual

advanced

Understanding service dependencies in Docker Compose

In Docker Compose, what does the depends_on key do when defined between services?

A It guarantees the dependent service is fully ready and healthy before starting the current service.

B It automatically restarts the dependent service if the current service fails.

C It ensures the dependent service starts before the current service but does not wait for it to be ready.

D It links the dependent service's ports to the current service.

💡 Hint

Consider what depends_on controls in startup order versus readiness.

The depends_on key controls startup order but does not wait for the dependent service to be fully ready or healthy. Health checks require additional configuration.

❓ estimation

expert

Estimating resource usage for Docker Compose local setup

You plan to run 5 microservices locally with Docker Compose. Each service requires approximately 500MB RAM and 0.5 CPU cores. Your laptop has 8 CPU cores and 16GB RAM. Considering Docker and OS overhead, what is the maximum number of service instances you can run simultaneously without swapping or CPU throttling?

A 24 instances (limited by RAM: 16GB / 0.5GB = 32, CPU limits to 8 cores * 3 instances)

B 10 instances (limited by RAM: 16GB / 0.5GB = 32 but CPU limits to 8 cores * 1 instance each)

C 28 instances (16GB / 0.5GB = 32 RAM, 8 cores * 3.5 instances per core CPU)

D 16 instances (8 cores * 2 per core, RAM is sufficient)

💡 Hint

Calculate max instances by RAM and CPU separately, then take the smaller number.

RAM allows 32 instances (16GB / 0.5GB). CPU allows 16 instances (8 cores * 2 instances per core). Considering overhead, the limiting factor is CPU, so max is 16 instances.

Practice

1. What is the main purpose of using Docker Compose in local development for microservices?

easy

A. To replace the need for writing application code

B. To run multiple microservices together easily on a single machine

C. To deploy microservices directly to production servers

D. To monitor live traffic of microservices in production

Solution

1. Step 1: Understand Docker Compose's role

   Docker Compose is designed to help developers run multiple services together locally using a simple configuration file.

2. Step 2: Differentiate local development from production

   It is not meant for production deployment or monitoring but for easy local setup and testing.

3. Final Answer:

   To run multiple microservices together easily on a single machine -> Option B

4. Quick Check:

   Docker Compose = local multi-service setup [OK]

Hint: Docker Compose is for local multi-service running [OK]

Common Mistakes:

• Confusing Docker Compose with production deployment tools
• Thinking it replaces writing application code
• Assuming it monitors live production traffic

2. Which of the following is the correct syntax to define a service named web in a docker-compose.yml file?

easy

A. service:
web:
image: nginx

B. containers:
web:
image: nginx

C. services:
- web:
image: nginx

D. services:
web:
image: nginx

Solution

1. Step 1: Identify the correct top-level key

   The correct key to define multiple services is services, not service or containers.

2. Step 2: Check service definition syntax

   Services are defined as keys under services, not as list items with dashes.

3. Final Answer:

   services: web: image: nginx -> Option D

4. Quick Check:

   Correct YAML key for services = services [OK]

Hint: Services go under 'services:' key without dashes [OK]

Common Mistakes:

• Using 'service' instead of 'services'
• Defining services as list items with dashes
• Using 'containers' instead of 'services'

3. Given this docker-compose.yml snippet:

services:
  db:
    image: postgres
    ports:
      - "5432:5432"
  api:
    build: ./api
    depends_on:
      - db
    ports:
      - "8000:8000"

What happens when you run docker-compose up?

medium

A. Both db and api services start, with api waiting for db to be ready

B. api starts first, then db starts after

C. Only db service starts, api is ignored

D. Both services start but ports are not exposed

Solution

1. Step 1: Understand depends_on behavior

   The api service depends on db, so Docker Compose starts db first.

2. Step 2: Check port mappings

   Ports are correctly mapped for both services, so they are exposed on the host machine.

3. Final Answer:

   Both db and api services start, with api waiting for db to be ready -> Option A

4. Quick Check:

   depends_on controls start order [OK]

Hint: depends_on means start order matters [OK]

Common Mistakes:

• Assuming api starts before db
• Thinking ports are not exposed without extra config
• Believing depends_on waits for full readiness (it waits only for start)

4. You wrote this docker-compose.yml but docker-compose up fails:

services:
  app:
    image: myapp
    ports:
      - "8080:80"
    volumes:
      - ./app:/app
    environment:
      - DEBUG=true
  db:
    image: postgres
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: example

What is the error causing the failure?

medium

A. Port mapping for app is reversed; host port must be higher

B. Volume mapping for app is invalid; local path must be absolute

C. The environment variable for db uses wrong syntax; should be a list or key-value pairs

D. Missing depends_on between app and db

Solution

1. Step 1: Check environment variable syntax

   For db, environment variables must be either a list of strings or a map with key-value pairs. Mixing styles causes errors.

2. Step 2: Validate other configurations

   Volume and port mappings are valid; depends_on is optional and won't cause startup failure.

3. Final Answer:

   The environment variable for db uses wrong syntax; should be a list or key-value pairs -> Option C

4. Quick Check:

   Environment vars syntax must be consistent [OK]

Hint: Use consistent environment variable syntax [OK]

Common Mistakes:

• Mixing list and map styles for environment variables
• Assuming volume paths must be absolute
• Thinking depends_on is mandatory

5. You want to develop three microservices locally: frontend, backend, and database. The backend depends on database, and frontend depends on backend. You also want to share code changes live between your host and containers. Which docker-compose.yml setup best fits these requirements?

hard

A. Define all three services with depends_on chaining, map ports, and use volumes to mount source code directories

B. Define only frontend and backend services, omit database, and build images without volumes

C. Run each service in separate Docker Compose files without depends_on, and no volume mounts

D. Use a single service combining all three microservices in one container with no volumes

Solution

1. Step 1: Setup service dependencies

   Use depends_on to ensure backend starts after database, and frontend after backend.

2. Step 2: Enable live code sharing

   Use volumes to mount local source code directories into containers for live updates during development.

3. Step 3: Expose necessary ports

   Map ports for each service to access them from the host machine.

4. Final Answer:

   Define all three services with depends_on chaining, map ports, and use volumes to mount source code directories -> Option A

5. Quick Check:

   Dependencies + volumes + ports = correct setup [OK]

Hint: Use depends_on and volumes for live dev setup [OK]

Common Mistakes:

• Omitting the database service
• Not using volumes for live code updates
• Combining all services into one container