How to Upgrade Oracle Linux 7.9 to 8.10 Using LEAPP

Oracle Linux 7.9 reached end of support on July 1, 2024. Systems running OL7.9 no longer receive security patches, bug fixes, or critical updates—a significant risk for any infrastructure handling data or running production applications. For organizations still running OL7.9, the window to upgrade is narrowing.

Oracle Linux 8.10 provides extended support through 2029, modern kernel features, improved performance, and compatibility with current cloud-native tools and applications. Moving from OL7.9 to OL8.10 is a major version upgrade, which means significant package changes, kernel updates, and configuration migrations.

This is where LEAPP comes in. LEAPP (Lightweight Application Experience Preservation) is Red Hat's enterprise-grade tool specifically designed to handle major OS version migrations. Unlike simpler upgrade methods, LEAPP performs exhaustive pre-flight analysis, identifies compatibility issues before they become problems, guides you through remediation, and provides detailed reporting throughout the process.

This guide walks through the complete LEAPP upgrade journey from OL7.9 to OL8.10: understanding what LEAPP does, preparing your system, analyzing compatibility, fixing problems, executing the upgrade, and verifying success. By the end, you'll have a modern, supported Oracle Linux 8.10 system.

Your upgrade path: OL7.9 → OL8.10 (via LEAPP) → Install MySQL 8.4 LTS. This guide covers the full direct upgrade to OL8.10.

Understanding LEAPP and Why It Matters

Before diving into the technical steps, it's important to understand what LEAPP does and why using it matters for a major OS upgrade.

What is LEAPP?

LEAPP is a framework developed by Red Hat (which Oracle Linux is based on) for automating OS upgrades. It's not a simple package manager upgrade—it's an intelligent system that:

• Scans your entire system (packages, configurations, modules, services)
• Identifies compatibility issues before the upgrade
• Reports risks and blocking issues
• Guides you through remediation
• Performs the actual upgrade in a controlled boot environment
• Logs every change for audit purposes

Why not just upgrade packages directly?

You might think you could just run yum update to upgrade from OL7 to OL8, but this approach fails because:

• Kernel versions change significantly (3.x to 5.x)
• Package names and versions change dramatically
• Configuration file formats change
• Systemd behavior differs
• Dependency trees are completely different
• Third-party packages may be incompatible

Without LEAPP's analysis, you'd discover these problems during or after the upgrade—potentially leaving your system broken or unstable.

Why use LEAPP instead of a clean install?

For small systems, a clean install of OL8 is always preferable—safer, cleaner, more predictable. But for systems with:

• Extensive custom configurations
• Applications tightly integrated with the OS
• Specific package versions and dependencies
• Complex network or storage setups
• Automation and deployment complexity

A clean install would require rebuilding everything from scratch. LEAPP preserves your existing system while safely migrating it to a new major version.

Table of Contents

1. Assumptions and Prerequisites
2. Understanding Your System
3. Basic Prerequisites and Checks
4. Step 1: Install LEAPP
5. Step 2: Run Pre-Upgrade Analysis
6. Step 3: Understanding the LEAPP Report
7. Step 4: Answer LEAPP Questions
8. Step 5: Remediate Blocking Issues
9. Step 6: Execute the Upgrade
10. Step 7: Post-Upgrade Verification
11. Troubleshooting Common Issues
12. Next Steps in Your Upgrade Journey

Assumptions and Prerequisites

Before proceeding with LEAPP, understand these critical assumptions:

System assumptions:

• You have an existing Oracle Linux 7.9 installation (not earlier OL7 versions)
• You have complete, tested backups of your system that you can restore if needed
• You have direct console or IPMI access to your server during the upgrade
• You understand that while LEAPP is designed to be safe, upgrades carry inherent risk
• You're prepared for system downtime (the upgrade process takes 1–3 hours total)

When to use LEAPP vs. alternatives:

If you have the option and time, a clean OL8 installation is always safer. However, LEAPP is the right choice when:

• Your system has months or years of custom configurations
• Rebuilding the system from scratch would be more complex than upgrading
• You need to preserve specific application deployments and settings
• Your team's automation and orchestration depends on the existing setup
• Minimal downtime is preferred over complete reconfiguration

Official documentation:

This guide follows the Oracle Base article's proven methodology but adds context and explanation. For comprehensive prerequisites and edge cases, always consult the official Oracle LEAPP documentation.

Understanding Your System

Before running LEAPP, take time to document your current system state. This serves two purposes:

1. Baseline for comparison: After the upgrade, you can verify what changed
2. Reference if problems occur: You have a record of your pre-upgrade configuration

Create a system inventory:

# Document installed packages
rpm -qa > /tmp/ol7-packages-before.txt

# Document services
systemctl list-units --type=service --state=running > /tmp/ol7-services-before.txt

# Document network configuration
ip addr show > /tmp/ol7-network-before.txt
ip route show >> /tmp/ol7-network-before.txt

# Document kernel information
uname -a > /tmp/ol7-kernel-before.txt

# Document SELinux status (if applicable)
getenforce > /tmp/ol7-selinux-before.txt

Document custom configurations:

• Where is your application data stored?
• Are there custom systemd services running?
• Are there third-party repositories configured?
• Are there custom firewall rules (iptables or firewalld)?
• Are there NFS/CIFS mounts or other network filesystems?

Basic Prerequisites and Checks

Before installing LEAPP, verify your system meets basic requirements.

Check locale setting:

$ cat /etc/locale.conf
LANG="en_US.UTF-8"

If different or missing, set it explicitly:

echo 'LANG="en_US.UTF-8"' > /etc/locale.conf

For KVM hypervisors:

virsh list --all
virsh shutdown vm-name
virsh destroy vm-name

Enable root SSH login:

vi /etc/ssh/sshd_config

PermitRootLogin yes

systemctl restart sshd

Step 1: Install LEAPP

Install with repository access:

yum install -y leapp-upgrade --enablerepo=ol7_leapp,ol7_latest

Update the entire system:

yum update -y

Reboot after updates:

reboot

Verify LEAPP installation:

$ leapp --version
leapp version 15.0.x

Step 2: Run Pre-Upgrade Analysis

Now LEAPP scans your system to identify compatibility issues. This is the critical step that prevents upgrade disasters.

Run the pre-upgrade analysis:

leapp preupgrade --oraclelinux

(If your system is on OCI cloud, use leapp preupgrade --oci instead.)

This command:

• Scans all installed packages
• Checks system configurations
• Identifies kernel modules
• Analyzes services and dependencies
• Compares against OL8.10 compatibility database
• Generates detailed report

The process takes 5–15 minutes depending on system size and complexity.

Review generated files:

cd /var/log/leapp
ls -la

Key files:

• leapp-report.txt — Human-readable summary of findings
• leapp-report.json — Machine-readable format (for automation)
• answerfile — Configuration questions LEAPP needs answered
• leapp-preupgrade.log — Detailed technical log
• archive/ — Contains additional diagnostic information

Read the report immediately:

cat /var/log/leapp/leapp-report.txt

This is the most important output. It tells you:

• What blocking issues prevent the upgrade (inhibitors)
• What could cause problems (warnings)
• What will change (informational messages)

Step 3: Understanding the LEAPP Report

The LEAPP report uses severity levels. Understanding them is critical to successful remediation.

Inhibitors (Critical - Must Fix)

These are absolute blockers. LEAPP will refuse to proceed if any inhibitors exist. Examples:

• "Package X is not available in OL8.10 repositories"
• "Custom kernel module Y is incompatible with OL8.10 kernel"
• "Configuration file Z uses deprecated syntax"

You must resolve every inhibitor. This might mean:

• Removing unsupported packages
• Unloading custom kernel modules
• Updating configuration files to new format
• Finding OL8.10-compatible alternatives

Errors (Serious - Should Address)

These are serious but not absolute blockers. Examples:

• "Package will be removed during upgrade"
• "Configuration file will be replaced"
• "Service behavior will change"

Warnings (Informational - Review)

Potential issues that might affect you. Examples:

• "Third-party repository might not have OL8.10 packages"
• "Custom service might need reconfiguration"

Review warnings but they often don't require pre-upgrade action.

Informational (FYI - No Action Needed)

Messages about changes that will happen. These are for awareness only.

Step 4: Answer LEAPP Questions

Some upgrades require you to answer configuration questions. LEAPP presents these in the answerfile.

Identify unanswered questions:

cat /var/log/leapp/answerfile

Look for sections with questions and value: null or empty values.

Answer via command line:

leapp answer --section remove_pam_pkcs11_module_check.confirm=True

Format: leapp answer --section {section-name}.{question-key}={your-answer}

Answer by editing the file:

vi /var/log/leapp/answerfile

Find the relevant section, set the value, save, and exit.

Re-run analysis to confirm:

leapp preupgrade --oraclelinux

The report should reflect your answers and show fewer issues.

Step 5: Remediate Blocking Issues

Based on LEAPP's findings, fix each inhibitor. This process is iterative.

