Volumes in Compose in Docker - Commands & Configuration

Introduction

Sometimes your app needs to save data that stays safe even if the app stops or restarts. Volumes in Docker Compose help you keep this data outside the app container so it doesn't get lost.

When you want to save database files so they are not deleted when the container stops.

When you need to share files between your computer and the app running inside a container.

When you want to keep logs or uploads safe even if you update or remove the app container.

When multiple containers need to access the same files or data.

When you want to separate app code from data for easier backups and updates.

Config File - docker-compose.yml

docker-compose.yml

version: '3.9'
services:
  web:
    image: nginx:1.23
    volumes:
      - web-data:/usr/share/nginx/html
volumes:
  web-data:
    driver: local

This file defines a service named web using the nginx image.

The volumes section inside the service maps a named volume web-data to the container path /usr/share/nginx/html, where nginx serves files.

The volumes key at the bottom declares the named volume web-data using the local driver, which stores data on the host machine.

Commands

This command starts the services defined in the docker-compose.yml file in detached mode, creating the volume automatically if it does not exist.

Terminal

docker-compose up -d

Expected Output

Creating network "default" with the default driver

Creating volume "web-data" with local driver

Creating compose_web_1 ... done

→

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

This command lists all Docker volumes on your system, so you can verify that the named volume was created.

Terminal

docker volume ls

Expected Output

DRIVER    VOLUME NAME

local     web-data

This command stops and removes the containers and network created by docker-compose up, but it keeps the volume data safe.

Terminal

docker-compose down

Expected Output

Stopping compose_web_1 ... done

Removing compose_web_1 ... done

Removing network default

This command shows detailed information about the named volume, including where the data is stored on your host machine.

Terminal

docker volume inspect web-data

Expected Output

[

    {

        "CreatedAt": "2024-06-01T12:00:00Z",

        "Driver": "local",

        "Labels": null,

        "Mountpoint": "/var/lib/docker/volumes/web-data/_data",

        "Name": "web-data",

        "Options": null,

        "Scope": "local"

    }

]

Key Concept

If you remember nothing else from this pattern, remember: volumes keep your app data safe outside containers so it persists across restarts and updates.

Common Mistakes

Not declaring the named volume under the top-level volumes key in docker-compose.yml.

Docker Compose will create an anonymous volume instead, making it harder to manage or reuse the data.

Always declare named volumes explicitly under the volumes section at the bottom of the compose file.

Using a relative host path instead of a named volume for persistent data.

Relative paths can cause permission issues or data loss if the path is not correct or shared properly.

Use named volumes for data that needs to persist and be managed by Docker.

Running docker-compose down with the --volumes flag expecting data to be kept.

The --volumes flag deletes all volumes created by the compose file, causing data loss.

Run docker-compose down without --volumes to keep your data safe.

Summary

Define named volumes in docker-compose.yml to store persistent data outside containers.

Use docker-compose up -d to start services and create volumes automatically.

Use docker volume ls and docker volume inspect to check and manage your volumes.

Use docker-compose down without --volumes to stop containers but keep data safe.

Practice

1. What is the main purpose of using volumes in a Docker Compose file?

easy

A. To limit container CPU usage

B. To speed up container startup time

C. To automatically update container images

D. To keep data safe outside containers so it persists

Solution

1. Step 1: Understand volume role in Docker

   Volumes store data outside the container's writable layer, so data is not lost when containers stop or are removed.

2. Step 2: Compare options

   Options B, C, and D relate to performance or resource limits, not data persistence.

3. Final Answer:

   To keep data safe outside containers so it persists -> Option D

4. Quick Check:

   Volumes = Data persistence [OK]

Hint: Volumes = persistent data storage outside containers [OK]

Common Mistakes:

• Thinking volumes speed up container startup
• Confusing volumes with resource limits
• Assuming volumes update images automatically

2. Which of the following is the correct syntax to define a named volume in a Docker Compose file?

easy

A. services:
volumes:
- mydata:/app/data

B. volumes:
- mydata:/app/data

C. volumes:
mydata:
driver: local

D. volumes:
mydata: /app/data

Solution

1. Step 1: Identify volume declaration section

   Named volumes are declared under the top-level 'volumes:' key with a name and optional driver.

2. Step 2: Check syntax correctness

   volumes: mydata: driver: local correctly defines a named volume 'mydata' with driver 'local'. Options A, B, and D mix service and volume syntax incorrectly or have invalid mapping syntax.

3. Final Answer:

   volumes: mydata: driver: local -> Option C

