Ubuntu upgrade: from version 24.04 LTS to 26.04 LTS

The distribution upgrade from Ubuntu 24.04 LTS (Noble Numbat) to Ubuntu 26.04 LTS (Resolute Raccoon) modernises the Linux server foundation in depth: Linux Kernel 7.0, the complete move to cgroup v2-only, the Rust-based security architecture with sudo-rs, and native rollback in APT 3.2.

The path runs through preparation, the upgrade itself, conflict resolution and post-configuration of modern server features.

💡 Prerequisite: Ubuntu only supports in-place upgrades between consecutive LTS releases. If the system is still on Ubuntu 22.04 LTS, complete the first hop first: Ubuntu upgrade: from version 22.04 LTS to 24.04 LTS.

⚠️ Upgrade availability: Canonical typically opens the automatic upgrade path for LTS systems with the first point release (Ubuntu 26.04.1 LTS in late summer 2026). Test the upgrade in a staging or VM environment first.

Fundamentals and new features in Ubuntu 26.04 LTS

The most important architecture changes


┌─────────────────────────────────────────────────────────────┐
│                  Ubuntu LTS release cycle                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Ubuntu 24.04 (Noble)            Ubuntu 26.04 (Resolute)   │
│   ├── Release: April 2024         ├── Release: April 2026   │
│   └── Support: until 2029         └── Support: until 2031   │
│                                                             │
│   Upgrade path:                                             │
│   24.04 LTS ──────────────────────────────────▶ 26.04 LTS   │
│                      (Hop 2: in-place)                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Core component comparison:

Component	Ubuntu 24.04 LTS (Noble)	Ubuntu 26.04 LTS (Resolute)	Meaning and breaking changes
Linux Kernel	6.8	7.0	Improved CPU schedulers, newer I/O drivers
Control Groups	cgroup v1 + v2	cgroup v2 only	cgroup v1 removed completely (Docker/container check required)
Sudo stack	sudo (C)	sudo-rs (Rust)	Memory-safe sudo implementation with native sudoers compatibility
Package manager	APT 2.9	APT 3.2	Built-in transaction history and rollback support
systemd	255	259	Extended log retention and service isolation
Python	3.12	3.13	JIT compiler options, strict venv isolation
Desktop / GUI	GNOME 46 (X11/Wayland)	GNOME 50 (Wayland-only)	X11 server removed as the session default

Upgrade preparation on Ubuntu 24.04

1. Baseline state and hardware prerequisites

Before you start, check the baseline of the 24.04 system:


# Confirm distribution and version
lsb_release -a

# RAM and disk space (at least 25 GB free on /)
free -h
df -h /

Preparation for cgroup v2 (breaking-change check):


# Check the current cgroup filesystem
stat -fc %T /sys/fs/cgroup/
# Expected output: cgroup2fs

⚠️ Watch older containers / Docker daemons: Because Ubuntu 26.04 no longer supports cgroup v1, container engines (Docker, Podman, containerd) must run versions that fully handle cgroup v2 (Docker 20.10+ or Docker CE 24+).

2. Create a complete system backup


#!/bin/bash
# backup_before_hop2.sh
set -euo pipefail

BACKUP_DIR="/backup/ubuntu24_to_26_$(date +%Y%m%d_%H%M%S)"
echo "=== Creating backup before 26.04 upgrade in: $BACKUP_DIR ==="

sudo mkdir -p "$BACKUP_DIR"
sudo cp -a /etc "$BACKUP_DIR/etc"
sudo cp -a /home "$BACKUP_DIR/home"
dpkg --get-selections > "$BACKUP_DIR/installed_packages_2404.txt"

echo "Backup complete:"
sudo du -sh "$BACKUP_DIR"

3. Update the existing 24.04 system


# Sync all package lists and run a full upgrade
sudo apt update
sudo apt full-upgrade -y

# Clean the system
sudo apt autoremove --purge -y
sudo apt autoclean

# Refresh Snap packages
sudo snap refresh

The upgrade process (24.04 → 26.04)

Start the upgrade in a protected session

On remote connections, use screen or tmux so the upgrade does not abort on a network drop.


# Start a screen session
screen -S resolute-upgrade

# Launch the upgrade
sudo do-release-upgrade


┌─────────────────────────────────────────────────────────────┐
│                 Release-upgrade sequence                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Analysis and package lists  [████░░░░░░] 10%            │
│     ├── Disable incompatible third-party PPAs               │
│     └── Switch to 26.04 repositories (resolute)             │
│                                                             │
│  2. Download and dependency tree [██████░░░░] 50%           │
│     └── Fetch packages for kernel 7.0, systemd 259          │
│                                                             │
│  3. Installation and migration  [████████░░] 80%            │
│     ├── Replace classic sudo with sudo-rs                   │
│     └── cgroup v2-only configuration adjustments            │
│                                                             │
│  4. Finish and reboot           [██████████] 100%           │
│     └── Restart into Ubuntu 26.04 LTS                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Once every package is installed and obsolete dependencies are gone, confirm the reboot:


sudo reboot

Validation and new core features

After the reboot, verify the successful installation:


