Loading...
No results found.

Apply your skills in Google Cloud console

Lab setup instructions and requirements
Protect your account and progress. Always use a private browser window and lab credentials to run this lab.

Docker Essentials: Container Volumes

Lab 30 minutes universal_currency_alt 1 Credit show_chart Introductory
info This lab may incorporate AI tools to support your learning.
This content is not yet optimized for mobile devices.
For the best experience, please visit us on a desktop computer using a link sent by email.

gem-docker-volumes

Google Cloud self-paced labs logo

Activate Cloud Shell

Cloud Shell is a virtual machine that is loaded with development tools. It offers a persistent 5GB home directory and runs on the Google Cloud. Cloud Shell provides command-line access to your Google Cloud resources.

  1. Click Activate Cloud Shell Activate Cloud Shell icon at the top of the Google Cloud console.

When you are connected, you are already authenticated, and the project is set to your PROJECT_ID. The output contains a line that declares the PROJECT_ID for this session:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud is the command-line tool for Google Cloud. It comes pre-installed on Cloud Shell and supports tab-completion.

  1. (Optional) You can list the active account name with this command:
gcloud auth list

  1. Click Authorize.

  2. Your output should now look like this:

Output:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`
  1. (Optional) You can list the project ID with this command:
gcloud config list project

Output:

[core] project = <project_ID>

Example output:

[core] project = qwiklabs-gcp-44776a13dea667a6 Note: For full documentation of gcloud, in Google Cloud, refer to the gcloud CLI overview guide.

Overview

This lab explores Docker volumes, a critical mechanism for data persistence in containerized applications. You'll learn how volumes work, the different types available, and how to use them to ensure your data survives container restarts and removals. This lab assumes a basic understanding of Docker and Linux.

Task 1. Understanding Docker Volumes

This task will cover the fundamentals of docker volumes.

  1. What are Docker Volumes? Docker volumes are directories (or files) that are external to the container's filesystem. This means that the data within a volume persists even if the container is stopped, removed, or recreated. Why are they important? By default, data inside a container is ephemeral, meaning it's lost when the container is stopped or removed. Volumes provide a way to store persistent data, such as databases, configuration files, or user uploads.
# No code required for this step. This is a conceptual overview.
  1. Types of Volumes: Docker offers three primary types of volumes: named volumes, bind mounts, and tmpfs mounts. Named volumes are managed by Docker and stored in a Docker-managed directory on the host machine. They are the preferred way to persist data. Bind mounts map a directory or file on the host machine directly into the container. They offer more flexibility but can also introduce security risks if not used carefully. tmpfs mounts are stored in the host's memory and are not persisted across container restarts. They are useful for storing temporary data that doesn't need to be saved.
# No code required for this step. This is a conceptual overview.

Task 2. Creating and Using Named Volumes

This task demonstrates how to create and use named volumes to persist data.

  1. Create a named volume called 'mydata'.
docker volume create mydata
  1. Inspect the volume to see its details. Note the Mountpoint; this is where the volume data is stored on the host.
docker volume inspect mydata
  1. Run a container that uses the 'mydata' volume. This example uses a simple Alpine Linux container and mounts the volume to the /data directory inside the container.
docker run -it -v mydata:/data alpine ash
  1. Create a file inside the active container.
cd /data echo "Hello from inside the container!" > myfile.txt exit
  1. Stop the container.
docker stop $(docker ps -aq)
  1. Remove the container.
docker rm $(docker ps -aq)
  1. Run a new container using the same volume.
docker run -it -v mydata:/data alpine ash
  1. Verify that the 'myfile.txt' file still exists in the /data directory.
cd /data ls -l cat myfile.txt exit
  1. Clean up the volume (optional).
docker volume rm mydata

Task 3. Using Bind Mounts

This task demonstrates how to use bind mounts to share data between the host and a container.

  1. Create a directory on your host machine.
mkdir ~/host_data
  1. Create a file in the directory.
echo "Hello from the host!" > ~/host_data/hostfile.txt
  1. Run a container and bind-mount the directory to /data inside the container.
docker run -it -v /home/$USER/host_data:/data alpine ash
  1. Modify the file from inside the container.
echo "This line added from container" >> /data/hostfile.txt cat /data/hostfile.txt exit
  1. Check the file on the host machine. The changes made inside the container should be reflected on the host.
cat ~/host_data/hostfile.txt
  1. Clean up the directory (optional).
rm -rf ~/host_data

Task 4. Using Volumes with Docker Compose

This task demonstrates how to define and use volumes within a Docker Compose file.

  1. Create a docker-compose.yml file with the following content. This example defines a simple web server using the nginx image and mounts a volume to the /usr/share/nginx/html directory to serve static content.
version: "3.3" services: web: image: nginx:latest ports: - "8080:80" volumes: - web_data:/usr/share/nginx/html volumes: web_data:
  1. Create an index.html file in the same directory as the docker-compose.yml file with some basic HTML content.
<html> <head> <title>Docker Compose Volume Example</title> </head> <body> <div><strong>Hello from Docker Compose!</strong></div> <p>This content is served from a Docker volume.</p> </body> </html>
  1. Start the application using Docker Compose.
docker-compose up -d
  1. Access the application in your browser at http://localhost:8080. You should see the content from the index.html file.
curl http://localhost:8080
  1. Stop and remove the application.
docker-compose down

Congratulations!

In this lab, you explored Docker volumes and their importance for data persistence. You learned how to create and use named volumes and bind mounts, and how to define volumes in Docker Compose files. Understanding volumes is crucial for building stateful containerized applications.

Additional Resources

Manual Last Updated Jun 24, 2025

Lab Last Tested Jun 24, 2025

Before you begin

  1. Labs create a Google Cloud project and resources for a fixed time
  2. Labs have a time limit and no pause feature. If you end the lab, you'll have to restart from the beginning.
  3. On the top left of your screen, click Start lab to begin

Use private browsing

  1. Copy the provided Username and Password for the lab
  2. Click Open console in private mode

Sign in to the Console

  1. Sign in using your lab credentials. Using other credentials might cause errors or incur charges.
  2. Accept the terms, and skip the recovery resource page
  3. Don't click End lab unless you've finished the lab or want to restart it, as it will clear your work and remove the project

This content is not currently available

We will notify you via email when it becomes available

Great!

We will contact you via email if it becomes available

One lab at a time

Confirm to end all existing labs and start this one

Use private browsing to run the lab

Using an Incognito or private browser window is the best way to run this lab. This prevents any conflicts between your personal account and the Student account, which may cause extra charges incurred to your personal account.