Un­der­stand­ing and managing Docker container volumes

Docker is open source software for creating and managing con­tain­ers. With a Docker volume, you can transfer data between con­tain­ers or back up data from a Docker container.

• Docker is installed and running
• You have basic fa­mil­iar­i­ty with Docker’s func­tion­al­i­ty and Docker commands

In order to un­der­stand Docker volumes, it is important to first un­der­stand how the Docker file system works.

A Docker image is a col­lec­tion of read-only layers. When you launch a container from an image, Docker adds a read-write layer to the top of that stack of read-only layers. Docker calls this the Union File System. Any time a file is changed, Docker makes a copy of the file from the read-only layers up into the top read-write layer. This leaves the original (read-only) file unchanged. When a container is deleted, that top read-write layer is lost. This means that any changes made after the container was launched are now gone.

A Docker volume allows data to persist, even when a container is deleted. Volumes are also a con­ve­nient way to share data between the host and the container.

Mounting a Docker volume is a good solution if you want to:

• Push data to a Docker container.
• Pull data from a Docker container.
• Share data between Docker con­tain­ers.

Docker volumes exist outside the Union File System of read-only and read-write layers. The volume is a folder which is shared between the container and the host machine. Volumes can also be shared between con­tain­ers.

A Docker volume “lives” outside the container, on the host machine. From the container, the volume acts like a folder which you can use to store and retrieve data. It is simply a mount point to a directory on the host. There are several ways to create and manage Docker volumes. Each method has its own ad­van­tages and dis­ad­van­tages.

As of version 1.9.0, which was released 11/3/2015, Docker volumes can now be created and managed using the in­te­grat­ed docker volume command.

The docker volume create command will create a named volume. The name allows you to easily locate and assign Docker volumes to con­tain­ers.

To create a Docker volume, use the command:

To launch a container which will use a volume that you have created with docker volume, add the following argument to the docker run command:

For example, to run a container from the CentOS image named my-volume-test and map the volume data-volume to the container’s /data directory, the command is:

To list all Docker volumes on the system, use the command:

This will return a list of all of the Docker volumes which have been created on the host.

To inspect a named volume, use the command:

This will return in­for­ma­tion about the volume, including its mount point (the directory where it “lives”) on the host system.

For example, to get more in­for­ma­tion about data-volume which we created above, the command is:

To remove a named volume, use the command:

You will not be able to remove a volume if it is being used by an existing container. Before removing the volume, you will need to stop and delete the container with the commands:

For example, to delete the volume data-volume, we will first need to delete the container my-volume-test, which is using it:

The volume data-volume can then be deleted with:

If you want to mount a specific directory on your host machine as a Docker volume on the container, add the following argument to your docker run command:

For example, to launch a new container and map the /webfiles folder from the host into the /var/www/html folder in the container, the command is:

You can test this by first creating a directory to use as a Docker volume with the command:

Add a small test file to this directory with the command:

Next, launch a container named my-directory-test and map /hostvol­ume on the host to /con­tain­er­vol­ume on the container with the command:

Once you are at the new con­tain­er's command prompt, list the files in the shared volume with the command:

You will see the host-hello.txt file which we created on the host.

This works in the opposite direction, as well. Files you put into this directory will appear on the host. You can test this from the container by adding another file to the shared volume with the command:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt. Once there, list the files in the shared volume on with the command:

You will see the two test files we created from the host and from the container.

Use the following command in a Dock­er­file to create a shared storage volume in the container:

For example, to create a volume /myvolume in the container to be launched from the Dock­er­file, the command is:

To test this, begin by creating a file called Dock­er­file with the command:

Put the following content into this file:

Save and exit the file.

Next, build an image named dock­er­file-vol­ume­test from this Dock­er­file with the command:

Then launch a container named my-dock­er­file-test from this image with the command:

Once you are at the new con­tain­er's command prompt, create a small test file in the shared volume with the command:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt.

Next, let’s find the mount point. To do this, use the command:

• Source is the directory on the host machine.
• Des­ti­na­tion is the folder on the container.

Check the source directory on your host machine. In this example, the command is:

Here you will find the dock­er­file-container-hello.txt file which you created on the container.

There are many sit­u­a­tions where it is useful to share a Docker volume between con­tain­ers, and several ways to ac­com­plish this goal.

If you create a volume on the host machine, it can be used by multiple different con­tain­ers at once. This allows you to share data between con­tain­ers and the host. For this example we will create a directory on the host, and use that directory as a shared volume between two con­tain­ers.

Begin by creating a directory to use as a Docker volume with the command:

Create a small test file in this directory with the command:

Next, launch a container named sql-database from the official Post­greSQL image, and map /webdata on the host to /data on the container with the command:

Once you are at the new container’s command prompt, verify that the shared volume is set up correctly with the command:

You will see the host-hello.txt file which we created on the host. Let's add a file to this shared volume with the command:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt.

Now launch a container named webapp from the official PHP+Apache image, and map /webdata on the host to /var/www/html on the container.

Once you are at the new con­tain­er's command prompt, verify that the shared volume is set up correctly with the command:

You will see both the host-hello.txt file which we created on the host, and the sql-hello.txt file we created on the sql-database container.

Let's add a file from this container as well:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt. Once on the host machine, you will see all three files listed with the command:

Now that the two con­tain­ers are sharing a directory which “lives” on the host, data can be trans­ferred instantly between all three locations simply by moving it to that directory.

You can also set up a separate container as a shared data volume. To do this, first create the data container. Then, when you create the container that will be using that data container, add the following argument to the docker run command:

For this example, we will create a data container called data-storage which will serve as the data volume, and two other con­tain­ers that share it as a storage volume.

First, launch the data-storage container from the official CentOS 7 image:

Then add a small file to the /shared-data folder:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt.

Now launch the app container from the official Python image and mount the data-storage container as a volume:

List the files in the shared volume with the command:

As you can see, the /shared-data folder has been mounted from the /shared-data folder on the data-storage container, and contains the data-storage-hello.txt file.

Let’s add one from this container:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt.

Finally, launch the web container from the official Apache image and mount the data-storage container as a volume:

List the files in the shared volume with the command:

You will see the files we created on the data-storage and app con­tain­ers listed here.

Through­out this guide we have been mounting volumes with the default read-write access. If you want to restrict a container to having read-only access to a volume, simply add :ro to the container volume specified in the -v statement:

This can be useful for security purposes, or when you want to ensure that the data in a par­tic­u­lar volume is safe­guard­ed against being ac­ci­den­tal­ly over­writ­ten or deleted by another container.

For example, begin by creating a volume on the host named limited-access with the command:

Then run a container from the CentOS image named allowed-to-write and map the volume limited-access as a normal (read-write) volume:

Once you are at this con­tain­er's command prompt, create a test file with the command:

Detach from the container with [Ctrl] + [P] and [Ctrl] + [Q] and return to the host machine’s command prompt.

Next, run a container from the CentOS image named not-allowed-to-write and map the volume limited-access as a read-only volume:

If you attempt to create a test file in the shared volume with a command such as this

you will receive an error which explains that this container does not have write access to that directory: