Container Storage
Container storage provides persistent data access for stateful containerized workloads. It covers volume types, storage drivers, CSI plugins, and the strategies for attaching durable storage to containers whose processes are otherwise ephemeral.
itVirtualization, containers, and orchestration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Container Storage
A container filesystem looks like one ordinary tree of files, which is a useful illusion right up to the point where something important vanishes. The tree begins with image layers, gains a private writable layer when the container starts, and can have selected paths replaced by mounts. One view, several lifecycles. This is less mystical than it sounds, although the filesystem does make a decent job of wearing a false moustache.
The writable layer is the first trap. It is where new files and changed image files appear, and it belongs to one container. Remove that container and the layer goes with it. That is excellent for rebuildable cache and temporary extraction. It is a poor retirement plan for database files, uploads, or the only copy of anything that would make tomorrow unnecessarily exciting.
A volume gives a chosen path a life separate from the container. Replace the container, attach the same volume, and the data can remain. A bind mount instead shows the container an exact path from the daemon host. Use that when the host and container genuinely need the same files, not because a host directory feels more familiar. A tmpfs mount keeps temporary files in memory while the container runs, then removes them when it stops. Each choice answers a different question about what should survive.
The surprise is that persistence is only one question. A volume can outlive a container and still be full, inaccessible to the container user, absent on another host, or unrecoverable after the wrong deletion. A shared mount also does not make simultaneous writes safe. Storage has a talent for remaining technically present while being operationally useless.
Start with the Course tab when you need the full model of layers, mounts, and failure behavior. The Cheatsheet is the fast map for destinations, lifecycle rules, and operational tests. Use the Practice tab to replace a container on purpose and observe what remains. Then follow the Reference tab into orchestrator storage, where scheduling, attachment, topology, and recovery add several more moving parts, because apparently one filesystem was not enough.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://docs.docker.com/engine/storage/
Supports
- Container writable-layer lifecycle and uniqueness
- Volume, bind-mount, and tmpfs categories
- Mounted paths as files or directories inside the container filesystem
- https://docs.docker.com/engine/storage/volumes/
Supports
- Engine-managed volume lifecycle and use cases
- Named and anonymous volume behavior
- Destination masking and empty-volume population
- Sharing, backup, restore, and migration guidance
- https://docs.docker.com/engine/storage/bind-mounts/
Supports
- Host-path mapping and common use cases
- Destination masking and daemon-host scope
- Default write access, read-only mode, security impact, and host coupling
- https://docs.docker.com/engine/storage/tmpfs/
Supports
- Linux memory-backed temporary mount lifecycle
- Nonpersistent use cases, size options, and swap caveat
- https://docs.docker.com/engine/storage/drivers/
Supports
- Storage-driver role for image and writable layers
- Stackable layers and copy-on-write behavior
- Writable-layer performance and disk-usage considerations
- https://docs.kernel.org/filesystems/overlayfs.html
Supports
- Upper and lower filesystem composition
- Copy-up behavior, whiteouts, and merged directories
- Overlay filesystem durability and permission mechanics
- https://github.com/opencontainers/runtime-spec/blob/main/config.md
Supports
- Container root filesystem configuration
- Read-only root behavior
- Additional mount fields and ordering
- https://github.com/opencontainers/image-spec/blob/main/layer.md
Supports
- Image layers as filesystem changesets
- Ordered additions, modifications, removals, and whiteouts
- https://kubernetes.io/docs/concepts/storage/
Supports
- Cluster storage learning path
- Kubernetes volumes, persistent volumes, claims, storage classes, and dynamic provisioning
- https://www.docker.com/blog/docker-0-1-release/
Supports
- Docker 0.1 release in 2013
- https://www.docker.com/blog/docker-1-0/
Supports
- Docker 1.0 release in 2014
- https://www.docker.com/blog/announcing-docker-1-9/
Supports
- Docker 1.9 named volumes and volume plugins
- https://opencontainers.org/about/overview/
Supports
- Open Container Initiative launch in 2015
- https://opencontainers.org/posts/announcements/2017-07-17-open-container-initiative-oci-releases-v1-0-of-container-standards/
Supports
- OCI Runtime and Image Specification 1.0 release in 2017
- https://kubernetes.io/blog/2018/01/12/container-storage-interface-beta/
Supports
- Kubernetes Container Storage Interface beta in 2018
- https://kubernetes.io/blog/2019/01/15/container-storage-interface-ga/
Supports
- Kubernetes Container Storage Interface general availability in 2019
- https://opencontainers.org/posts/blog/2024-03-13-image-and-distribution-1-1/
Supports
- OCI Image and Distribution Specification 1.1 release in 2024
- https://docs.podman.io/en/latest/markdown/podman-run.1.html
Supports
- Podman bind, volume, and tmpfs mount behavior
- https://containerd.io/
Supports
- containerd runtime distribution
- https://longhorn.io/docs/
Supports
- Longhorn distributed block storage for Kubernetes
- https://docs.portworx.com/
Supports
- Portworx Kubernetes storage platform documentation
- https://rook.io/docs/
Supports
- Rook storage orchestration documentation
