Lightweight Virtualization: Using LXD/LXC on Ubuntu

Introduction

As modern infrastructure demands agility, efficiency, and rapid provisioning, traditional virtualization solutions can become cumbersome. Lightweight virtualization – known also as operating-system-level virtualization – provides a streamlined alternative. LXC (Linux Containers) and its more advanced sibling LXD have emerged as powerful tools for deploying and managing containers on Ubuntu. This article dives deep into their architecture, installation, networking, storage, security, orchestration, and best practices.

1. Fundamentals of OS-Level Virtualization

Operating-system-level virtualization differs from full virtualization (e.g., KVM, VMware) by sharing the host kernel across isolated environments:

Namespaces: Isolate processes, users, network, mounts, IPC, UTS.
Control Groups (cgroups): Enforce resource limits (CPU, memory, I/O).
Chroots / UnionFS: Provide root filesystem isolation and layered storage.

These primitives combine to yield lightweight containers — minimal overhead, near-native performance, and rapid startup times.

2. LXC vs LXD: Understanding the Stack

Feature	LXC	LXD
Scope	Low-level container tools (API CLI)	Container hypervisor with REST API, clustering
CLI	lxc-start, lxc-attach, lxc-stop	lxc (unified commands)
API	Language bindings (Python, Go)	REST over UNIX socket / HTTPS
Clustering	Not built-in	Native multi-node clustering
Image Management	Manual import	Built-in remote image import

3. Installing LXD on Ubuntu

Update package index:
```
sudo apt update
```
Install snapd if not present:
```
sudo apt install snapd
```
Install LXD via Snap:
```
sudo snap install lxd
```
Initialize the LXD daemon:
```
sudo lxd init
```

The interactive lxd init prompts for storage backend (ZFS, directory, btrfs), network bridge, and cluster configuration. Accept sensible defaults or tailor to your environment.

4. Basic Container Lifecycle

Launch:
```
lxc launch ubuntu:22.04 my-container
```
List:
```
lxc list
```
Execute a command:
```
lxc exec my-container -- bash
```

Stop / Start / Restart:

lxc stop my-container
lxc start my-container

Delete:
```
lxc delete my-container
```

5. Networking Models

LXD offers versatile networking:

Bridge (lxdbr0): Default NAT-based network for containers.
Macvlan: Containers appear as physical NICs on LAN.
IPvlan: Similar to macvlan but at Layer 3.
Fan: Overlay network for cloud-scale clustering.

Example: Creating a new bridge:

lxc network create my-bridge ipv4.address=10.0.5.1/24 ipv4.nat=true ipv6.address=none

6. Storage Backends and Management

LXD supports multiple storage drivers:

ZFS: Snapshots, thin provisioning, compression.
Btrfs: Copy-on-write, subvolumes, quotas.
LVM: Logical volumes, snapshots.
Directory: Simple, no advanced features.

To add a storage pool:

lxc storage create data-pool zfs size=100GB

7. Security and Isolation

Containers by default offer strong isolation, but extra measures are recommended:

AppArmor / Seccomp: Fine-grained syscall filtering.
Unprivileged Containers: Map container root to non-root host UID/GID.
Resource Limits: Set CPU, memory quotas via profiles.
Network Policies: Use ebtables/iptables to restrict traffic.

8. Clustering and Orchestration

LXD can form clusters of multiple Ubuntu hosts, offering:

Centralized control plane: Single lxc CLI/REST endpoint.
Live migration: Move containers without downtime.
Distributed storage replication: ZFS pools across nodes.
Group scheduling: Placement policies.

To add a node:

lxc cluster add ubuntu-node2

9. Backup, Restore, and Migration

Container snapshots serve as checkpoints. To snapshot:

lxc snapshot my-container snap1

To export/import:

lxc export my-container ./backup.tar.gz
lxc image import ./backup.tar.gz --alias backup-image

Migration example:

lxc move my-container target-node:

10. Monitoring and Logging

lxc info: Real-time container metrics.
Prometheus Grafana: Export LXD metrics via lxd-prometheus.
Centralized Logging: Forward container logs to rsyslog or ELK stack.

11. Use Cases and Best Practices

Common scenarios for LXD/LXC on Ubuntu:

Dev/Test Environments: Rapid spin-up of clean OS instances.
Microservices: Isolate single-purpose services with minimal overhead.
CI/CD Pipelines: Ephemeral builders matching production OS.
Edge Computing: Run containers on resource constrained IoT gateways.

Best practices:

Automate with cloud-init user-data for consistent provisioning.
Version images and maintain an internal image server.
Regularly prune unused images and snapshots to save storage.
Define reusable profiles for resource limits, devices, and networks.

Conclusion

LXD and LXC deliver high-performance, lightweight virtualization tailored for Linux. By leveraging namespaces, cgroups, and modern storage backends on Ubuntu, administrators and developers achieve rapid, secure, and scalable container deployments. Whether for microservices, CI/CD, or clustered infrastructure, this stack provides the tools and flexibility needed in today’s fast-paced IT landscape.

For further reading:

LINUXMIND.DEV

Lightweight Virtualization: Using LXD/LXC on Ubuntu