Skip to main content

Docker Volumes & Storage

📁 14. What are Docker volumes, and why are they needed?​

Docker volume āĻšāϞ⧋ Docker-āĻāϰ manage āĻ•āϰāĻž āĻāĻ•āϟāĻŋ persistent storage mechanism, āϝāĻž container-āĻāϰ āĻŦāĻžāχāϰ⧇ data āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤

āϕ⧇āύ āĻĻāϰāĻ•āĻžāϰ? Container āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ•āĻ­āĻžāĻŦ⧇ stateless — āĻ…āĻ°ā§āĻĨāĻžā§Ž container āĻŦāĻ¨ā§āϧ āĻŦāĻž delete āĻšāϞ⧇ āϤāĻžāϰ āϭ⧇āϤāϰ⧇āϰ āϏāĻŦ data āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ real-world application-āĻ database, log file, āĻŦāĻž user-uploaded content āĻāϰ āĻŽāϤ⧋ data persistent āϰāĻžāĻ–āĻž āϜāϰ⧁āϰāĻŋāĨ¤ Volume āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϞ⧇:

  • Container delete āĻšāϞ⧇āĻ“ data āĻĨāĻžāϕ⧇
  • āĻāĻ•āĻžāϧāĻŋāĻ• container āĻāĻ•āχ data share āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇
  • Data backup āĻ“ migrate āĻ•āϰāĻž āϏāĻšāϜ āĻšāϝāĻŧ
  • Host filesystem āĻĨ⧇āϕ⧇ independent āĻĨāĻžāϕ⧇, āϤāĻžāχ portable

What is the difference between a volume, a bind mount, and a tmpfs mount?​

āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝVolumeBind Mounttmpfs Mount
Storage locationDocker-managed directoryHost-āĻāϰ āϝ⧇āϕ⧋āύ⧋ pathRAM (memory)
PortabilityāĻŦ⧇āĻļāĻŋ portableHost path-āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰāĻļā§€āϞN/A
Data persistenceāĻšā§āϝāĻžāρāĻšā§āϝāĻžāρāύāĻž (container āĻŦāĻ¨ā§āϧ⧇ āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧ)
PerformanceāĻ­āĻžāϞ⧋OS-dependentāϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĻā§āϰ⧁āϤ
āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰProduction data, databaseDevelopment, source codeSensitive/temporary data

Volume — Docker āύāĻŋāĻœā§‡ manage āĻ•āϰ⧇, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ recommended approachāĨ¤

Bind Mount — Host machine-āĻāϰ specific directory āϏāϰāĻžāϏāϰāĻŋ container-āĻ mount āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ Development-āĻ source code share āĻ•āϰāϤ⧇ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇āĨ¤

tmpfs Mount — āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ memory-āϤ⧇ āĻĨāĻžāϕ⧇, disk-āĻ āϞ⧇āϖ⧇ āύāĻžāĨ¤ Sensitive data (āϝ⧇āĻŽāύ secret, token) temporary āϰāĻžāĻ–āĻžāϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧁āĻ•ā§āϤāĨ¤


Where does Docker store volume data on the host filesystem?​

Linux host-āĻ Docker volume-āĻāϰ data āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻšāϝāĻŧ:

/var/lib/docker/volumes/<volume_name>/_data

āωāĻĻāĻžāĻšāϰāĻŖ, myapp_data āύāĻžāĻŽā§‡āϰ volume-āĻāϰ data āĻĨāĻžāĻ•āĻŦ⧇:

/var/lib/docker/volumes/myapp_data/_data

āύ⧋āϟ: Windows āĻŦāĻž macOS-āĻ Docker āĻāĻ•āϟāĻŋ Linux VM-āĻāϰ āϭ⧇āϤāϰ⧇ āϚāϞ⧇, āϤāĻžāχ āĻāχ path āϏāϰāĻžāϏāϰāĻŋ host āĻĨ⧇āϕ⧇ accessible āύāĻžāĻ“ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Volume inspect āĻ•āϰāϤ⧇:

docker volume inspect myapp_data

What is the difference between named volumes and anonymous volumes?​

Named Volume:

  • Explicitly āĻāĻ•āϟāĻŋ āύāĻžāĻŽ āĻĻāĻŋāϝāĻŧ⧇ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧ
  • āϏāĻšāĻœā§‡ āĻĒ⧁āύāϰāĻžāϝāĻŧ reference āĻ•āϰāĻž āϝāĻžāϝāĻŧ
  • docker volume ls-āĻ clearly āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ
  • Recommended for production use
# Named volume āϤ⧈āϰāĻŋ
docker volume create myapp_data

# Container-āĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ
docker run -v myapp_data:/app/data myimage

Anonymous Volume:

  • āϕ⧋āύ⧋ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ āύāĻž, Docker automatically āĻāĻ•āϟāĻŋ random ID assign āĻ•āϰ⧇
  • Container delete āĻšāϞ⧇ āĻāϟāĻŋ orphaned āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ
  • Track āĻ•āϰāĻž āĻ•āĻ āĻŋāύ, āϏāĻžāϧāĻžāϰāĻŖāϤ avoid āĻ•āϰāĻž āωāϚāĻŋāϤ
# Anonymous volume (āύāĻžāĻŽ āύ⧇āχ)
docker run -v /app/data myimage

āϏāĻšāϜ āύāĻŋāϝāĻŧāĻŽ: Production-āĻ āϏāĻŦāϏāĻŽāϝāĻŧ named volume āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύāĨ¤


How do you share a volume between multiple containers?​

āĻāĻ•āχ named volume āĻāĻ•āĻžāϧāĻŋāĻ• container-āĻ mount āĻ•āϰāϞ⧇āχ āϤāĻžāϰāĻž āĻāĻ•āχ data access āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āωāĻĻāĻžāĻšāϰāĻŖ — āĻĻ⧁āϟāĻŋ container āĻāĻ•āχ volume share āĻ•āϰāϛ⧇:

# āĻĒā§āϰāĻĨāĻŽā§‡ volume āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ
docker volume create shared_data

# āĻĒā§āϰāĻĨāĻŽ container āϚāĻžāϞ⧁ āĻ•āϰ⧁āύ
docker run -d \
--name container_one \
-v shared_data:/app/data \
myimage

# āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ container āĻāĻ•āχ volume mount āĻ•āϰ⧁āύ
docker run -d \
--name container_two \
-v shared_data:/app/data \
myimage

āĻāĻ–āύ container_one āϝāĻž /app/data-āϤ⧇ āϞāĻŋāĻ–āĻŦ⧇, container_two-āĻ“ āϏ⧇āϟāĻž read āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Docker Compose-āĻ:

version: "3.8"

services:
app:
image: myimage
volumes:
- shared_data:/app/data

worker:
image: myworker
volumes:
- shared_data:/app/data

volumes:
shared_data:

āϏāϤāĻ°ā§āĻ•āϤāĻž: āĻāĻ•āĻžāϧāĻŋāĻ• container āĻāĻ•āχ āϏāĻŽāϝāĻŧ⧇ āĻāĻ•āχ file-āĻ write āĻ•āϰāϞ⧇ race condition āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ application-level locking āĻŦāĻž database āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύāĨ¤

🔄 15. How do you persist data in Docker containers?​

Container-āĻ data persist āĻ•āϰāĻžāϰ āϤāĻŋāύāϟāĻŋ āĻĒā§āϰāϧāĻžāύ āωāĻĒāĻžāϝāĻŧ āφāϛ⧇:

Volume āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ (āϏāĻŦāĻšā§‡āϝāĻŧ⧇ recommended):

# Volume āϤ⧈āϰāĻŋ āĻ•āϰ⧇ run āĻ•āϰ⧁āύ
docker run -d \
--name myapp \
-v myapp_data:/app/data \
myimage

Bind Mount āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ (development-āĻ āωāĻĒāϝ⧋āĻ—ā§€):

docker run -d \
--name myapp \
-v /host/path:/container/path \
myimage

Docker Compose-āĻ:

version: "3.8"

services:
db:
image: postgres
volumes:
- postgres_data:/var/lib/postgresql/data

volumes:
postgres_data:

What happens to data inside a container when it is removed?​

āĻāϟāĻŋ āύāĻŋāĻ°ā§āĻ­āϰ āĻ•āϰ⧇ data āϕ⧋āĻĨāĻžāϝāĻŧ āĻ›āĻŋāϞ āϤāĻžāϰ āωāĻĒāϰ:

Data āϕ⧋āĻĨāĻžāϝāĻŧ āĻ›āĻŋāϞContainer remove āĻšāϞ⧇ āϕ⧀ āĻšāϝāĻŧ
Container layer (volume āĻ›āĻžāĻĄāĻŧāĻž)āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧ
Named volumeāĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧ, volume āφāϞāĻžāĻĻāĻžāĻ­āĻžāĻŦ⧇ exist āĻ•āϰ⧇
Bind mountāĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧ, host filesystem-āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ
Anonymous volumeOrphaned āĻšāϝāĻŧ, manually cleanup āύāĻž āĻ•āϰāϞ⧇ disk āĻ­āϰ⧇ āϝāĻžāϝāĻŧ

āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ: docker rm -v āĻĻāĻŋāϞ⧇ container-āĻāϰ āϏāĻžāĻĨ⧇ anonymous volume-āĻ“ delete āĻšāϝāĻŧāĨ¤ Named volume āĻ•āĻ–āύ⧋ automatically delete āĻšāϝāĻŧ āύāĻžāĨ¤


How would you back up and restore a Docker volume?​

Backup āĻ•āϰāĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋ:

āĻāĻ•āϟāĻŋ temporary container āϤ⧈āϰāĻŋ āĻ•āϰ⧇ volume mount āĻ•āϰ⧁āύ, āϤāĻžāϰāĻĒāϰ tar āĻĻāĻŋāϝāĻŧ⧇ compress āĻ•āϰ⧁āύ:

docker run --rm \
-v myapp_data:/data \
-v $(pwd):/backup \
ubuntu \
tar czf /backup/myapp_backup.tar.gz -C /data .

āĻāχ command-āϟāĻŋ myapp_backup.tar.gz āύāĻžāĻŽā§‡ current directory-āϤ⧇ backup file āϤ⧈āϰāĻŋ āĻ•āϰāĻŦ⧇āĨ¤

Restore āĻ•āϰāĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋ:

# āĻĒā§āϰāĻĨāĻŽā§‡ āύāϤ⧁āύ volume āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ
docker volume create myapp_data_restored

# Backup āĻĨ⧇āϕ⧇ data restore āĻ•āϰ⧁āύ
docker run --rm \
-v myapp_data_restored:/data \
-v $(pwd):/backup \
ubuntu \
tar xzf /backup/myapp_backup.tar.gz -C /data

āĻ…āĻ¨ā§āϝ machine-āĻ migrate āĻ•āϰāϤ⧇:

# ā§§. Backup āύāĻŋāύ (āφāϗ⧇āϰ command)

# ⧍. File transfer āĻ•āϰ⧁āύ (scp āĻŦāĻž āĻ…āĻ¨ā§āϝ āωāĻĒāĻžāϝāĻŧ⧇)
scp myapp_backup.tar.gz user@remote-server:/path/

# ā§Š. Remote server-āĻ restore āĻ•āϰ⧁āύ
docker volume create myapp_data
docker run --rm \
-v myapp_data:/data \
-v /path:/backup \
ubuntu \
tar xzf /backup/myapp_backup.tar.gz -C /data

What is the difference between using volumes and writing to the container layer?​

Container layer āĻšāϞ⧋ container-āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ writable layer, āϝāĻž image-āĻāϰ āωāĻĒāϰ⧇ āĻĨāĻžāϕ⧇āĨ¤

āĻŦāĻŋāώāϝāĻŧVolumeContainer Layer
PersistenceContainer delete āĻšāϞ⧇āĻ“ āĻĨāĻžāϕ⧇Container delete āĻšāϞ⧇ āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧ
PerformanceNative disk speedCopy-on-Write (CoW) overhead āφāϛ⧇, āϤ⧁āϞāύāĻžāĻŽā§‚āϞāĻ• āϧ⧀āϰ
SharingāĻāĻ•āĻžāϧāĻŋāĻ• container share āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĻļ⧁āϧ⧁ āϐ container-āχ access āĻĒāĻžāϝāĻŧ
BackupāϏāĻšāϜāĻ•āĻ āĻŋāύ (docker export āϞāĻžāϗ⧇)
Image sizeImage āĻŦāĻĄāĻŧ āĻšāϝāĻŧ āύāĻžāĻŦāĻžāϰāĻŦāĻžāϰ write āĻ•āϰāϞ⧇ image layer āĻŦāĻĄāĻŧ āĻšāϝāĻŧ

āϕ⧇āύ Container Layer-āĻ āϞ⧇āĻ–āĻž āωāϚāĻŋāϤ āύāϝāĻŧ:

