user avatar
How can i check docker volume size?

To check the size of a Docker volume, you can use the docker system df command to view the disk usage by Docker objects, including volumes, but this provides a high-level overview and not the size of individual volumes. For detailed information on a specific volume, you can use the following methods:

1. Using docker volume inspect with Custom Commands

For specific volume size, Docker does not directly provide a command, but you can inspect a volume and use system commands to check its size if you know where Docker stores its volumes on the host system. By default, Docker volumes are stored in /var/lib/docker/volumes on Linux. You can use this knowledge to check the size of a specific volume:

docker volume inspect [VOLUME_NAME] --format '{{ .Mountpoint }}'

Then, use the du (disk usage) command to check the size of the volume's directory:

sudo du -sh /var/lib/docker/volumes/[VOLUME_NAME]/_data

Replace [VOLUME_NAME] with the name of your Docker volume.

2. Using a Container

If you don't have direct access to the host's file system or you're using Docker for Mac/Windows, you can still check a volume's size by creating a temporary container that mounts the volume and then using the du command within that container:

docker run --rm -v [VOLUME_NAME]:/data alpine du -sh /data

This command runs an Alpine container, mounts the volume [VOLUME_NAME] to /data inside the container, and executes du -sh /data to show the size of the data within the volume. The container is removed after the command runs due to the --rm flag.

3. Docker Volume Plugins

If you're using a volume plugin, some plugins may provide their own mechanisms or commands to check the volume size. You'll need to refer to the specific plugin's documentation for instructions.


  • The du command provides the actual disk usage of files and directories. It may differ from the allocated space reported by some file systems.
  • Permissions: Running these commands might require sudo or running as a user with appropriate permissions to access Docker's internal storage or execute commands in containers.

These methods are generally applicable for most Docker installations, but details may vary depending on your Docker setup and the host operating system.

1 / 2
user avatar
Please write a script that would list all docker volumes and their respective sizes.

To create a script that lists all Docker volumes and their respective sizes, you can combine shell commands with Docker commands. The script will:

  1. List all Docker volumes.
  2. Use the volume name to find its mount point on the host.
  3. Use the du command to get the size of each volume.

Here's a basic script that does this. Note that this script assumes you're running it on a Linux host and have permissions to access Docker's storage and execute the necessary commands. You might need to run this script with sudo or as a user with Docker privileges.

#!/bin/bash # List all docker volumes, extract their names, and iterate over them docker volume ls --format "{{.Name}}" | while read volume_name; do # Get the mount point of the volume mount_point=$(docker volume inspect "$volume_name" --format '{{ .Mountpoint }}') # Use 'du' to calculate the volume's size and print it with the volume name echo "Volume: $volume_name" echo "Size: $(sudo du -sh "$mount_point" | cut -f1)" echo "-------------------------------------" done

To use this script:

  1. Copy the script into a file, for example,
  2. Make the script executable by running chmod +x
  3. Execute the script by running ./ You might need to run it as root or with sudo depending on your Docker setup and permissions, like so: sudo ./

This script will print the name and size of each volume, followed by a separator line for clarity. Note that the size reported is the actual disk usage, not the allocated space, which might be different especially for sparse files or volumes with filesystems that support compression or deduplication.

user avatar
I'd like to make the script more secure by adding `set -Eeuo pipefail`, additionally I'd like the output to be in the format "size \t volume_name" and the script should accept the size unit argument in a similar way to du command and falling back to '-sh' if not specified.

To enhance the script for listing Docker volumes and their sizes, incorporating the set -Eeuo pipefail option will make it more robust by handling errors more strictly. Also, allowing a size unit argument similar to the du command improves its flexibility. Here’s how you can modify the script:

  1. set -Eeuo pipefail ensures that the script exits immediately if a command fails, if an undefined variable is used, or if a command in a pipeline fails.
  2. The script will accept an optional argument for the size unit. If not provided, it defaults to -sh (human-readable sizes, summarizing).

Here's the revised script:

#!/bin/bash # Make script exit on any error, unset variable usage, and fail on pipe errors set -Eeuo pipefail # Check if a size unit argument is provided; default to '-sh' if not size_unit="${1:--sh}" # Function to print volume name and its size using specified size unit list_volume_sizes() { docker volume ls --format "{{.Name}}" | while read -r volume_name; do # Get the mount point of the volume mount_point=$(docker volume inspect "$volume_name" --format '{{ .Mountpoint }}') # Calculate the volume's size with the specified unit volume_size=$(sudo du $size_unit "$mount_point" | cut -f1) # Print size and volume name in the desired format printf "%s\t%s\n" "$volume_size" "$volume_name" done } # Execute the function list_volume_sizes


  1. Save the Script: Copy the above script into a file, e.g.,
  2. Make It Executable: Change the file's permissions to make it executable with chmod +x
  3. Run the Script:
    • Without size unit argument: ./ or with sudo if required.
    • With size unit argument: ./ -sm or another valid du option, e.g., -sk for kilobytes. Use sudo if necessary.

This script will now print each volume's size in the specified unit (or human-readable format by default) followed by the volume name, separated by a tab, making it more readable and allowing for easy parsing or redirection into a file or another command.