Infinibay/lxd: LXD container to deploy infinibay in a containerized environment

LXD-based containerization for the Infinibay VDI management platform.

production ready – Automated provisioning with intelligent orchestration and multi-distro support

LXD provides native support for KVM/libvirt, making it ideal for running VMs inside containers without privileged mode or complex workarounds.

Main Benefits:

• ✅ Native KVM device access – No --privileged requires mod
• ✅ Full system support inside containers
• ✅ Designed for nested virtualization
• ✅ YAML-based configuration (lxd-compose)
• ✅ Better security isolation for VM workloads
• ✅ Minimal performance overhead (~5%)

Infinibay’s LXD deployment supports multiple Linux distributions with automatic package manager detection:

• Debian/Ubuntu – Use apt-get (automatically detected)
• RHEL/CentOS/Fedora/Rocky/AlmaLinux – Use dnf Or yum (automatically detected)
• openSUSE/SLES – Use zypper (automatically detected)
• Arch/Manjaro/EndeavorOS – Use pacman (automatically detected)

The setup script automatically detects your distribution and uses the appropriate package manager. The LXD installation path (Snap vs. native package) is also automatically detected.

This directory contains LXD-based containerization for use with Infinibay. lxd-write,

structure:

lxd/
├── run.sh                         # Main management script ⭐
├── .lxd-compose.yml               # Main lxd-compose config
├── envs/
│   └── infinibay.yml              # Infinibay project definition
├── profiles/
│   └── templates/                 # LXD profile templates
├── values.yml.example             # Configuration template
├── setup.sh                       # Automated installation
├── INSTALL.md                     # Complete guide
└── README.md                      # This file

Comment: lxd-compose uses a different structure than docker-compose:

