---
id: 2026-04-25-ubuntu-upgrade-from-24-04-lts-to-26-04-lts
slug: ubuntu-upgrade-from-24-04-lts-to-26-04-lts
title: "Ubuntu upgrade: from version 24.04 LTS to 26.04 LTS"
excerpt: "Step-by-step upgrade from Ubuntu 24.04 LTS (Noble Numbat) to 26.04 LTS (Resolute Raccoon) — including cgroup v2, sudo-rs and APT 3.2 rollback."
date: "2026-04-25 00:00:00"
updated: "2026-04-25 00:00:00"
author:
  name: "Sebastian Palencsár"
  handle: "spalencsar"
category: "server-environments"
tags: ["ubuntu", "ubuntu2404", "ubuntu2604", "upgrade", "linux", "server", "lts", "resolute-raccoon"]
reading_time: 25
toc: true
---

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.

<blockquote class="infobox infobox--info">
💡 **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](/en/server-environments/ubuntu-upgrade-from-22-04-lts-to-24-04-lts){.badge-link-text}.
</blockquote>

<blockquote class="infobox infobox--warn">
⚠️ **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.
</blockquote>

## Fundamentals and new features in Ubuntu 26.04 LTS

### The most important architecture changes

```markdown
┌─────────────────────────────────────────────────────────────┐
│                  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:

```bash
# 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):**

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

<blockquote class="infobox infobox--warn">
⚠️ **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+).
</blockquote>

### 2. Create a complete system backup

```bash
#!/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

```bash
# 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.

```bash
# Start a screen session
screen -S resolute-upgrade

# Launch the upgrade
sudo do-release-upgrade
```

```markdown
┌─────────────────────────────────────────────────────────────┐
│                 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:

```bash
sudo reboot
```

## Validation and new core features

After the reboot, verify the successful installation:

```bash
# 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.

```bash
# Check version and status
sudo -V

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

<blockquote class="infobox infobox--info">
💡 **Compatibility note:** Existing `/etc/sudoers` and `/etc/sudoers.d/*` configurations remain valid 1:1. No changes to your aliases or privilege rules are required.
</blockquote>

### 2. Use the APT 3.2 rollback function

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

```bash
# 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
```

<blockquote class="infobox infobox--info">
💡 **Advantage in server operation:** Failed package updates no longer mean hunting down and downgrading individual libraries by hand.
</blockquote>

### 3. cgroup v2 and Docker optimisation

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

```bash
# 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`):

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

```bash
sudo systemctl restart docker
```

## Post-configuration and system hardening

### 1. Adjust SSH and firewall defaults

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

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

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

### 2. System cleanup and log rotation

```bash
# 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:

```bash
# 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:

```bash
# 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:

```bash
# 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:

```bash
# 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`:

```bash
#!/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:**

```bash
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.

## Further Resources

- [Linux server hardening: SSH with FIDO2 and CrowdSec](/en/server-environments/linux-server-hardening-fido2-crowdsec){.badge-link-text}
- [Part 1: Ubuntu upgrade from 22.04 to 24.04 LTS](/en/server-environments/ubuntu-upgrade-from-22-04-lts-to-24-04-lts){.badge-link-text}
- [LPIC-1 series: Linux fundamentals](/en/category/lpic-1-serie){.badge-link-text}
- [Docker and Docker Compose on Linux](/en/server-environments/how-to-install-docker-and-docker-compose-on-almalinux){.badge-link-text}
- [Ubuntu server environments](/en/category/server-environments){.badge-link-text}
