Docker Compose for dev environment - Commands & Configuration

Introduction

When you develop software, you often need several services like a web server and a database to work together. Docker Compose helps you start and manage these services easily with one command, so you can focus on coding instead of setup.

When you want to run a web app and a database together on your computer without installing them separately.

When you need to share your development setup with teammates so everyone uses the same environment.

When you want to quickly start and stop multiple services with one command during development.

When you want to avoid conflicts between different projects by isolating their services.

When you want to test how your app works with other services like Redis or message queues locally.

Config File - docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  web:
    image: nginx:1.23
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: devuser
      POSTGRES_PASSWORD: devpass
      POSTGRES_DB: devdb
    ports:
      - "5432:5432"
    volumes:
      - db-data:/var/lib/postgresql/data
volumes:
  db-data: {}

This file defines two services: web and db.

The web service uses the nginx image and maps port 8080 on your computer to port 80 inside the container. It also mounts a local html folder as read-only to serve your web files.

The db service uses the postgres image with environment variables to set up the database user, password, and database name. It maps port 5432 and uses a volume to keep data persistent.

The volumes section creates a named volume db-data to store database files outside the container.

Commands

This command starts all services defined in the docker-compose.yml file in the background. It creates containers, networks, and volumes as needed.

Terminal

docker-compose up -d

Expected Output

Creating network "default" with the default driver

Creating volume "db-data" with default driver

Creating devenvironment_web_1 ... done

Creating devenvironment_db_1  ... done

→

-d - Run containers in detached mode (in the background)

This command lists all running containers started by Docker Compose, showing their status and ports.

Terminal

docker-compose ps

Expected Output

    Name                   Command               State           Ports         

--------------------------------------------------------------------------------

devenvironment_db_1   docker-entrypoint.sh postgres   Up      0.0.0.0:5432->5432/tcp

 devenvironment_web_1  nginx -g 'daemon off;'          Up      0.0.0.0:8080->80/tcp

This command shows the logs from the web service container, useful to check if the web server started correctly.

Terminal

docker-compose logs web

Expected Output

[devenvironment_web_1] 2024/06/01 12:00:00 [notice] 1#1: using the "epoll" event method

[devenvironment_web_1] 2024/06/01 12:00:00 [notice] 1#1: nginx/1.23.0 started

This command stops and removes all containers, networks, and default volumes created by Docker Compose, cleaning up your environment.

Terminal

docker-compose down

Expected Output

Stopping devenvironment_web_1 ... done

Stopping devenvironment_db_1  ... done

Removing devenvironment_web_1 ... done

Removing devenvironment_db_1  ... done

Removing network default

Key Concept

If you remember nothing else from this pattern, remember: Docker Compose lets you start and stop multiple related services with one simple file and commands.

Common Mistakes

Not mapping ports in the docker-compose.yml file

Without port mapping, you cannot access the services from your computer, so your app won't work as expected.

Always map container ports to your local machine ports using the ports section.

Running 'docker-compose up' without the -d flag and closing the terminal

The containers stop when the terminal closes because they run in the foreground.

Use 'docker-compose up -d' to run containers in the background.

Not using volumes for persistent data like databases

Data will be lost when containers are removed if volumes are not used.

Define volumes in docker-compose.yml to keep data safe across container restarts.

Summary

Use docker-compose.yml to define multiple services and how they connect.

Start all services together with 'docker-compose up -d' and check their status with 'docker-compose ps'.

Stop and clean up services with 'docker-compose down' to keep your environment tidy.

Practice

1. What is the main purpose of using docker-compose.yml in a development environment?

easy

A. To build Docker images only

B. To define and run multiple containers with one command

C. To replace Docker CLI commands completely

D. To monitor container resource usage

Solution

1. Step 1: Understand Docker Compose role

   Docker Compose uses a YAML file to define multiple containers and their settings.

2. Step 2: Identify main benefit in dev

   It allows running all containers together with a single command, simplifying setup.

3. Final Answer:

   To define and run multiple containers with one command -> Option B

4. Quick Check:

   Compose = multiple containers, one command [OK]

Hint: Compose runs many containers with one file and command [OK]

Common Mistakes:

• Thinking Compose only builds images
• Believing Compose replaces all Docker CLI commands
• Confusing Compose with monitoring tools

2. Which of the following is the correct syntax to expose port 8080 on the host mapped to port 80 in a docker-compose.yml service?

easy

A. ports:
- "80:8080"

B. expose:
- "80:8080"

C. expose:
- "8080:80"

D. ports:
- "8080:80"

Solution

1. Step 1: Understand ports syntax in Compose

   The format is "host_port:container_port" to map host port to container port.

