Docker Compose for local development in Microservices - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to specify the version of Docker Compose file format.

Microservices

version: '[1]'
services:
  web:
    image: myapp:latest

Drag options to blanks, or click blank then click option'

Alatest

B3.8

Cv2

D1.0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'latest' as version causes errors.

Using 'v2' is not a valid version string here.

The version field in Docker Compose specifies the file format version. '3.8' is a commonly used stable version for modern Docker Compose files.

2fill in blank

medium

Complete the code to define a service named 'db' using the official PostgreSQL image.

Microservices

services:
  db:
    image: [1]

Drag options to blanks, or click blank then click option'

Aredis:6

Bmysql:latest

Cpostgres:13

Dmongo:4.4

Attempts:

3 left

💡 Hint

Common Mistakes

Using MySQL or MongoDB images for a PostgreSQL service.

Omitting the version tag may cause unexpected updates.

The db service uses the official PostgreSQL image tagged 'postgres:13' for version 13.

3fill in blank

hard

Fix the error in the environment variable syntax for the 'web' service.

Microservices

services:
  web:
    image: myapp:latest
    environment:
      - DATABASE_URL=[1]

Drag options to blanks, or click blank then click option'

A"postgres://user:pass@db:5432/mydb"

Bpostgres://user:pass@db:5432/mydb

C'postgres://user:pass@db:5432/mydb'

DDATABASE_URL=postgres://user:pass@db:5432/mydb

Attempts:

3 left

💡 Hint

Common Mistakes

Not quoting the URL causes YAML parsing errors.

Using single quotes may work but double quotes are safer here.

Environment variable values with special characters should be quoted with double quotes in YAML to avoid parsing errors.

4fill in blank

hard

Fill both blanks to correctly map the local port 8080 to the container port 80 and mount the current directory to /app inside the container.

Microservices

services:
  web:
    ports:
      - '[1]:[2]'
    volumes:
      - './:[3]'

Drag options to blanks, or click blank then click option'

A8080

B80

C/app

D/var/www

Attempts:

3 left

💡 Hint

Common Mistakes

Reversing port mapping order.

Mounting to wrong container directory.

Port mapping uses 'host_port:container_port' format, so '8080:80' maps local 8080 to container 80. Volume mounts map local './' to container '/app' to share code.

5fill in blank

hard

Fill all three blanks to define a 'depends_on' relationship where 'web' depends on 'db', and set restart policy to always.

Microservices

services:
  web:
    depends_on:
      - [1]
    restart: [2]
  db:
    image: postgres:13
    restart: [3]

Drag options to blanks, or click blank then click option'

Adb

Balways

Cno

Dnever

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong service name in depends_on.

Setting restart policy to 'no' disables auto-restart.

The 'web' service depends on 'db' to start first. Setting 'restart: always' ensures services restart automatically on failure.

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