4. Quick Check:

   Named volume syntax = volumes: mydata: driver: local [OK]

Hint: Define named volumes under top-level 'volumes:' with name and driver [OK]

Common Mistakes:

• Defining volumes under services instead of top-level
• Using list syntax for volume declaration
• Incorrect mapping format for volumes

3. Given this snippet in a Docker Compose file:

services:
  web:
    image: nginx
    volumes:
      - mydata:/usr/share/nginx/html
volumes:
  mydata:

What happens to the data inside /usr/share/nginx/html when the container restarts?

medium

A. Data persists because 'mydata' is a named volume

B. Data is shared with the host folder automatically

C. Data is reset to the image default every restart

D. Data is lost because volumes do not persist

Solution

1. Step 1: Understand named volume behavior

   Named volumes like 'mydata' store data outside the container and keep it between restarts.

2. Step 2: Analyze the mount point

   The volume is mounted to '/usr/share/nginx/html', so data written there is saved in 'mydata' volume.

3. Final Answer:

   Data persists because 'mydata' is a named volume -> Option A

4. Quick Check:

   Named volume mount = data persistence [OK]

Hint: Named volumes keep data safe across container restarts [OK]

Common Mistakes:

• Assuming data resets to image default
• Confusing named volumes with bind mounts
• Thinking volumes do not persist data

4. You wrote this in your Docker Compose file but get an error:

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

What is the problem?

medium

A. You cannot use relative paths under 'volumes:' top-level key

B. The image name 'myapp' is invalid

C. Bind mounts must be declared under 'volumes:' top-level key

D. The service name 'app' is reserved

Solution

1. Step 1: Understand volume declaration rules

   Top-level 'volumes:' is for named volumes only, not for bind mounts with paths.

2. Step 2: Identify misuse of relative path

   Using './data:' under 'volumes:' top-level is invalid syntax; relative paths belong only in service volume mounts.

3. Final Answer:

   You cannot use relative paths under 'volumes:' top-level key -> Option A

4. Quick Check:

   Relative paths only in service volumes [OK]

Hint: Declare bind mounts only under service volumes, not top-level [OK]

Common Mistakes:

• Putting bind mount paths under top-level volumes
• Assuming image name causes this error
• Thinking service names are restricted

5. You want to share a local folder ./config with a container's /etc/config path and also keep a database's data persistent using a named volume dbdata. Which is the correct Docker Compose snippet?

hard

A. services:
app:
image: myapp
volumes:
- dbdata:/etc/config
db:
image: postgres
volumes:
- ./config:/var/lib/postgresql/data
volumes:
dbdata:

B. services:
app:
image: myapp
volumes:
- ./config:/etc/config
db:
image: postgres
volumes:
- dbdata:/var/lib/postgresql/data
volumes:
dbdata:

C. services:
app:
image: myapp
volumes:
- /etc/config:./config
db:
image: postgres
volumes:
- /var/lib/postgresql/data:dbdata
volumes:
dbdata:

D. services:
app:
image: myapp
volumes:
- ./config:/etc/config
db:
image: postgres
volumes:
- ./dbdata:/var/lib/postgresql/data
volumes:
dbdata:

Solution

1. Step 1: Identify bind mount for local folder sharing

   Bind mounts use local paths like './config:/etc/config' under service volumes.

2. Step 2: Identify named volume for database persistence

   Named volumes like 'dbdata' are declared top-level and mounted as 'dbdata:/var/lib/postgresql/data'.

3. Step 3: Check options for correct syntax

   services: app: image: myapp volumes: - ./config:/etc/config db: image: postgres volumes: - dbdata:/var/lib/postgresql/data volumes: dbdata: correctly uses bind mount for app and named volume for db. Options B and C swap paths incorrectly. services: app: image: myapp volumes: - ./config:/etc/config db: image: postgres volumes: - ./dbdata:/var/lib/postgresql/data volumes: dbdata: uses a bind mount for dbdata instead of named volume.

4. Final Answer:

   services: app: image: myapp volumes: - ./config:/etc/config db: image: postgres volumes: - dbdata:/var/lib/postgresql/data volumes: dbdata: -> Option B

5. Quick Check:

   Bind mount + named volume = services: app: image: myapp volumes: - ./config:/etc/config db: image: postgres volumes: - dbdata:/var/lib/postgresql/data volumes: dbdata: [OK]

Hint: Use bind mounts for local folders, named volumes for persistent data [OK]

Common Mistakes:

• Swapping source and target paths
• Using bind mounts instead of named volumes for DB data
• Declaring bind mounts under top-level volumes