README

Devmapper snapshotter

Devmapper is a containerd snapshotter plugin that stores snapshots in ext4-formatted filesystem images in a devicemapper thin pool.

Setup

To make it work you need to prepare thin-pool in advance and update containerd's configuration file. This file is typically located at /etc/containerd/config.toml.

Here's minimal sample entry that can be made in the configuration file:

[plugins]
  ...
  [plugins.devmapper]
    pool_name = "containerd-pool"
    base_image_size = "8192MB"
  ...

The following configuration flags are supported:

  • root_path - a directory where the metadata will be available (if empty default location for containerd plugins will be used)
  • pool_name - a name to use for the devicemapper thin pool. Pool name should be the same as in /dev/mapper/ directory
  • base_image_size - defines how much space to allocate when creating the base device
  • async_remove - flag to async remove device using snapshot GC's cleanup callback

Pool name and base image size are required snapshotter parameters.

Run

Give it a try with the following commands:

ctr images pull --snapshotter devmapper docker.io/library/hello-world:latest
ctr run --snapshotter devmapper docker.io/library/hello-world:latest test

Requirements

The devicemapper snapshotter requires dmsetup (>= 1.02.110) command line tool to be installed and available on your computer. On Ubuntu, it can be installed with apt-get install dmsetup command.

How to setup device mapper thin-pool

There are many ways how to configure a devmapper thin-pool depending on your requirements, disk configuration, and environment.

On local dev environment you can utilize loopback devices. This type of configuration is simple and suits well for development and testing (please note that this configuration is slow and not recommended for production uses). Run the following script to create a thin-pool device:

#!/bin/bash
set -ex

DATA_DIR=/var/lib/containerd/devmapper
POOL_NAME=devpool

mkdir -p ${DATA_DIR}

# Create data file
sudo touch "${DATA_DIR}/data"
sudo truncate -s 100G "${DATA_DIR}/data"

# Create metadata file
sudo touch "${DATA_DIR}/meta"
sudo truncate -s 10G "${DATA_DIR}/meta"

# Allocate loop devices
DATA_DEV=$(sudo losetup --find --show "${DATA_DIR}/data")
META_DEV=$(sudo losetup --find --show "${DATA_DIR}/meta")

# Define thin-pool parameters.
# See https://www.kernel.org/doc/Documentation/device-mapper/thin-provisioning.txt for details.
SECTOR_SIZE=512
DATA_SIZE="$(sudo blockdev --getsize64 -q ${DATA_DEV})"
LENGTH_IN_SECTORS=$(bc <<< "${DATA_SIZE}/${SECTOR_SIZE}")
DATA_BLOCK_SIZE=128
LOW_WATER_MARK=32768

# Create a thin-pool device
sudo dmsetup create "${POOL_NAME}" \
    --table "0 ${LENGTH_IN_SECTORS} thin-pool ${META_DEV} ${DATA_DEV} ${DATA_BLOCK_SIZE} ${LOW_WATER_MARK}"

cat << EOF
#
# Add this to your config.toml configuration file and restart containerd daemon
#
[plugins]
  [plugins.devmapper]
    pool_name = "${POOL_NAME}"
    root_path = "${DATA_DIR}"
    base_image_size = "10GB"
EOF

Use dmsetup to verify that the thin-pool created successfully:

sudo dmsetup ls
devpool	(253:0)

Once configured and restarted containerd, you'll see the following output:

INFO[2020-03-17T20:24:45.532604888Z] loading plugin "io.containerd.snapshotter.v1.devmapper"...  type=io.containerd.snapshotter.v1
INFO[2020-03-17T20:24:45.532672738Z] initializing pool device "dev-pool"

Another way to setup a thin-pool is via container-storage-setup tool (formerly known as docker-storage-setup). It is a script to configure CoW file systems like devicemapper:

#!/bin/bash
set -ex

# Block device to use for devmapper thin-pool
BLOCK_DEV=/dev/sdf
POOL_NAME=devpool
VG_NAME=containerd

# Install container-storage-setup tool
git clone https://github.com/projectatomic/container-storage-setup.git
cd container-storage-setup/
sudo make install-core
echo "Using version $(container-storage-setup -v)"

# Create configuration file
# Refer to `man container-storage-setup` to see available options
sudo tee /etc/sysconfig/docker-storage-setup <<EOF
DEVS=${BLOCK_DEV}
VG=${VG_NAME}
CONTAINER_THINPOOL=${POOL_NAME}
EOF

# Run the script
sudo container-storage-setup

cat << EOF
#
# Add this to your config.toml configuration file and restart containerd daemon
#
[plugins]
  [plugins.devmapper]
    pool_name = "${VG_NAME}-${POOL_NAME}"
    base_image_size = "10GB"