Example 1: Remove incompatible package

# Identify the package
rpm -qa | grep package-name

# Remove it
yum remove -y package-name

After removing, re-run preupgrade to verify the inhibitor is gone.

Example 2: Handle custom kernel modules

# List loaded modules
lsmod | grep custom

# Unload the module
modprobe -r custom-module

# Remove the package providing it
yum remove -y custom-module-package

Contact the vendor for OL8.10-compatible versions. Plan to reinstall after the upgrade.

Example 3: Update configuration files

cat /etc/path/to/config-file

Review and document changes flagged by LEAPP. Most updates are safe, but awareness is key.

Iteration process:

1. Run leapp preupgrade --oraclelinux
2. Review findings
3. Answer questions with leapp answer
4. Fix inhibitors (remove packages, update configs, etc.)
5. Repeat until no inhibitors remain

Only proceed to the actual upgrade once the report shows zero inhibitors.

Step 6: Execute the Upgrade

Once all inhibitors are resolved, you're ready for the actual upgrade. This is the point of no return—the system will be offline during the upgrade.

Verify current release:

cat /etc/redhat-release
cat /etc/oracle-release
uname -r

Note these values for comparison after upgrade.

Run the upgrade command:

leapp upgrade --oraclelinux

(Use leapp upgrade --oci if on OCI.)

This command:

• Downloads all OL8.10 packages
• Stages the system for upgrade
• Prepares the boot environment
• Reports when ready to reboot

Once the command completes (usually takes 10–30 minutes), you'll see a message to reboot.

Reboot into upgrade environment:

reboot

During the reboot:

When the system reboots, LEAPP takes control before normal services start. You'll see upgrade messages scrolling on the console. This is where the actual upgrade happens:

• OL7 packages are replaced with OL8.10 equivalents
• Kernel is updated from 3.x to 5.x
• Configuration files are migrated
• System integrity is verified

This phase takes 20–60 minutes. Do not interrupt it. Watch the console if possible—any errors will only appear there.

The system will automatically reboot when upgrade completes. Once you see the login prompt, the upgrade is finished.

Step 7: Post-Upgrade Verification

After the system reboots, verify everything worked correctly.

Verify OS version:

cat /etc/redhat-release
cat /etc/oracle-release

Should show OL8.10 instead of 7.9.

Check kernel:

uname -r
grubby --default-kernel

Should show a 5.x kernel (e.g., 5.4.17...) instead of 3.x.

Verify services:

systemctl status

Most services should show "active (running)." If critical services failed, check logs:

journalctl -u service-name -n 50
systemctl restart service-name

Clean up repositories:

ls /etc/yum.repos.d/ | grep ol7
rm /etc/yum.repos.d/ol7*.repo

Configure firewall (if needed):

firewall-cmd --state
firewall-cmd --permanent --list-all

Configure SELinux (if applicable):

getenforce

Restart KVM guests (if applicable):

virsh list --all
virsh start {vm-name}

Run post-upgrade commands:

# Example: set Python version
alternatives --set python /usr/bin/python3

Troubleshooting Common Issues

Problem: LEAPP preupgrade won't complete

If analysis hangs or fails:

• Check disk space: df -h
• Check memory: free -h
• Check logs: tail -100 /var/log/leapp/leapp-preupgrade.log

Problem: Upgrade hangs during reboot

Large systems take 30+ minutes. Wait at least 15 minutes before assuming failure. If truly stuck:

• Hard reset the system (power off, power on)
• System reverts to OL7.9
• Review logs, fix issues, try again

Problem: Services fail after upgrade

Check service-specific logs:

journalctl -u service-name -e

Most issues are configuration-related and fixable without rollback.

Problem: Package missing after upgrade

Check if OL8.10 version exists:

yum search package-name
yum install package-name

If not available, package may not be supported on OL8.10. Contact vendor or find alternative.

Next Steps in Your Upgrade Journey

Congratulations—you're now running Oracle Linux 8.10! Your upgrade journey is complete.

Install MySQL 8.4:

Follow our MySQL 8.4 installation guide to install a modern, long-term support database.

Archive upgrade documentation:

cp -r /var/log/leapp /backup/leapp-upgrade-$(date +%Y%m%d)

These documents prove what changed during the upgrade—valuable for troubleshooting, compliance, and future reference.

Update your documentation:

Update your infrastructure documentation to reflect OL8.10, new kernel version, and any configuration changes made during remediation.

The LEAPP upgrade from OL7.9 to OL8.10 is complete. Your system is now modern, supported, and ready for production.