Docker Compose for dev environment - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of docker-compose up with multiple services

You run docker-compose up with this docker-compose.yml file:

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
  db:
    image: postgres:13
    environment:
      POSTGRES_PASSWORD: example

What will you see in the terminal output immediately after running the command?

Docker

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
  db:
    image: postgres:13
    environment:
      POSTGRES_PASSWORD: example

A Both nginx and postgres containers start, logs from both services stream in the terminal.

B Only nginx container starts; postgres container is created but not started.

C Error: missing build context for nginx service.

D Only postgres container starts; nginx container fails due to missing ports.

💡 Hint

Think about what docker-compose up does by default with multiple services.

The docker-compose up command starts all services defined in the file. Both nginx and postgres containers will start, and their logs will stream together in the terminal.

❓ Configuration

intermediate

Correct volume syntax for live code reload

You want to mount your local ./app folder into the container at /usr/src/app to enable live code reload during development. Which volume syntax in docker-compose.yml is correct?

A

volumes:
  - ./app\:/usr/src/app

B

volumes:
  - /usr/src/app:./app

C

volumes:
  - /app:usr/src/app

D

volumes:
  - ./app:/usr/src/app

💡 Hint

Local path comes first, then container path separated by a colon.

The correct syntax for mounting a local folder is local_path:container_path. Option D correctly mounts ./app to /usr/src/app.

❓ Troubleshoot

advanced

Why does docker-compose fail with 'port is already allocated' error?

You have this docker-compose.yml snippet:

services:
  web:
    image: nginx
    ports:
      - "8080:80"
  api:
    image: node
    ports:
      - "8080:3000"

You run docker-compose up and get an error: Bind for 0.0.0.0:8080 failed: port is already allocated. What is the cause?

Docker

services:
  web:
    image: nginx
    ports:
      - "8080:80"
  api:
    image: node
    ports:
      - "8080:3000"

A The container port 80 is already used by another container.

B Both services try to bind host port 8080, causing a conflict.

C Docker daemon is not running, so ports cannot be allocated.

D The node image does not expose port 3000 by default.

💡 Hint

Host ports must be unique across all services.

Both services map host port 8080 to different container ports. Host port 8080 cannot be used twice, causing the error.

🔀 Workflow

advanced

Order of commands to update code in a running dev environment

You have a running dev environment with docker-compose up. You updated your local source code and want the container to use the new code without restarting the whole environment. What is the correct order of commands?

A 1,3

B 4,1,2

C 3,1,2

D 2,1,3

💡 Hint

You only need to rebuild and restart the containers to apply code changes.

First rebuild images with docker-compose build, then restart containers with docker-compose restart to apply changes without stopping the whole environment.

✅ Best Practice

expert

Choosing the best way to share environment variables securely

You want to share sensitive environment variables like database passwords with your dev containers using Docker Compose. Which approach is best practice?

A Hardcode passwords directly in the <code>docker-compose.yml</code> file under <code>environment</code>.

B Pass environment variables at runtime using <code>docker-compose run -e</code>.

C Store secrets in a Docker Swarm secret and use <code>secrets</code> in Compose.

D Use a separate <code>.env</code> file and reference variables in <code>docker-compose.yml</code>.

💡 Hint

Think about secure storage and avoiding exposing secrets in files.

Using Docker Swarm secrets with secrets in Compose is the most secure way to handle sensitive data, avoiding exposure in files or command history.