EOF

If successful container-storage-setup will output:

+ echo VG=containerd
+ sudo container-storage-setup
INFO: Volume group backing root filesystem could not be determined
INFO: Writing zeros to first 4MB of device /dev/xvdf
4+0 records in
4+0 records out
4194304 bytes (4.2 MB) copied, 0.0162906 s, 257 MB/s
INFO: Device node /dev/xvdf1 exists.
  Physical volume "/dev/xvdf1" successfully created.
  Volume group "containerd" successfully created
  Rounding up size to full physical extent 12.00 MiB
  Thin pool volume with chunk size 512.00 KiB can address at most 126.50 TiB of data.
  Logical volume "devpool" created.
  Logical volume containerd/devpool changed.
...

And dmsetup will produce the following output:

sudo dmsetup ls
containerd-devpool          (253:2)
containerd-devpool_tdata    (253:1)
containerd-devpool_tmeta    (253:0)
Expand ▾ Collapse ▴

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrNotFound represents an error returned when object not found in meta store
	ErrNotFound = errors.New("not found")
	// ErrAlreadyExists represents an error returned when object can't be duplicated in meta store
	ErrAlreadyExists = errors.New("object already exists")
)

Functions

This section is empty.

Types

type Config

type Config struct {
	// Device snapshotter root directory for metadata
	RootPath string `toml:"root_path"`

	// Name for 'thin-pool' device to be used by snapshotter (without /dev/mapper/ prefix)
	PoolName string `toml:"pool_name"`

	// Defines how much space to allocate when creating base image for container
	BaseImageSize      string `toml:"base_image_size"`
	BaseImageSizeBytes uint64 `toml:"-"`

	// Flag to async remove device using Cleanup() callback in snapshots GC
	AsyncRemove bool `toml:"async_remove"`
}

    Config represents device mapper configuration loaded from file. Size units can be specified in human-readable string format (like "32KIB", "32GB", "32Tb")

    func LoadConfig

    func LoadConfig(path string) (*Config, error)

      LoadConfig reads devmapper configuration file from disk in TOML format

      func (*Config) Validate

      func (c *Config) Validate() error

        Validate makes sure configuration fields are valid

        type DeviceInfo

        type DeviceInfo struct {
        	// DeviceID is a 24-bit number assigned to a device within thin-pool device
        	DeviceID uint32 `json:"device_id"`
        	// Size is a thin device size
        	Size uint64 `json:"size"`
        	// Name is a device name to be used in /dev/mapper/
        	Name string `json:"name"`
        	// ParentName is a name of parent device (if snapshot)
        	ParentName string `json:"parent_name"`
        	// State represents current device state
        	State DeviceState `json:"state"`
        	// Error details if device state change failed
        	Error string `json:"error"`
        }

          DeviceInfo represents metadata for thin device within thin-pool

          type DeviceInfoCallback

          type DeviceInfoCallback func(deviceInfo *DeviceInfo) error

            DeviceInfoCallback is a callback used for device updates

            type DeviceState

            type DeviceState int

              DeviceState represents current devmapper device state reflected in meta store

              const (
              	// Unknown means that device just allocated and no operations were performed
              	Unknown DeviceState = iota
              	// Creating means that device is going to be created
              	Creating
              	// Created means that devices successfully created
              	Created
              	// Activating means that device is going to be activated
              	Activating
              	// Activated means that device successfully activated
              	Activated
              	// Suspending means that device is going to be suspended
              	Suspending
              	// Suspended means that device successfully suspended
              	Suspended
              	// Resuming means that device is going to be resumed from suspended state
              	Resuming
              	// Resumed means that device successfully resumed
              	Resumed
              	// Deactivating means that device is going to be deactivated
              	Deactivating
              	// Deactivated means that device successfully deactivated
              	Deactivated
              	// Removing means that device is going to be removed
              	Removing
              	// Removed means that device successfully removed but not yet deleted from meta store
              	Removed
              	// Faulty means that the device is errored and the snapshotter failed to rollback it
              	Faulty
              )

              func (DeviceState) String

              func (s DeviceState) String() string

              type PoolDevice

              type PoolDevice struct {
              	// contains filtered or unexported fields
              }

                PoolDevice ties together data and metadata volumes, represents thin-pool and manages volumes, snapshots and device ids.

                func NewPoolDevice

                func NewPoolDevice(ctx context.Context, config *Config) (*PoolDevice, error)

                  NewPoolDevice creates new thin-pool from existing data and metadata volumes. If pool 'poolName' already exists, it'll be reloaded with new parameters.

                  func (*PoolDevice) Close

                  func (p *PoolDevice) Close() error

                    Close closes pool device (thin-pool will not be removed)

                    func (*PoolDevice) CreateSnapshotDevice

                    func (p *PoolDevice) CreateSnapshotDevice(ctx context.Context, deviceName string, snapshotName string, virtualSizeBytes uint64) (retErr error)

                      CreateSnapshotDevice creates and activates new thin-device from parent thin-device (makes snapshot)

                      func (*PoolDevice) CreateThinDevice

                      func (p *PoolDevice) CreateThinDevice(ctx context.Context, deviceName string, virtualSizeBytes uint64) (retErr error)

                        CreateThinDevice creates new devmapper thin-device with given name and size. Device ID for thin-device will be allocated from metadata store. If allocation successful, device will be activated with /dev/mapper/<deviceName>

                        func (*PoolDevice) DeactivateDevice

                        func (p *PoolDevice) DeactivateDevice(ctx context.Context, deviceName string, deferred, withForce bool) error

                          DeactivateDevice deactivates thin device

                          func (*PoolDevice) GetUsage

                          func (p *PoolDevice) GetUsage(deviceName string) (int64, error)

                            GetUsage reports total size in bytes consumed by a thin-device. It relies on the number of used blocks reported by 'dmsetup status'. The output looks like:

                            device2: 0 204800 thin 17280 204799
                            

                            Where 17280 is the number of used sectors

                            func (*PoolDevice) IsActivated

                            func (p *PoolDevice) IsActivated(deviceName string) bool

                              IsActivated returns true if thin-device is activated

                              func (*PoolDevice) IsLoaded

                              func (p *PoolDevice) IsLoaded(deviceName string) bool

                                IsLoaded returns true if thin-device is visible for dmsetup

                                func (*PoolDevice) MarkDeviceState

                                func (p *PoolDevice) MarkDeviceState(ctx context.Context, name string, state DeviceState) error

                                  MarkDeviceState changes the device's state in metastore

                                  func (*PoolDevice) RemoveDevice

                                  func (p *PoolDevice) RemoveDevice(ctx context.Context, deviceName string) error

                                    RemoveDevice completely wipes out thin device from thin-pool and frees it's device ID

                                    func (*PoolDevice) RemovePool

                                    func (p *PoolDevice) RemovePool(ctx context.Context) error

                                      RemovePool deactivates all child thin-devices and removes thin-pool device

                                      func (*PoolDevice) ResumeDevice

                                      func (p *PoolDevice) ResumeDevice(ctx context.Context, deviceName string) error

                                      func (*PoolDevice) SuspendDevice

                                      func (p *PoolDevice) SuspendDevice(ctx context.Context, deviceName string) error

                                        SuspendDevice flushes the outstanding IO and blocks the further IO

                                        func (*PoolDevice) WalkDevices

                                        func (p *PoolDevice) WalkDevices(ctx context.Context, cb func(info *DeviceInfo) error) error

                                          WalkDevices iterates all devices in pool metadata

                                          type PoolMetadata

                                          type PoolMetadata struct {
                                          	// contains filtered or unexported fields
                                          }

                                            PoolMetadata keeps device info for the given thin-pool device, it also responsible for generating next available device ids and tracking devmapper transaction numbers

                                            func NewPoolMetadata

                                            func NewPoolMetadata(dbfile string) (*PoolMetadata, error)

                                              NewPoolMetadata creates new or open existing pool metadata database

                                              func (*PoolMetadata) AddDevice

                                              func (m *PoolMetadata) AddDevice(ctx context.Context, info *DeviceInfo) error

                                                AddDevice saves device info to database.

                                                func (*PoolMetadata) ChangeDeviceState

                                                func (m *PoolMetadata) ChangeDeviceState(ctx context.Context, name string, state DeviceState) error

                                                  ChangeDeviceState changes the device state given the device name in devices bucket.

                                                  func (*PoolMetadata) Close

                                                  func (m *PoolMetadata) Close() error

                                                    Close closes metadata store

                                                    func (*PoolMetadata) GetDevice

                                                    func (m *PoolMetadata) GetDevice(ctx context.Context, name string) (*DeviceInfo, error)

                                                      GetDevice retrieves device info by name from database

                                                      func (*PoolMetadata) GetDeviceNames

                                                      func (m *PoolMetadata) GetDeviceNames(ctx context.Context) ([]string, error)

                                                        GetDeviceNames retrieves the list of device names currently stored in database

                                                        func (*PoolMetadata) MarkFaulty

                                                        func (m *PoolMetadata) MarkFaulty(ctx context.Context, name string) error

                                                          MarkFaulty marks the given device and corresponding devmapper device ID as faulty. The snapshotter might attempt to recreate a device in 'Faulty' state with another devmapper ID in subsequent calls, and in case of success it's status will be changed to 'Created' or 'Activated'. The devmapper dev ID will remain in 'deviceFaulty' state until manually handled by a user.

                                                          func (*PoolMetadata) RemoveDevice

                                                          func (m *PoolMetadata) RemoveDevice(ctx context.Context, name string) error

                                                            RemoveDevice removes device info from store.

                                                            func (*PoolMetadata) UpdateDevice

                                                            func (m *PoolMetadata) UpdateDevice(ctx context.Context, name string, fn DeviceInfoCallback) error

                                                              UpdateDevice updates device info in metadata store. The callback should be used to indicate whether device info update was successful or not. An error returned from the callback will rollback the update transaction in the database. Name and Device ID are not allowed to change.

                                                              func (*PoolMetadata) WalkDevices

                                                              func (m *PoolMetadata) WalkDevices(ctx context.Context, cb func(info *DeviceInfo) error) error

                                                                WalkDevices walks all devmapper devices in metadata store and invokes the callback with device info. The provided callback function must not modify the bucket.

                                                                type Snapshotter

                                                                type Snapshotter struct {
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  Snapshotter implements containerd's snapshotter (https://godoc.org/github.com/containerd/containerd/snapshots#Snapshotter) based on Linux device-mapper targets.

                                                                  func NewSnapshotter

                                                                  func NewSnapshotter(ctx context.Context, config *Config) (*Snapshotter, error)

                                                                    NewSnapshotter creates new device mapper snapshotter. Internally it creates thin-pool device (or reloads if it's already exists) and initializes a database file for metadata.

                                                                    func (*Snapshotter) Cleanup

                                                                    func (s *Snapshotter) Cleanup(ctx context.Context) error

                                                                    func (*Snapshotter) Close

                                                                    func (s *Snapshotter) Close() error

                                                                      Close releases devmapper snapshotter resources. All subsequent Close calls will be ignored.

                                                                      func (*Snapshotter) Commit

                                                                      func (s *Snapshotter) Commit(ctx context.Context, name, key string, opts ...snapshots.Opt) error

                                                                        Commit marks an active snapshot as committed in meta store. Block device unmount operation captures snapshot changes by itself, so no additional actions needed within Commit operation.

                                                                        func (*Snapshotter) Mounts

                                                                        func (s *Snapshotter) Mounts(ctx context.Context, key string) ([]mount.Mount, error)

                                                                          Mounts return the list of mounts for the active or view snapshot

                                                                          func (*Snapshotter) Prepare

                                                                          func (s *Snapshotter) Prepare(ctx context.Context, key, parent string, opts ...snapshots.Opt) ([]mount.Mount, error)

                                                                            Prepare creates thin device for an active snapshot identified by key

                                                                            func (*Snapshotter) Remove

                                                                            func (s *Snapshotter) Remove(ctx context.Context, key string) error

                                                                              Remove removes thin device and snapshot metadata by key

                                                                              func (*Snapshotter) ResetPool

                                                                              func (s *Snapshotter) ResetPool(ctx context.Context) error

                                                                                ResetPool deactivates and deletes all thin devices in thin-pool. Used for cleaning pool after benchmarking.

                                                                                func (*Snapshotter) Stat

                                                                                func (s *Snapshotter) Stat(ctx context.Context, key string) (snapshots.Info, error)

                                                                                  Stat returns the info for an active or committed snapshot from store

                                                                                  func (*Snapshotter) Update

                                                                                  func (s *Snapshotter) Update(ctx context.Context, info snapshots.Info, fieldpaths ...string) (snapshots.Info, error)

                                                                                    Update updates an existing snapshot info's data

                                                                                    func (*Snapshotter) Usage

                                                                                    func (s *Snapshotter) Usage(ctx context.Context, key string) (snapshots.Usage, error)

                                                                                      Usage returns the resource usage of an active or committed snapshot excluding the usage of parent snapshots.

                                                                                      func (*Snapshotter) View

                                                                                      func (s *Snapshotter) View(ctx context.Context, key, parent string, opts ...snapshots.Opt) ([]mount.Mount, error)

                                                                                        View creates readonly thin device for the given snapshot key

                                                                                        func (*Snapshotter) Walk

                                                                                        func (s *Snapshotter) Walk(ctx context.Context, fn snapshots.WalkFunc, fs ...string) error

                                                                                          Walk iterates through all metadata Info for the stored snapshots and calls the provided function for each.

                                                                                          Directories

                                                                                          Path Synopsis