Why advanced Compose features matter in Docker - Why It Works

Introduction

Docker Compose helps run multiple containers together easily. Advanced features let you handle complex setups like linking services, managing networks, and sharing data smoothly.

When you want to run a web app with a database and cache together without conflicts

When you need to share files between containers for data processing

When you want to control how containers restart automatically after failure

When you want to isolate containers using custom networks for security

When you want to scale services up or down easily with one command

Config File - docker-compose.yml

docker-compose.yml

version: '3.9'
services:
  web:
    image: nginx:1.23
    ports:
      - "8080:80"
    volumes:
      - web-data:/usr/share/nginx/html
    networks:
      - front-net
    restart: always
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: exampledb
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - back-net
    restart: on-failure
volumes:
  web-data:
  db-data:
networks:
  front-net:
  back-net:

This file defines two services: web and db. The web service uses the nginx image and shares a volume for website files. It connects to a network called front-net and restarts always if it stops. The db service uses the postgres image with environment variables for setup, stores data in a volume, connects to back-net, and restarts only on failure. Volumes keep data safe outside containers. Networks separate traffic between web and database for security.

Commands

Starts all services defined in the docker-compose.yml file in detached mode so they run in the background.

Terminal

docker-compose up -d

Expected Output

Creating network "example_front-net" with driver "bridge"

Creating network "example_back-net" with driver "bridge"

Creating volume "example_web-data" with default driver

Creating volume "example_db-data" with default driver

Creating example_db_1 ... done

Creating example_web_1 ... done

→

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

Shows the status of all running services to verify they started correctly.

Terminal

docker-compose ps

Expected Output

    Name                  Command               State           Ports         

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

example_db_1    docker-entrypoint.sh postgres    Up      

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

Displays the logs of the web service to check for errors or confirm it is running well.

Terminal

docker-compose logs web

Expected Output

example_web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration

example_web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/

example_web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh

example_web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf

example_web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf

example_web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up

Stops and removes all containers, networks, and volumes created by docker-compose up to clean up the environment.

Terminal

docker-compose down

Expected Output

Stopping example_web_1 ... done

Stopping example_db_1  ... done

Removing example_web_1 ... done

Removing example_db_1  ... done

Removing network example_front-net

Removing network example_back-net

Key Concept

If you remember nothing else from this pattern, remember: advanced Compose features let you organize, connect, and keep your containers running smoothly together.

Common Mistakes

Not defining volumes for databases or data storage

Data will be lost when containers stop or are removed

Always use volumes to persist important data outside containers

Using the default network for all services without separation

Services can access each other freely, which can cause security risks

Create separate networks to isolate services that should not communicate

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

Containers stop when the terminal session ends

Use -d flag to run containers in the background

Summary

Use docker-compose.yml to define multiple services, volumes, and networks for your app.

Run 'docker-compose up -d' to start all services in the background.

Check running services with 'docker-compose ps' and logs with 'docker-compose logs'.

Clean up with 'docker-compose down' to stop and remove all resources.

Practice

1. What is the main benefit of using advanced features in Docker Compose for multi-container applications?

easy

A. They reduce the size of container images.

B. They make containers run faster individually.

C. They simplify managing multiple containers together.

D. They automatically update Docker itself.

Solution

1. Step 1: Understand Docker Compose purpose

   Docker Compose is designed to manage multiple containers as one app.

2. Step 2: Identify advanced features role

   Advanced features help organize, scale, and control these containers easily.

3. Final Answer:

   They simplify managing multiple containers together. -> Option C

4. Quick Check:

   Advanced Compose features = Simplify multi-container management [OK]

Hint: Think: Compose = managing many containers easily [OK]

Common Mistakes:

• Confusing image size with Compose features
• Thinking Compose speeds up single containers
• Assuming Compose updates Docker engine

2. Which of the following is the correct syntax to scale a service named web to 3 instances using Docker Compose CLI?

easy

A. docker-compose scale web 3

B. docker-compose start web -n 3

C. docker-compose run --scale web 3

D. docker-compose up --scale web=3

Solution

1. Step 1: Recall Docker Compose scale syntax

   The correct command to scale is: docker-compose up --scale servicename=number