• Main configuration: .lxd-compose.yml
• Projects: envs/*.yml files
• Order: apply infinibay, destroy infinibay, stop infinibay

The deployment creates 4 LXD containers:

1. infinibe-postgres – PostgreSQL Database
2. infinibe-redis – Redis Cache
3. infinibay-backend – Node.js API + libvirt-node + infiniservice + KVM access
4. infinibay-frontend – Next.js web interface

# 1. Clone repository and navigate to lxd directory
cd infinibay/lxd

# 2. Run setup (installs LXD, lxd-compose, detects package manager)
sudo ./setup.sh

# 3. IMPORTANT: Activate lxd group (REQUIRED!)
newgrp lxd
# This activates the group in your current session
# You need to do this after setup.sh adds you to the lxd group

# 4. Configure environment variables
# Option A: Edit the auto-generated .env (RECOMMENDED)
nano .env
# setup.sh already created .env with secure auto-generated passwords
# IMPORTANT: Change ADMIN_PASSWORD from auto-generated to your own!

# Option B: If you prefer to start from .env.example before setup.sh
# cp .env.example .env && nano .env
# Then run setup.sh, which will detect and preserve your .env

# 5. Deploy and start Infinibay (smart default - does everything!)
./run.sh
# This one command:
# - Creates containers if they don't exist
# - Starts containers if they're stopped
# - Provisions if not already done (installs PostgreSQL, Redis, Node.js, Rust, libvirt)
# - Shows access URLs when ready
# Takes 5-10 minutes on first run

# 6. Access Infinibay
# URLs will be displayed after ./run.sh completes
# Frontend: http://:3000
# Backend API: http://:4000

What happens:

• setup.sh – Installs LXD, lxd-compose, detects your distro and package manager, auto-detects LXD path, generates .env with secure password
• newgrp lxd , Necessary – LXD activates group permissions
• .env configuration , Important – Review and change ADMIN_PASSWORD (automatically generated passwords must be personalized!)
• ./run.sh – Intelligent orchestration: builds containers, provisions software, starts everything up
  • Checks if the environment exists → creates it if not
  • Checks if containers are running → starts when stopped
  • Checks if provisioned → provisioned if not (tracked via LXD metadata)
  • Automatically skips previously completed steps
• containers shared /opt/infinibay directory (your code)
• data exists /data Directories even if the container is destroyed

after running setup.shYou may need to activate lxd Group:

Option 1 (Quick – current session only):

Option 2 (permanent – ​​requires re-login):

logout
# Then login again

How to check if you are in a group:

groups | grep lxd
# Should show 'lxd' in the output

# One command does everything - creates, provisions, and starts
./run.sh              # Smart default - handles everything automatically

# Fresh start - destroy and recreate everything
./run.sh redo         # or: ./run.sh rd

# Quick status check
./run.sh status       # or: ./run.sh s

# Smart default workflow (recommended)
./run.sh              # Does everything: create → provision → start

# Manual step-by-step (if you prefer explicit control)
./run.sh apply        # Shortcuts: a, ap - Create containers
./run.sh provision    # Shortcuts: p, pr - Install software

# Container management
./run.sh status       # Shortcuts: s, st - Check status
./run.sh destroy      # Shortcuts: d, de - Remove containers
./run.sh redo         # Shortcut: rd - Destroy and recreate (fresh start)
./run.sh restart      # Shortcuts: r, re - Legacy alias for redo

# Execute commands in containers
./run.sh exec backend bash      # Shortcuts: e, ex
./run.sh exec postgres psql -U infinibay
./run.sh exec frontend npm run dev

# Follow container logs
./run.sh logs backend           # Shortcuts: l, lo
./run.sh logs postgres

# Update profiles only (after modifying templates)
./run.sh setup-profiles         # Shortcut: sp

# Show help with all shortcuts
./run.sh help

Full shortcut reference:

# View container status
sg lxd -c "lxc list"

# Execute commands
sg lxd -c "lxc exec infinibay-backend -- bash"

# Create snapshot
sg lxd -c "lxc snapshot infinibay-backend backup-$(date +%Y%m%d)"

# List snapshots
lxc info infinibay-backend

Implemented and implemented:

• ✅ Creates 4 Ubuntu containers with resource limits
• ✅ Mounts shared /opt/infinibay directory (your code)
• ✅ continuously /data Directories for each service
• ✅ Automated provisioning scripts for all containers
• ✅ PostgreSQL installation and configuration
• ✅ Redis installation and configuration
• ✅ Node.js 20.x LTS + npm
• ✅ Rust toolchain (for libvirt-node native modules)
• ✅ libvirt + KVM with /dev/kvm device access
• ✅ SystemD services are ready for backend/frontend
• Network connectivity between containers
• ✅ Universal package manager support (apt/dnf/zypper/pacman)
• ✅ Automatic LXD path detection (Snap vs native)
• ✅ Smart default orchestration with state tracking
• ✅ Provision of state persistence through LXD metadata

Still manual:

• ⏳ npm install in backend/frontend
• ⏳ Database Migration
• ⏳ Starting Infinibay Services
• ⏳ Application configuration

After provisioning, you must:

1. Install npm dependencies in backend/frontend
2. Run Database Migration
3. Configure and start Infinibay services

See INSTALL.md for detailed instructions.

# Make sure you specify the project name
lxd-compose apply infinibay  # ✓ Correct
lxd-compose apply             # ✗ Wrong

# You need to be in the lxd group
newgrp lxd
# Or logout/login

# Check if you're in lxd group
groups | grep lxd

# If not, the setup script should have added you
# Just run:
newgrp lxd

# Check individual container status
./run.sh status

# Use redo to start fresh (destroys and recreates everything)
./run.sh redo

# Option 1: Use redo command (destroys and recreates everything)
./run.sh redo

# Option 2: Manually clear provisioning state for specific container
lxc config unset infinibay-backend user.provisioned
lxc config unset infinibay-frontend user.provisioned
lxc config unset infinibay-postgres user.provisioned
lxc config unset infinibay-redis user.provisioned
# Then run: ./run.sh

Recommendation: Use the native installer for production deployment until LXD provisioning is complete.

See INSTALL.md for development workflow.

last update: 2025-11-21
Situation: production ready