This guide shows you how to install the SupremeRAID™ software dependencies on a server that has no internet access. The customer collects a system profile with graidutil, a Graid SE or partner generates a matching dependency bundle from the official distribution repositories on a machine with internet access, and the customer installs that bundle before running the SupremeRAID pre-installer and installer in offline mode.

Overview

Why this approach

Earlier offline procedures only covered the RHEL family and Ubuntu, and they pushed work onto the customer: Ubuntu required a second identical machine, and RHEL required the customer to mount the installation ISO, whose kernel-headers and dependency versions Graid could not control. The current tooling uses one flow for every supported distribution: the customer runs one command to describe their system, the SE generates every required package (including the matching kernel-headers / linux-headers) from the official repositories in a throw-away Docker container, and the customer installs the bundle with one command.

Prerequisites

Customer server

• The graidutil package from Graid support (.deb or .rpm, x86_64 or aarch64).
• Root access.
• A way to transfer files in and out (USB drive, SCP through a jump host, and so on).

Build machine (SE / partner)

• A Linux virtual machine or workstation with internet access. It does not need to run the same distribution as the customer.
• Docker.
• Python 3.10 or newer. The scripts use only the Python standard library.
• The two scripts from Graid support, offline.py and check_kernel.py, in the same directory.
• For Red Hat Enterprise Linux targets only: a Red Hat account with an active subscription. The container registers with it to reach the RHEL repositories and unregisters itself when finished.

Set up the build machine (one time)

1. Install and enable Docker:

   curl -fsSL https://get.docker.com -o get-docker.sh
   sudo sh get-docker.sh
   sudo systemctl enable --now docker
   docker run --rm hello-world

   The last command should printHello from Docker!. If you will run the scripts as a non-root user, add that user to the docker group and log in again.
2. Check the Python version. You need 3.10 or newer; on older hosts (for example Ubuntu 20.04 or RHEL 8) install a newer Python or use a newer VM.

   python3 --version

3. Put the scripts in a dedicated directory. They write their output next to themselves.

   mkdir -p ~/graid-offline && cd ~/graid-offline
   # copy offline.py and check_kernel.py here

4. Red Hat targets only: export your subscription credentials in the shell session you will run the scripts from. Nothing is written to disk, and the values never appear on the command line.

   export ACCOUNT='<your Red Hat account>'
   export PASSWORD='<your Red Hat password>'

Step 1. Collect the system profile (customer server)

Install the graidutil package if it is not already present:

# Debian / Ubuntu family
sudo dpkg -i graidutil-<version>-x86_64.deb
# RHEL / SUSE family
sudo rpm -i graidutil-<version>-x86_64.rpm

Then collect the profile:

graidutil collect data
# or write it to a specific path
graidutil collect data -o /tmp/installed_versions.txt

This writes installed_versions.txt in the current directory. The file contains the distribution, release, kernel version, CPU architecture, the kernel's GCC configuration, and the version of every installed package. It does not contain hostnames, IP addresses, or credentials.

Send installed_versions.txt to your Graid SE or partner.

Step 2. Check kernel-headers availability (build machine)

Before downloading anything, confirm that the kernel-headers / linux-headers package for the customer's exact kernel still exists in the official repository. Distributions remove older kernel packages over time.

python3 check_kernel.py --installed installed_versions.txt

There are three possible results.

Result A: kernel packages are already installed

[CHECK] ubuntu 24.04 - kernel: 6.8.0-139-generic
  linux-headers-6.8.0-139-generic               ... [INSTALLED]
  linux-modules-extra-6.8.0-139-generic         ... [INSTALLED]
[RESULT] Kernel packages are already installed on the target machine.

Nothing kernel-related needs to be downloaded. Go to step 3.

Result B: kernel packages are available in the repository

[CHECK] debian 13 - kernel: 6.12.73+deb13-amd64
  linux-headers-6.12.73+deb13-amd64             ... [OK]
[RESULT] Kernel-headers/linux-headers packages are available in the official repo.

The bundle will include headers matching the running kernel. Go to step 3.

Result C: kernel packages were NOT found

[CHECK] debian 13 - kernel: 6.12.74+deb13-amd64
  linux-headers-6.12.74+deb13-amd64             ... [NOT FOUND]
[RESULT] Kernel-headers/linux-headers packages were NOT found.
         If you proceed with -K no-specify, offline.py will install:
           linux-headers-amd64 = 6.12.94-1

The customer's kernel version is no longer in the official repository. Report this to the customer and let them choose:

• Customer agrees to upgrade the kernel: run step 3 with -K no-specify. The bundle will contain the latest kernel and headers shown in the output, and the customer will reboot into the new kernel after step 4.
• Customer does not agree: the customer must obtain the kernel-headers package and its dependencies for their current kernel themselves (for example from their OS vendor). Do not build a bundle until that is resolved.

