Learn LXC - Storage: Rootfs, Images & Snapshots

#Introduction

In episode 7 your container has resource limits. Now the next question: where does the container live? In episode 8 we break down LXC storage — from the backends that determine how the rootfs is stored, to the images that are the source of new containers. The backend decision here determines speed, disk usage, and how efficient your snapshots will be later (episode 9).

#Storage Backends

LXC supports several backends for storing container rootfs. Each has a different philosophy:

#dir (Directory)

The simplest backend and the default: the rootfs is just a regular directory at /var/lib/lxc/<name>/rootfs. Easy to back up (just cp -a), but no native snapshot support — every snapshot is a full copy.

Check the c1 container backend

grep lxc.rootfs.path /var/lib/lxc/c1/config

An output of dir:/var/lib/lxc/c1/rootfs indicates the dir backend.

#btrfs and ZFS (Filesystems with Native Snapshots)

Both filesystems have built-in snapshots that are nearly instant and disk-efficient (copy-on-write). If the LXC rootfs sits on a btrfs/zfs volume, lxc-snapshot uses its native mechanism — snapshots become cheap, fast, and nestable. This is the best choice for homelabs and snapshot-intensive production.

#LVM (Logical Volume Manager)

With LVM, each container is its own logical volume. LVM snapshots are also native, but usually single (not nested) and require careful volume management. Suitable for environments that already use LVM as their storage standard.

#Loop

The loop backend uses a disk image file that's loop-mounted as a filesystem. Flexible for experiments and portability, but with lower performance, and snapshots depend on the filesystem inside.

#Choosing a Backend at Create Time

The backend is chosen via --bdev and the filesystem via --fstype:

Create a container with dir backend

lxc-create -n c2 -B dir -t download -- -d debian -r bookworm -a amd64

Create a container on a btrfs volume (native snapshot)

lxc-create -n c3 -B btrfs -t download -- -d ubuntu -r 24.04 -a amd64

-B bdev / --bdev <type> — choose the backend (dir, btrfs, zfs, lvm, loop).
--fstype <fs> — the filesystem inside (e.g. ext4 for loop/LVM, btrfs for the btrfs backend).

Tip

The backend can't be casually changed once a container is created. Before deciding, ask first: how often will you snapshot (btrfs/zfs), is your storage already standardized on LVM, or do you just want simple and portable (dir)? This decision is cheap now, expensive if changed later.

#Images: The Source of New Containers

#The download Template

The download template fetches images from the official linuxcontainers.org image server. These images can be thought of as "base images" — minimal rootfs ready to be customized. The most flexible way to choose:

List available images

lxc-create -n placeholder -t download -- --list

The selected image can be a specific release (e.g. Ubuntu 24.04, Debian bookworm) and architecture (amd64, arm64).

#lxc-copy: Cloning Containers

lxc-copy creates a new container from an existing one — like copying a template. It's faster than re-downloading an image. Basic example:

Clone c1 into c4

lxc-copy -n c1 -N c4

The difference between a full copy and a snapshot clone will be covered in episode 9.

#lxc-snapshot: Freezing a State

lxc-snapshot saves a container's state at a point in time, so you can go back (rollback) if something breaks:

Take a snapshot of c1

lxc-snapshot -n c1

With the dir backend, this snapshot is a full copy; with btrfs/zfs, it uses the native snapshot that's nearly instant.

Note

Key concept: an image is a source for creating new containers, while a snapshot is a recording of an existing container's state. Images point forward (scale out), snapshots point backward (rollback). Episode 9 will dive into snapshots and clones specifically.

#Viewing Disk Usage

Monitor how much storage each container uses:

Size of each container rootfs

du -sh /var/lib/lxc/*/rootfs

If you use ZFS, use zfs list -t all to see volumes and their snapshots:

View ZFS datasets and snapshots

zfs list -t all | grep -E "lxc|containers"

#Closing

Key takeaways:

Storage backends: dir (simple), btrfs/zfs (native snapshots), LVM (volume-based), and loop (disk image file).
lxc-create -B <bdev> --fstype <fs> determines how the rootfs is stored.
The download template fetches images from the official image server.
lxc-copy creates new containers from existing ones; lxc-snapshot records a state for rollback.
The backend determines snapshot efficiency — choose from the start based on your needs.

In the next episode 9 we'll focus on snapshots & clones — lxc-snapshot -n c1 -L to list snapshots, lxc-copy -n c1 -N c2 for a full copy, and -s for a disk-efficient snapshot clone. This is the most valuable skill for homelab and production operations.