How To Use Volumes in Docker

Docker volumes are a persistent storage mechanism that decouples your data from the container lifecycle. Volumes let containers retain data across restarts and removals, and allow multiple containers to share a common data source. Unlike bind mounts, Docker manages volumes internally and stores them under /var/lib/docker/volumes/ on Linux systems.

This article shows how to create and inspect Docker volumes, interact with their contents, and use them in Docker Compose workflows. You'll also learn how to back up and restore volume data, and how to reference volumes using the VOLUME instruction in a Dockerfile.

The Short Answer Version

The following Docker commands demonstrate how to manage persistent data using volumes:

# Create a new volume
$ docker volume create web_content

# Run a container and mount the volume
$ docker container run -d -v web_content:/app/data --name volume_demo httpd

# List all volumes
$ docker volume ls

# Inspect a volume
$ docker volume inspect web_content

# Remove a volume
$ docker volume rm web_content

# Remove all unused volumes
$ docker volume prune

When to Use Docker Volumes

Use Docker volumes instead of bind mounts in the following situations:

• You want data to persist across container restarts or removals.
• You need consistent storage behavior across Linux, macOS, and Windows.
• You prefer Docker-managed storage lifecycle and internal volume handling.
• You plan to back up or restore application data regularly.
• You need to share persistent data between multiple containers.

Bind mounts are more suitable for development environments where code changes on the host need to reflect immediately in the container. For production environments, Docker volumes are the preferred choice due to their portability, safety, and lifecycle integration.

Manually Create and Link Volumes

Docker volumes allow you to persist container data independently of the container lifecycle. This section demonstrates how to manually create a volume, attach it to a container, inspect it, and remove both the container and the volume.

1. Create a Docker volume.

   CONSOLE

   Copy

   $ docker volume create web_content

   Explain Code

   Powered by Vultr AgentBeta

   This command creates a Docker-managed volume named web_content. Docker stores it internally and tracks its metadata.

   • volume create: Initializes a new volume.
   • web_content: The name assigned to the volume.

   Output:

   web_content

2. Run a container and mount the volume.

   CONSOLE

   Copy

   $ docker container run -d -v web_content:/usr/local/apache2/htdocs --name apache_with_volume httpd

   Explain Code

   Powered by Vultr AgentBeta

   This launches a container with the httpd image and mounts the named volume at the web server's root, making it available for data persistence.

   • -d: Runs the container in detached mode.
   • -v web_content:/usr/local/apache2/htdocs: Mounts the web_content volume to Apache’s web root.
   • --name apache_with_volume: Assigns a custom name to the container.
   • httpd: Uses the official Apache HTTP server image.

   Output:

   03d0120e51dd822148d4c4c0464473cdad8a916e22ba5685ec495e47573dc722

3. List all volumes.

   CONSOLE

   Copy

   $ docker volume ls

   Explain Code

   Powered by Vultr AgentBeta

   This command verifies that the volume was created and is currently available.

   • volume ls: Lists all volumes managed by Docker.

   Output:

   DRIVER    VOLUME NAME
   local     web_content

4. Inspect the volume.

   CONSOLE

   Copy

   $ docker volume inspect web_content

   Explain Code

   Powered by Vultr AgentBeta

   Use this command to confirm the volume’s internal mount path and attributes, useful for debugging and manual access.

   • volume inspect: Displays low-level metadata about a volume.
   • web_content: Target volume name.

   Output:

   [
      {
          "CreatedAt": "2025-06-06T17:38:52Z",
          "Driver": "local",
          "Labels": null,
          "Mountpoint": "/var/lib/docker/volumes/web_content/_data",
          "Name": "web_content",
          "Options": null,
          "Scope": "local"
      }
   ]

5. List all containers.

   CONSOLE

   Copy

   $ docker container ls -a

   Explain Code

   Powered by Vultr AgentBeta

   This confirms that the container is active and correctly linked to the volume.

   • container ls -a: Shows all containers, running or stopped.

   Output:

   CONTAINER ID   IMAGE     COMMAND              CREATED          STATUS          PORTS     NAMES
   03d0120e51dd   httpd     "httpd-foreground"   46 seconds ago   Up 45 seconds   80/tcp    apache_with_volume

6. Check volume usage by container.

   CONSOLE

   Copy

   $ docker container inspect --format={{.Mounts}} apache_with_volume

   Explain Code

   Powered by Vultr AgentBeta

   This shows where the volume is mounted inside the container, validating its usage path.

   • inspect: Retrieves metadata about the container.
   • --format={{.Mounts}}: Filters output to show mount points.

   Output:

   [{volume web_content /var/lib/docker/volumes/web_content/_data /usr/local/apache2/htdocs local z true }]

7. Stop the container.

   CONSOLE

   Copy

   $ docker container stop apache_with_volume

   Explain Code

   Powered by Vultr AgentBeta

   This halts the container without removing it, preserving the volume and data.

   • container stop: Gracefully stops a running container.

   Output:

   apache_with_volume