# Check OS version and kernel 7.0
lsb_release -a
uname -r

# Inspect failed system services
systemctl --failed

# Check network and Netplan status
sudo netplan status
ip addr show

1. sudo-rs in practice

Ubuntu 26.04 ships the Rust-written implementation sudo-rs by default. It raises memory safety while leaving the syntax unchanged.


# Check version and status
sudo -V

# Check privileges (reads existing /etc/sudoers unchanged)
sudo -l

💡 Compatibility note: Existing /etc/sudoers and /etc/sudoers.d/* configurations remain valid 1:1. No changes to your aliases or privilege rules are required.

2. Use the APT 3.2 rollback function

A standout feature in Ubuntu 26.04 is native transaction history in APT 3.2.


# Show the history of recent package actions
sudo apt history

# Undo the last failed installation
sudo apt history undo last

# Roll back to a specific point in time
sudo apt history undo 2026-08-20

💡 Advantage in server operation: Failed package updates no longer mean hunting down and downgrading individual libraries by hand.

3. cgroup v2 and Docker optimisation

With cgroup v1 gone, you manage resource limits directly through systemd's v2 interface:


# Monitor resource use live
systemd-cgtop

# Configure a resource limit for a service (e.g. Nginx/SSH)
sudo systemctl set-property ssh.service MemoryMax=512M CPUQuota=50%

For Docker, make sure the cgroup2 driver is active (/etc/docker/daemon.json):


{
  "exec-opts": ["native.cgroupdriver=cgroup2"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}


sudo systemctl restart docker

Post-configuration and system hardening

1. Adjust SSH and firewall defaults


# Open the SSH configuration
sudo nano /etc/ssh/sshd_config

# Recommended security settings:
# PermitRootLogin no
# PasswordAuthentication no
# PubkeyAuthentication yes


# Check UFW firewall status and active ports
sudo ufw status verbose

2. System cleanup and log rotation


# Remove old kernel versions and orphaned packages
sudo apt autoremove --purge -y
sudo apt autoclean

# Cap systemd journal size (/etc/systemd/journald.conf)
sudo journalctl --vacuum-size=200M

Troubleshooting and emergency scenarios

Even with careful preparation, unexpected errors can appear during a major upgrade:

1. Interrupted upgrade process (Inconsistent State)

If the upgrade stops early:


# Unlock and configure package management
sudo dpkg --configure -a

# Automatically install missing dependencies
sudo apt install -f -y

# Audit package status
sudo dpkg --audit

2. Boot problems and emergency shell

If the system does not boot into the new kernel after the upgrade:


# 1. In the GRUB menu choose "Advanced Options" -> "Recovery Mode"
# 2. Select "Drop to root shell prompt"

# Mount the filesystem read-write
mount -o remount,rw /

# Check the journal for fatal boot errors
journalctl -xb -p err

# Reinstall the GRUB bootloader
update-grub

3. Python 3.13 and PEP 668 (externally-managed-environment)

If system-wide Python scripts fail after the upgrade:


# Recommended path: use your own virtual environment
python3 -m venv ~/my-environment
source ~/my-environment/bin/activate
pip install -r requirements.txt

# For CLI tools: use pipx
sudo apt install pipx
pipx install <package-name>

Long-term maintenance: automated updates and monitoring

To keep the Ubuntu 26.04 LTS system stable and secure over the next five years, enable automatic security updates:


# Set up unattended upgrades
sudo apt install unattended-upgrades apt-listchanges -y
sudo dpkg-reconfigure -plow unattended-upgrades

Automatic health check via cron job:

Create a monitoring script at /usr/local/bin/system_health.sh:


#!/bin/bash
# /usr/local/bin/system_health.sh
set -euo pipefail

LOG_FILE="/var/log/system_health.log"
DATE=$(date '+%Y-%m-%d %H:%M:%S')

echo "=== System Health Check - $DATE ===" >> "$LOG_FILE"

# Check disk utilisation
DISK_USAGE=$(df / | awk 'NR==2 {print $5}' | tr -d '%')
if [ "$DISK_USAGE" -gt 85 ]; then
    echo "WARNING: Disk ${DISK_USAGE}% full" >> "$LOG_FILE"
fi

# Check failed services
FAILED=$(systemctl --failed --no-legend | wc -l)
if [ "$FAILED" -gt 0 ]; then
    echo "WARNING: $FAILED failed systemd services!" >> "$LOG_FILE"
    systemctl --failed --no-legend >> "$LOG_FILE"
fi

echo "=== Status: OK ===" >> "$LOG_FILE"

Make the script executable:


sudo chmod +x /usr/local/bin/system_health.sh

Conclusion

The upgrade from Ubuntu 24.04 LTS to 26.04 LTS brings significant security and architecture improvements: modern Linux kernel 7.0, the memory-safe sudo-rs implementation and native rollback in APT 3.2 put the platform on the current enterprise baseline.

What decides a smooth transition is a careful pre-check of cgroup-v2 dependencies (especially with container workloads), running the upgrade in a stable screen session, and cleaning orphaned kernels and packages afterwards.