2. Step 2: Match ports for host 8080 to container 80

   To expose container port 80 on host port 8080, use "8080:80" under ports.

3. Final Answer:

   ports: - "8080:80" -> Option D

4. Quick Check:

   HostPort:ContainerPort = 8080:80 [OK]

Hint: Ports use host:container format [OK]

Common Mistakes:

• Reversing host and container ports
• Using expose instead of ports for host mapping
• Incorrect YAML indentation

3. Given this docker-compose.yml snippet, what will be the effect of the volume configuration?

services:
  app:
    image: myapp
    volumes:
      - ./src:/app/src

medium

A. The host's ./src folder is shared with /app/src inside the container

B. The container's /app/src folder is copied to host's ./src folder once

C. The container will have an empty /app/src folder

D. The volume will cause a syntax error

Solution

1. Step 1: Understand volume syntax in Compose

   Format "host_path:container_path" mounts host folder inside container.

2. Step 2: Analyze given volume mapping

   Host folder ./src is mounted to container path /app/src, sharing files live.

3. Final Answer:

   The host's ./src folder is shared with /app/src inside the container -> Option A

4. Quick Check:

   Volume mount = host folder shared inside container [OK]

Hint: Volumes share host folder inside container path [OK]

Common Mistakes:

• Thinking volume copies files only once
• Confusing source and target paths
• Assuming volume creates empty folder

4. You wrote this docker-compose.yml but get an error when running docker-compose up. What is wrong?

services:
  web:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    environment:
      - DEBUG=true
    command: nginx -g 'daemon off;'
    restart: always
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

medium

A. The environment variable for db should use list syntax or key-value mapping consistently

B. The volume pgdata is not defined properly under volumes

C. The command for web service is invalid

D. The environment variable for db uses wrong syntax, should be a list

Solution

1. Step 1: Inspect YAML syntax in command field

   The command: nginx -g 'daemon off;' lacks quotes around the full string, causing YAML to parse it as separate unquoted scalars, leading to a syntax error.

2. Step 2: Confirm other sections are valid

   Environment uses valid list/map styles (mixed OK), volumes properly defined.

3. Final Answer:

   The command for web service is invalid -> Option C

4. Quick Check:

   Multi-word command needs full quotes or YAML list [OK]

Hint: YAML command with spaces: quote whole or use list [OK]

Common Mistakes:

• Blaming environment syntax mixing (both styles valid)
• Misreading pgdata volume definition
• Overlooking unquoted multi-word command

5. You want to set up a development environment with a web app and a database using Docker Compose. The web app needs live code updates from your host machine, and the database should persist data between restarts. Which docker-compose.yml configuration correctly achieves this?

hard

A. services:
web:
image: mywebapp
volumes:
- ./code:/app
ports:
- "3000:3000"
db:
image: mysql
environment:
MYSQL_ROOT_PASSWORD: rootpass
volumes:
- dbdata:/var/lib/mysql
volumes:
dbdata:

B. services:
web:
image: mywebapp
ports:
- "3000:3000"
db:
image: mysql
environment:
MYSQL_ROOT_PASSWORD: rootpass
volumes:
dbdata:
driver: local

C. services:
web:
image: mywebapp
volumes:
- /app:/code
ports:
- "3000:3000"
db:
image: mysql
environment:
MYSQL_ROOT_PASSWORD: rootpass
volumes:
- dbdata:/var/lib/mysql
volumes:
dbdata:

D. services:
web:
image: mywebapp
volumes:
- ./code:/app
ports:
- "3000:3000"
db:
image: mysql
environment:
MYSQL_ROOT_PASSWORD: rootpass

Solution

1. Step 1: Ensure live code updates for web app

   Mount host folder ./code to container /app using volumes for live updates.

2. Step 2: Ensure database data persistence

   Use a named volume (dbdata) mounted to /var/lib/mysql to keep data between restarts.

3. Step 3: Check ports and environment

   Expose port 3000 for web and set MYSQL_ROOT_PASSWORD for db environment.

4. Final Answer:

   Configuration with volumes for web and named volume for db -> Option A

5. Quick Check:

   Volumes for live code and persistent db = services: web: image: mywebapp volumes: - ./code:/app ports: - "3000:3000" db: image: mysql environment: MYSQL_ROOT_PASSWORD: rootpass volumes: - dbdata:/var/lib/mysql volumes: dbdata: [OK]

Hint: Use volumes for code and named volume for DB persistence [OK]

Common Mistakes:

• Not mounting host code folder for live updates
• Missing volume for database persistence
• Incorrect volume paths or missing volumes section