# Anonymous Volumes vs Named Volumes in Apple Container: Key Differences Explained > Confused by anonymous vs named volumes in Apple Container? Discover key differences, custom drivers, temporary storage, and cleanup needs. Understand your options now. - Repository: [Apple/container](https://github.com/apple/container) - Tags: deep-dive - Published: 2026-07-08 --- **Named volumes are explicitly created with user-defined identifiers and support custom driver options, while anonymous volumes are implicitly generated with UUID-based names for temporary storage and require manual cleanup.** Apple Container provides two distinct mechanisms for persisting data beyond a single container's lifecycle. Understanding the difference between **anonymous volumes vs named volumes** is essential for effective data management in containerized workflows. Both volume types are managed by the runtime's **volume manager** (`ContainerPersistence` layer), but they differ significantly in creation semantics, visibility, and lifecycle management. ## What Are Named Volumes? Named volumes are persistent storage objects that you explicitly create and identify with human-readable names. According to the source code in [`docs/command-reference.md`](https://github.com/apple/container/blob/main/docs/command-reference.md) (lines 862-874), you create these using the `container volume create ` command. Key characteristics include: - **Explicit creation**: You must run `container volume create ` or reference the name in a mount to trigger creation. - **Custom naming**: Use descriptive identifiers like `mydata` or `cache-vol` rather than system-generated strings. - **Driver options**: Accept configuration parameters such as `--opt size=10g` or `--opt journal=ordered` (lines 878-904). - **Long-term persistence**: Survive until explicitly removed via `container volume delete ` (lines 926-934). ## What Are Anonymous Volumes? Anonymous volumes provide ephemeral storage without requiring you to manage identifiers. As documented in [`docs/command-reference.md`](https://github.com/apple/container/blob/main/docs/command-reference.md) (lines 909-914), these are created implicitly when you specify a mount without a source path. Key characteristics include: - **Implicit creation**: Generated automatically with syntax like `-v /path` or `--mount type=volume,dst=/path`. - **System naming**: Assigned a UUID-based identifier in the format `anon-{36-char-uuid}` (lines 909-917). - **No configuration options**: Created with default driver settings; you cannot specify size or journaling modes. - **Manual cleanup required**: Despite being created automatically, they persist after container stops and are **not** removed when using `--rm` (lines 923-925). ## Architectural Differences Both volume types are implemented in [`Sources/ContainerPersistence/VolumeManager.swift`](https://github.com/apple/container/blob/main/Sources/ContainerPersistence/VolumeManager.swift). When you create a volume—whether named or anonymous—the runtime allocates a directory on the host filesystem under the storage root. **Named volumes** are registered in the metadata store with their human-chosen identifier. Because the name is stable, the same volume can be attached to multiple containers, and configuration metadata is retained across reboots. **Anonymous volumes** are allocated on demand with runtime-generated UUIDs to guarantee uniqueness. Since the name is not part of your manifest, the runtime does not automatically prune these volumes when the originating container is removed—preventing accidental data loss. Users must manually delete them or run `container volume prune` to clean up unused ones. ## Practical Usage Examples ### Creating and Using Named Volumes Named volumes support driver-specific options for advanced use cases like databases and long-term caches. ```bash # Create a named volume with a 5GiB size and ordered journaling container volume create -s 5g --opt journal=ordered mydata # Run a container mounting the named volume at /var/lib/app container run -v mydata:/var/lib/app alpine:3.22 ls /var/lib/app ``` ### Working with Anonymous Volumes Anonymous volumes suit temporary scratch space where you do not need human-readable identifiers, as demonstrated in [`Tests/IntegrationTests/Volumes/TestCLIAnonymousVolumes.swift`](https://github.com/apple/container/blob/main/Tests/IntegrationTests/Volumes/TestCLIAnonymousVolumes.swift). ```bash # Implicitly create an anonymous volume mounted at /tmp/data container run -v /tmp/data alpine:3.22 touch /tmp/data/file.txt # Retrieve the generated volume ID for reuse VOL=$(container volume list -q | grep anon) # Attach the same anonymous volume to a new container container run -v $VOL:/tmp/data alpine:3.22 cat /tmp/data/file.txt ``` ### Cleaning Up Both Volume Types Anonymous volumes require explicit deletion even if the originating container used `--rm`. ```bash # Remove a specific named volume container volume delete mydata # Remove an anonymous volume by its UUID container volume rm $VOL # Remove all unused volumes (both named and anonymous) container volume prune ``` ## Summary - **Named volumes** require explicit creation with `container volume create`, support custom driver options (`--opt size=10g`, `--opt journal=ordered`), and persist until manually deleted. - **Anonymous volumes** are implicitly created with `-v /path` or `--mount type=volume,dst=/path`, use UUID-based names (`anon-{36-char-uuid}`), and lack configuration options. - Both types survive container restarts, but only named volumes are directly manageable by human-readable identifiers. - Anonymous volumes are **not** automatically cleaned up when containers exit with `--rm`; you must run `container volume prune` or delete them individually with `container volume rm`. - The `VolumeManager` in `Sources/ContainerPersistence/` handles both types but treats named volumes as first-class persistent objects while managing anonymous volumes as temporary-but-durable scratch space. ## Frequently Asked Questions ### Will anonymous volumes be deleted automatically when I remove a container with `--rm`? No. According to [`docs/command-reference.md`](https://github.com/apple/container/blob/main/docs/command-reference.md) (lines 923-925), anonymous volumes persist after the container stops and are **not** removed by the `--rm` flag. This design prevents accidental data loss from implicit storage. You must delete them manually using `container volume rm ` or clean up all unused volumes with `container volume prune`. ### Can I convert an anonymous volume to a named volume? No direct conversion mechanism exists in the Apple Container codebase. However, you can identify the anonymous volume's UUID using `container volume list -q | grep anon`, back up the data, and restore it to a newly created named volume using `container volume create`. The [`Tests/IntegrationTests/Volumes/TestCLIAnonymousVolumes.swift`](https://github.com/apple/container/blob/main/Tests/IntegrationTests/Volumes/TestCLIAnonymousVolumes.swift) file demonstrates how to retrieve and reuse anonymous volume IDs for data persistence between containers. ### Why can't I specify size or journaling options for anonymous volumes? Anonymous volumes are designed as simple data stores with default driver settings, as documented in the command reference (lines 909-914). They intentionally lack the option payload supported by named volumes to keep their creation lightweight and transient. If you need specific storage characteristics like `size=10g` or `journal=ordered`, you must explicitly create a named volume using `container volume create --opt