8. Remove the container.

   CONSOLE

   Copy

   $ docker container rm apache_with_volume

   Explain Code

   Powered by Vultr AgentBeta

   This removes the container while leaving the named volume intact for reuse.

   • container rm: Deletes the stopped container.

   Output:

   apache_with_volume

9. Remove the volume.

   CONSOLE

   Copy

   $ docker volume rm web_content

   Explain Code

   Powered by Vultr AgentBeta

   This permanently removes the volume and its contents.

   • volume rm: Deletes the specified volume.

   Output:

   web_content

Use Volumes in Dockerfiles

While Dockerfiles can't create named volumes, they can define mount points expected at runtime using the VOLUME instruction. Docker automatically creates an anonymous volume for such paths unless you explicitly mount a named one when running the container.

1. Navigate to the user's home directory and create a docker directory.

   CONSOLE

   Copy

   $ cd ~
   $ mkdir docker

   Explain Code

   Powered by Vultr AgentBeta

2. Navigate into the new directory.

   CONSOLE

   Copy

   $ cd docker/

   Explain Code

   Powered by Vultr AgentBeta

3. Create a Dockerfile.

   CONSOLE

   Copy

   $ nano Dockerfile

   Explain Code

   Powered by Vultr AgentBeta

4. Add the following content to the Dockerfile:

   DOCKERFILE

   Copy

   FROM httpd
   VOLUME ["/usr/local/apache2/htdocs"]
   CMD ["httpd-foreground"]

   Explain Code

   Powered by Vultr AgentBeta

   Save and close the file.

   This Dockerfile builds an Apache-based image that treats /usr/local/apache2/htdocs as a volume path.

   • VOLUME ["/usr/local/apache2/htdocs"]: Declares a runtime mount point for persistent data.

5. Build the image.

   CONSOLE

   Copy

   $ docker image build -t apache_with_volume .

   Explain Code

   Powered by Vultr AgentBeta

   This builds the Dockerfile and creates a new image named apache_with_volume.

   • -t apache_with_volume: Tags the resulting image with a readable name.

   Output:

   [+] Building 0.1s (5/5) FINISHED                            docker:default
    => [internal] load build definition from Dockerfile        0.0s
    => => transferring dockerfile: 110B                        0.0s
    => [internal] load metadata for docker.io/library/httpd    0.0s
    => => writing image sha256:c886f948f696b...                0.0s
    => => naming to docker.io/library/apache_with_volume       0.0s

6. Run the container.

   CONSOLE

   Copy

   $ docker container run -d --rm apache_with_volume

   Explain Code

   Powered by Vultr AgentBeta
   • -d: Runs the container in detached mode.
   • --rm: Automatically removes the container when it exits.

   Docker automatically creates an anonymous volume and mounts it at /usr/local/apache2/htdocs, as defined in the Dockerfile.

   To use a named volume instead of an anonymous one, pass the -v flag explicitly:

   CONSOLE

   Copy

   $ docker container run -d --rm -v web_content:/usr/local/apache2/htdocs apache_with_volume

   Explain Code

   Powered by Vultr AgentBeta

   This allows you to control the volume lifecycle while still benefiting from Dockerfile-defined mount points.

Interact with Docker Volumes

Docker does not let you directly mount volumes on the host system, but you can access and modify volume contents from within a running container.

1. Start a container with the volume mounted.

   CONSOLE

   Copy

   $ docker container run -d --name apache_with_volume -v web_content:/usr/local/apache2/htdocs httpd

   Explain Code

   Powered by Vultr AgentBeta

   This launches the container and mounts the named volume to serve persistent content.

   • -d: Runs the container in detached mode.
   • --name apache_with_volume: Assigns a custom name to the container.
   • -v web_content:/usr/local/apache2/htdocs: Mounts the volume to Apache’s default web root.
   • httpd: Uses the official Apache image.

   Output:

   03d0120e51dd8221...

2. Create an HTML file on your host machine.

   CONSOLE

   Copy

   $ echo "<h1>Hello Apache from docker volume</h1>" > index.html

   Explain Code

   Powered by Vultr AgentBeta

   This creates a simple HTML file for demonstration.

3. Copy the file into the container.

   CONSOLE

   Copy

   $ docker cp index.html apache_with_volume:/usr/local/apache2/htdocs/

   Explain Code

   Powered by Vultr AgentBeta

   This places your HTML file into the volume's mount point within the container.

   • docker cp: Copies files between host and container.
   • index.html: Source file on the host.
   • apache_with_volume:/usr/local/apache2/htdocs/: Destination path inside the container.

   Output:

   Successfully copied 2.05kB to apache_with_volume:/usr/local/apache2/htdocs/

4. View file contents inside the container.

   CONSOLE

   Copy

   $ docker exec apache_with_volume \
      cat /usr/local/apache2/htdocs/index.html

   Explain Code

   Powered by Vultr AgentBeta

   This verifies that the file was successfully copied into the container.

   • docker exec: Runs a command inside a running container.
   • cat /usr/local/apache2/htdocs/index.html: Prints the contents of the copied file.

   Output:

   <h1>Hello Apache from docker volume</h1>