2. Step 2: Match options with correct syntax

   docker-compose up --scale web=3 matches this syntax exactly.

3. Final Answer:

   docker-compose up --scale web=3 -> Option D

4. Quick Check:

   Scaling uses 'up --scale' syntax [OK]

Hint: Use 'docker-compose up --scale service=num' to scale [OK]

Common Mistakes:

• Using 'scale' as a separate command
• Confusing 'run' with 'up' for scaling
• Using 'start' which doesn't support scaling

3. Given this snippet in a docker-compose.yml file:

services:
  app:
    image: myapp
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: '0.5'
          memory: 512M

What will happen when you run docker stack deploy -c docker-compose.yml mystack?

medium

A. The command fails because deploy is not supported in Compose.

B. Two app containers start with CPU limited to 0.5 and 512MB memory each.

C. Only one app container starts ignoring resource limits.

D. Two app containers start but without any resource limits.

Solution

1. Step 1: Understand 'deploy' in Compose for Swarm

   The 'deploy' section is used by Docker Swarm to set replicas and resource limits.

2. Step 2: Analyze command effect

   Running 'docker stack deploy' uses Swarm mode, so it respects 'replicas' and 'resources' limits.

3. Final Answer:

   Two app containers start with CPU limited to 0.5 and 512MB memory each. -> Option B

4. Quick Check:

   'deploy' works with 'docker stack deploy' = resource limits applied [OK]

Hint: Use 'docker stack deploy' to apply 'deploy' settings [OK]

Common Mistakes:

• Thinking 'deploy' works with 'docker-compose up'
• Assuming only one container starts despite replicas
• Believing resource limits are ignored in Swarm

4. You wrote this docker-compose.yml snippet:

services:
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: mypass
    ports:
      - "5432:5432"
    deploy:
      replicas: 2

When running docker-compose up, only one db container starts. Why?

medium

A. The 'deploy' section is ignored by 'docker-compose up'.

B. You must specify replicas in 'docker-compose up' command.

C. Postgres image does not support multiple replicas.

D. Port mapping conflicts prevent multiple containers.

Solution

1. Step 1: Understand 'deploy' section scope

   The 'deploy' key is only used by Docker Swarm, not by 'docker-compose up'.

2. Step 2: Explain why only one container starts

   'docker-compose up' ignores 'deploy', so it starts one container by default.

3. Final Answer:

   The 'deploy' section is ignored by 'docker-compose up'. -> Option A

4. Quick Check:

   'deploy' ignored by 'docker-compose up' = one container [OK]

Hint: 'deploy' works only with Swarm, not 'docker-compose up' [OK]

Common Mistakes:

• Thinking 'docker-compose up' can scale with 'deploy'
• Assuming port conflicts cause single container
• Believing image limits replicas

5. You want to deploy a web app with a database using Docker Compose. You need to:
- Scale the web service to 4 instances
- Limit each web container to 1 CPU and 1GB RAM
- Ensure the database runs only once with persistent storage

Which Compose features help you achieve this setup?

hard

A. Use 'deploy.replicas' and 'deploy.resources.limits' for web; use volumes for DB persistence.

B. Use 'scale' in 'docker-compose up' for DB; use 'deploy' for web resource limits.

C. Use environment variables to limit CPU and RAM; scale DB with 'deploy.replicas'.

D. Use 'depends_on' to scale web; use 'ports' to limit DB resources.

Solution

1. Step 1: Identify scaling and resource control for web

   Use 'deploy.replicas' to scale web to 4 and 'deploy.resources.limits' to limit CPU and RAM.

2. Step 2: Ensure single DB instance with persistence

   Set DB replicas to 1 and use volumes to keep data persistent.

3. Final Answer:

   Use 'deploy.replicas' and 'deploy.resources.limits' for web; use volumes for DB persistence. -> Option A

4. Quick Check:

   Scaling + resource limits + volumes = Use 'deploy.replicas' and 'deploy.resources.limits' for web; use volumes for DB persistence. [OK]

Hint: 'deploy' controls scale and limits; volumes keep DB data safe [OK]

Common Mistakes:

• Trying to scale DB instead of web
• Using environment variables for resource limits
• Confusing 'depends_on' with scaling or resource control