Step 3. Generate the offline bundle (build machine)

# RHEL targets only, in the same shell:
export ACCOUNT='<your Red Hat account>'
export PASSWORD='<your Red Hat password>'

python3 offline.py --installed installed_versions.txt
# Only when the customer agreed to a kernel upgrade in step 2, result C:
python3 offline.py --installed installed_versions.txt -K no-specify

The script pulls the matching distribution image for the customer's architecture, resolves every package SupremeRAID needs against the customer's installed versions, downloads them, and packs them. A successful run ends with:

[DONE] ubuntu24_offline_packages.tar.gz  →  /home/se/graid-offline/output_tar

[SUCCESS]  ubuntu-24.04 finished.

The bundle is written to output_tar/<distro><major>_offline_packages.tar.gz next to the script, for example rocky9_offline_packages.tar.gz or ubuntu24_offline_packages.tar.gz. Expect roughly 100 to 400 MB depending on the distribution.

Note: output_tar/ is deleted and recreated on every run. Copy the bundle somewhere else before generating another one.

Send the .tar.gz file to the customer.

Step 4. Install the bundle (customer server)

Copy the bundle onto the server and run the installer as root:

sudo graidutil install ubuntu24_offline_packages.tar.gz
# or
sudo graidutil install -p /path/to/ubuntu24_offline_packages.tar.gz

The installer:

1. Extracts the bundle and simulates the installation with the system package manager to confirm nothing is missing. If the simulation fails it stops without changing anything and asks you to contact Graid support.
2. Lists the packages under [MANDATORY]. These are the kernel headers, compiler toolchain, and core libraries that SupremeRAID requires, and they may be upgrades of packages already on the system.
3. Asks for confirmation. To proceed, type exactly:

   AgreetoUpgrade

   Any other input aborts the installation with nothing installed.
4. Installs the mandatory packages. Packages in the bundle that are not required, or that would only be optional upgrades, are skipped.
5. If the headers for the currently running kernel were not installed (kernel upgrade case), offers to reboot. Reboot before continuing so that the running kernel matches the installed headers.

Every run is logged to /var/log/graid-offline-package.log, including what the operator typed at the confirmation prompt.

Step 5. Install SupremeRAID in offline mode (customer server)

sudo bash graid-preinstaller -pl sr --offline-install
sudo bash graid-installer --offline-install

The --offline-install option tells both runfiles to use the dependencies installed in step 4 instead of downloading them. Continue with the normal SupremeRAID setup (license, driver, graidctl) as documented in the user guide.

Flow chart

Commands inside the boxes can be selected and copied.

graidutil collect data

python3 check_kernel.py --installed installed_versions.txt

-K no-specify

python3 offline.py --installed installed_versions.txt

sudo graidutil install <distro><major>_offline_packages.tar.gz

sudo bash graid-preinstaller -pl sr --offline-install
sudo bash graid-installer --offline-install

Supported target distributions

Both x86_64 and aarch64 customers are supported. The scripts read the architecture from installed_versions.txt and build inside a container of that architecture.

Common issues

On the build machine

• SyntaxError on start: Python is older than 3.10. Check python3 --version.
• docker command not found or permission denied while trying to connect to the Docker daemon: Docker is not installed, not running, or your user is not in the docker group.
• [SKIP] Image not available: the machine cannot reach Docker Hub, quay.io, or registry.access.redhat.com. Check proxy and firewall settings.
• [ERROR] RHEL requires Red Hat subscription credentials: the target is RHEL and ACCOUNT / PASSWORD are not exported in the current shell.
• [ERROR] DISTRO / RELEASE not found in --installed file: the file was not produced by graidutil collect data, or its first lines were edited. Ask the customer to collect it again.
• [ERROR] Unsupported distro or is not supported: the customer's distribution or release is not in the supported list. Contact Graid support.
• [ERROR] -K only accepts 'no-specify': the kernel version is always taken from the file; -K exists only to request the latest kernel.
• [FAIL] <distro> during step 3: the package manager inside the container could not resolve the request. Scroll up for the package manager's own error. Typical causes are a mirror outage or a kernel version that disappeared between step 2 and step 3.

On the customer server

• Dependency check failed during graidutil install: the bundle does not match the server, for example because packages were installed or upgraded after installed_versions.txt was collected. Collect a fresh profile and generate a new bundle.
• [ABORTED] You did not agree to upgrade the required packages: the confirmation phrase must be typed exactly as AgreetoUpgrade, case-sensitive.

Related articles

• SupremeRAID Installation Guide