5. Back up the volume from inside the container.

   CONSOLE

   Copy

   $ docker exec apache_with_volume \
      tar czf /usr/local/apache2/htdocs/httpd_backup.tar.gz -C /usr/local/apache2/htdocs .

   Explain Code

   Powered by Vultr AgentBeta

   This creates a backup archive of the volume’s contents inside the container.

   • tar czf: Creates a compressed .tar.gz archive.
   • -C /usr/local/apache2/htdocs .: Archives the current directory (volume contents) into httpd_backup.tar.gz.

6. Copy the backup file from the container to the host.

   CONSOLE

   Copy

   $ docker cp apache_with_volume:/usr/local/apache2/htdocs/httpd_backup.tar.gz .

   Explain Code

   Powered by Vultr AgentBeta

   This allows you to save a local backup of the volume.

   • docker cp: Transfers files from the container to the host.
   • apache_with_volume:/usr/local/apache2/htdocs/httpd_backup.tar.gz: Source archive inside the container.
   • .: Destination path on the host (current directory).

   Output:

   Successfully copied 2.05kB to /home/john/docker/.

7. Restore the volume by copying the archive back and extracting it.

   CONSOLE

   Copy

   $ docker cp httpd_backup.tar.gz apache_with_volume:/usr/local/apache2/htdocs/

   Explain Code

   Powered by Vultr AgentBeta
   CONSOLE

   Copy

   $ docker exec apache_with_volume \
      tar xzf /usr/local/apache2/htdocs/httpd_backup.tar.gz -C /usr/local/apache2/htdocs

   Explain Code

   Powered by Vultr AgentBeta

   These steps restore the previous data state into the mounted volume.

   • First command copies the backup archive into the container.
   • Second command extracts the archive contents into the volume directory.

Use Volumes with Docker Compose

Docker Compose supports named volumes natively. These volumes are automatically created and managed alongside the service lifecycle.

1. Create a docker-compose directory in your home path.

   CONSOLE

   Copy

   $ cd ~
   $ mkdir docker-compose

   Explain Code

   Powered by Vultr AgentBeta

2. Navigate to the new directory.

   CONSOLE

   Copy

   $ cd docker-compose/

   Explain Code

   Powered by Vultr AgentBeta

3. Create a docker-compose.yml manifest.

   CONSOLE

   Copy

   $ nano docker-compose.yml

   Explain Code

   Powered by Vultr AgentBeta

4. Add the following YAML content to the file:

   YAML

   Copy

   services:
      web:
          image: httpd
          volumes:
              - web_content:/usr/local/apache2/htdocs
   
   volumes:
      web_content:

   Explain Code

   Powered by Vultr AgentBeta

   This configuration tells Docker Compose to create a volume named web_content and mount it to the container at /usr/local/apache2/htdocs.

   • image: httpd: Uses the official Apache image.
   • volumes:: Mounts the named volume web_content to Apache's web root.
   • The volumes: section at the root defines the named volume.

5. Start the service.

   CONSOLE

   Copy

   $ docker compose up -d

   Explain Code

   Powered by Vultr AgentBeta

   This command builds and runs the container while automatically creating the declared volume and network.

   • up -d: Starts the services defined in the Compose file in detached mode.

   Output:

   [+] Running 3/3
   ✔ Network docker-compose_default       Created                    0.2s 
   ✔ Volume "docker-compose_web_content"  Created                    0.0s 
   ✔ Container docker-compose-web-1       Started                    0.6s

6. Inspect the volume created by Docker Compose.

   CONSOLE

   Copy

   $ docker volume inspect docker-compose_web_content

   Explain Code

   Powered by Vultr AgentBeta

   Replace docker-compose_web_content with the name of your Docker Compose volume. This confirms that the named volume declared in the Compose file was created and is mounted as expected.

   • volume inspect: Displays detailed metadata about the named volume.

   Output:

   [
       {
           "Name": "docker-compose_web_content",
           "Mountpoint": "/var/lib/docker/volumes/docker-compose_web_content/_data",
           ...
       }
   ]

7. Shut down the service and remove the volume.

   CONSOLE

   Copy

   $ docker compose down -v

   Explain Code

   Powered by Vultr AgentBeta

   This removes all Docker resources tied to the Compose application, including the named volume.

   • down: Stops and removes containers, networks, and volumes.
   • -v: Ensures that named volumes declared in the Compose file are also deleted.

   Output:

   [+] Running 3/3
   ✔ Container docker-compose-web-1     Removed                      1.3s 
   ✔ Network docker-compose_default     Removed                      0.2s 
   ✔ Volume docker-compose_web_content  Removed                      0.0s

Conclusion

In this article, you explored how to create and manage Docker volumes using the CLI, Dockerfiles, and Docker Compose. You learned how to mount volumes to containers, inspect and remove them, and back up or restore volume data using practical workflows. Docker volumes are essential for separating application logic from persistent data. They improve data durability, simplify container management, and support scalable, production-ready deployments.