Docker image Copy-on-Write strategy āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ Container layer-āĻ āĻ•āĻŋāϛ⧁ āϞāĻŋāĻ–āϞ⧇ Docker āĻĒā§āϰāĻĨāĻŽā§‡ āĻĒ⧁āϰ⧋ file-āϟāĻŋ image layer āĻĨ⧇āϕ⧇ copy āĻ•āϰ⧇ āϤāĻžāϰāĻĒāϰ modify āĻ•āϰ⧇ — āĻāϟāĻŋ I/O intensive operation, āĻŦāĻŋāĻļ⧇āώāϤ database āĻŦāĻž large file-āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ significant performance hit āĻšāϝāĻŧāĨ¤

āύāĻŋāϝāĻŧāĻŽ: āϝ⧇āϕ⧋āύ⧋ data āϝāĻž persist āĻŦāĻž share āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āϏāĻŦāϏāĻŽāϝāĻŧ volume-āĻ āϰāĻžāϖ⧁āύāĨ¤


How do you manage volume permissions for non-root users inside containers?​

Container-āĻāϰ āϭ⧇āϤāϰ⧇ non-root user āĻĻāĻŋāϝāĻŧ⧇ āϚāĻžāϞāĻžāϞ⧇ volume-āĻāϰ directory-āϤ⧇ write permission āύāĻž āĻĨāĻžāĻ•āϞ⧇ "Permission denied" error āφāϏ⧇āĨ¤

āϏāĻŽāĻ¸ā§āϝāĻžāϰ āĻ•āĻžāϰāĻŖ:

Volume-āĻāϰ directory default-āĻ root owner āĻšāϝāĻŧāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ application non-root user āĻšāĻŋāϏ⧇āĻŦ⧇ āϚāϞāϞ⧇ āϏ⧇ write āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

āϏāĻŽāĻžāϧāĻžāύ ā§§ — Dockerfile-āĻ permission set āĻ•āϰ⧁āύ:

FROM node:18

# Non-root user āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ
RUN groupadd -r appgroup && useradd -r -g appgroup appuser

# Directory āϤ⧈āϰāĻŋ āĻ•āϰ⧇ ownership āĻĻāĻŋāύ
RUN mkdir -p /app/data && chown -R appuser:appgroup /app/data

# Non-root user āĻšāĻŋāϏ⧇āĻŦ⧇ switch āĻ•āϰ⧁āύ
USER appuser

WORKDIR /app
CMD ["node", "server.js"]

āϏāĻŽāĻžāϧāĻžāύ ⧍ — Entrypoint script āĻĻāĻŋāϝāĻŧ⧇ runtime-āĻ fix āĻ•āϰ⧁āύ:

#!/bin/sh
# entrypoint.sh

# Volume directory-āϰ ownership āĻ āĻŋāĻ• āĻ•āϰ⧁āύ
chown -R appuser:appgroup /app/data

# āĻāϰāĻĒāϰ non-root user āĻšāĻŋāϏ⧇āĻŦ⧇ app āϚāĻžāϞ⧁ āĻ•āϰ⧁āύ
exec su-exec appuser "$@"
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
CMD ["node", "server.js"]

āϏāĻŽāĻžāϧāĻžāύ ā§Š — docker run-āĻ user specify āĻ•āϰ⧁āύ:

# Host user-āĻāϰ UID āĻĻāĻŋāϝāĻŧ⧇ container āϚāĻžāϞāĻžāύ
docker run -d \
--user $(id -u):$(id -g) \
-v myapp_data:/app/data \
myimage

āϏāĻŽāĻžāϧāĻžāύ ā§Ē — Docker Compose-āĻ:

version: "3.8"

services:
app:
image: myimage
user: "1000:1000" # UID:GID
volumes:
- myapp_data:/app/data

volumes:
myapp_data:
driver: local
driver_opts:
o: uid=1000,gid=1000 # Volume-āĻāϰ default ownership

Best practice: Production-āĻ āĻ•āĻ–āύ⧋ root user āĻĻāĻŋāϝāĻŧ⧇ container āϚāĻžāϞāĻžāĻŦ⧇āύ āύāĻžāĨ¤ āϏāĻŦāϏāĻŽāϝāĻŧ dedicated non-root user āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ āĻāĻŦāĻ‚ Dockerfile-āĻāχ permission āĻ āĻŋāĻ• āĻ•āϰ⧁āύ — āĻāϟāĻŋ security āĻāĻŦāĻ‚ permission āωāĻ­āϝāĻŧ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰ⧇āĨ¤

âš™ī¸ 16. How do bind mounts work, and when should you use them?​

What is the risk of using bind mounts in production?​

How does a bind mount differ from a volume in terms of Docker management?​

How do you mount a configuration file from the host into a container?​