DGX Spark

https://docs.nvidia.com/dgx/dgx-spark
Admin
DGX Spark is NVIDIA's compact AI computer designed for developers, data scientists, and AI...
Tokens:47,788
Snippets:553
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example guids.txt content

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

A sample list of GUIDs for an NVIDIA DGX Spark system.

```text
09321615-5d32-5758-8308-52a4a7be8efc
095ba8dd-3778-52b4-9f32-02a67c210ce5
0eb9bda9-3010-493a-a6a8-b5e80eddf870
10ec82f4-ff64-5362-9e5d-688febf5dbb0
12029307-5bb1-5200-99a5-536f1be9d081
35abf34a-7ed8-51b2-ba1b-edef527d47e6
3d13c989-e6a8-4ead-95ee-921f09868f65
59007998-a3d7-54a3-b30e-eb3b77e2f351
5f106816-21fe-5d90-896a-175038b9256f
67d35028-ca5b-5834-834a-f97380381082
75b1af35-b88a-59d2-a3c7-a38537f8607f
93768061-87bf-5c78-b9ea-5b7a6301012b
b488217b-3895-4fc0-b1bf-ab7005a2d45a
b5e95689-ad65-5e57-8778-897f04396256
cfc0de0b-adb3-5060-ba22-e4010a78368f
dd1a238a-5f8e-46bd-9401-a88da99c5a96
```

--------------------------------

### Skip GNOME Initial Setup

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Creates the configuration file to bypass the GNOME initial setup wizard.

```bash
_hook_oobe_skip_gnome_initial_setup() {
 install -d -m 0755 -o YOUR_USERNAME -g YOUR_USERNAME \
  /home/YOUR_USERNAME/.config 2>/dev/null || true
 touch /home/YOUR_USERNAME/.config/gnome-initial-setup-done 2>/dev/null || true
 chown YOUR_USERNAME:YOUR_USERNAME \
  /home/YOUR_USERNAME/.config/gnome-initial-setup-done 2>/dev/null || true
}
```

--------------------------------

### Enable Landscape Client

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-fleet-lifecycle.html

Initiate the interactive setup process to configure the Landscape client.

```bash
sudo pro enable landscape
```

--------------------------------

### Main Execution Hook

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Orchestrates the installation process by calling various hooks in sequence.

```bash
_hook_main() {
 _hook_config_defaults
 _hook_mirror_apply_local_mirror
 _hook_oem_install_debs_from_usb
 _hook_oem_install_from_local_repo
 _hook_oem_install_firmware_usb
 _hook_oem_lvfs_local_mirror
 _hook_oem_lvfs_mirror_from_url

 HOOK_APT_UPDATED=0
 HOOK_FW_UPDATED=0
 HOOK_FW_FAILED=0
 _hook_fwupdmgr_refresh_and_count
 _hook_fwupdmgr_upgrade_loop
 _hook_apt_update_initial
 _hook_final_apt_upgrade
 _hook_restore_stock_apt_and_lvfs
 _hook_exit_with_status
}

_hook_main
```

--------------------------------

### Serve mirror with Python

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Starts a simple HTTP server to host the mirror directory.

```bash
cd ~/mirror
python3 -m http.server 8080 --bind 0.0.0.0
```

--------------------------------

### Configure GRUB for PXE Boot

Source: https://docs.nvidia.com/dgx/dgx-spark/pxe.html

Sample configuration for the grub.cfg file to initiate the FastOS installation.

```text
set default=0
set timeout=5

menuentry "Install DGX Spark FastOS" {
    linux /fastos/vmlinuz nouveau.modeset=0 console=tty0 console=ttyS0,921600 sbsa_gwdt.action=1 noui pxeinstall=true fastos_usbimg_url=http://<Server IP>/fastos/usb.customer.tar.gz ip=dhcp static_ip=<static ip>:<gateway ip>
    initrd /fastos/initrd
}
```

--------------------------------

### Repack FastOS Execution Example

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Example command to run the repack_fastos.sh script with required input tarball and cloud-init directory paths.

```bash
./repack_fastos.sh \
   -f $PATH_TO_FASTOS/usb.customer-1.135.33.tar.gz \
   -c $PATH_TO_cloud-init/oemdata/cloud-init
```

--------------------------------

### Verify Installation

Source: https://docs.nvidia.com/dgx/dgx-spark/support.html

Confirms the package is correctly installed on the system.

```bash
dpkg -l | grep dgx-spark-fieldiag
```

--------------------------------

### Install OEM Data Packages

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Functions to install .deb files from a USB partition and configure local APT repositories for package installation.

```bash
_hook_oem_install_debs_from_usb() {
 echo "Checking for debs in USB OEMDATA partition..."
 if [ -d "$OEM_MNT/debs" ] && ls "$OEM_MNT/debs"/*.deb >/dev/null 2>&1; then
   echo "Installing debs from USB OEMDATA partition..."
   dpkg -i "$OEM_MNT/debs"/*.deb || true
   apt-get install -f -y
 fi
}

_hook_oem_install_from_local_repo() {
 echo "Checking for local APT repo..."
 if [ ! -f "$OEM_MNT/apt-repo.url" ]; then
   echo "apt-repo.url not found"
   return 0
 fi
 repo_url=$(sed -n '1s/[[:space:]]*//p' "$OEM_MNT/apt-repo.url")
 if [ -z "$repo_url" ]; then
   echo "No local APT repo URL found"
   return 0
 fi
 echo "Adding local APT repo: $repo_url"
 printf 'deb [trusted=yes] %s ./\n' "$repo_url" > \
   /etc/apt/sources.list.d/oem-local.list
 repo_host=$(echo "$repo_url" | sed -n 's|.*://\([^:/]*\).*|\1|p')
 if [ -n "$repo_host" ]; then
   rm -f /var/lib/apt/lists/partial/*"$repo_host"* \
     /var/lib/apt/lists/*"$repo_host"* 2>/dev/null || true
 fi
 _hook_apt_update_with_retries || true

 if [ ! -f "$OEM_MNT/apt-packages.txt" ]; then
   echo "apt-packages.txt not found; apt upgrade using OEM local repo only" \
     "(single-source apt)"
   apt upgrade -y \
     -o Dir::Etc::sourcelist="/etc/apt/sources.list.d/oem-local.list" \
     -o APT::Architecture="$(dpkg --print-architecture)" \
     || true
   return 0
 fi
 pkgs=$(grep -v '^[#;]' "$OEM_MNT/apt-packages.txt" | while read -r line; do
   line="${line%%[[:space:]]*}"
   [ -z "$line" ] && continue
   case "$line" in *\.deb)
     line="${line%.deb}"; line="${line%_*}"; line="${line%_*}"
   esac
   echo "$line"
 done | tr '\n' ' ')
 if [ -z "$pkgs" ]; then
   return 0
 fi
 echo "Installing packages from local repo: $pkgs"
 if ! apt-get install -y $pkgs; then
   echo "Fallback: downloading .deb and installing with dpkg..."
   base="${repo_url%/}"
   for pkg in $pkgs; do
     pkg_file=$(
       _hook_http_get "$base/Packages.gz" | zcat 2>/dev/null | awk -v pkg="$pkg" '
/^Package: /{name=$2}
/^Filename: /{if(name==pkg){print $2; exit}}
/^$/{name=""}
'
     )
     pkg_file="${pkg_file#./}"
     [ -z "$pkg_file" ] && continue
     tmp_deb="/tmp/$(basename "$pkg_file")"
     if _hook_http_get "$base/$pkg_file" > "$tmp_deb" 2>/dev/null && \
       [ -s "$tmp_deb" ]; then
       dpkg -i "$tmp_deb" && echo "PASS: $pkg (dpkg)" || true
     else
       echo "FAIL: could not download $pkg"
     fi
     rm -f "$tmp_deb"
   done
   apt-get install -f -y 2>/dev/null || true
 fi
}
```

--------------------------------

### Usage Examples for repack_baseos.sh

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Common command-line invocations for the ISO repack script.

```bash
$(basename "$0")
 $(basename "$0") -iso /path/to/local-DGXOS.iso
 $(basename "$0") -iso /path/to/local-DGXOS.iso -iso-root /tmp/my-iso-root
 $(basename "$0") -clean
 $(basename "$0") -volume-id "DGXOS-CUSTOM"
 $(basename "$0") -debug
```

--------------------------------

### Serve Repository via Python

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Starts a simple HTTP server from the web root directory for testing or temporary hosting.

```bash
cd "$WEB_ROOT"
python3 -m http.server 8080 --bind 0.0.0.0
```

--------------------------------

### Install Field Diagnostic Software

Source: https://docs.nvidia.com/dgx/dgx-spark/support.html

Adds the repository source and installs the diagnostic package.

```bash
echo "deb [signed-by=/usr/share/keyrings/cuda-archive-keyring.gpg] https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/sbsa /" | sudo tee /etc/apt/sources.list.d/cuda-sbsa-ubuntu2404.list
sudo apt-get update
sudo apt-get install dgx-spark-fieldiag
```

--------------------------------

### Install Firmware from USB OEMDATA

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Scans the OEMDATA partition for firmware files and installs them using fwupdmgr.

```bash
_hook_oem_install_firmware_usb() {
 echo "Checking for firmware in USB OEMDATA partition..."
 if [ ! -d "$OEM_MNT/firmware" ]; then
   return 0
 fi
 echo "Installing firmware from USB OEMDATA partition..."
 find "$OEM_MNT/firmware" -maxdepth 1 -type f \
   \( -name '*.cab' -o -name '*.cap' \) | while read -r f; do
   name=$(basename "$f")
   echo "Installing firmware: $name"
   if fwupdmgr install --allow-reinstall "$f"; then
     echo "PASS: $name"
   else
     echo "FAIL: $name"
   fi
 done
}
```

--------------------------------

### Install OEM Cloud-Init Data

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Copies cloud-init configuration files and OEM scripts into the ISO oemdata directory.

```bash
install_oemdebs() {
   echo ""
   echo "Step 4: Installing cloud-init into ISO oemdata..."

   # Copy repo oemdata/cloud-init/ (full tree: seed/, cfg.d/, etc.) and
   # oem-iso-cfg.sh so they are on the repacked ISO
   if [[ -d "$OEMDATA_SRC" ]]; then
       if [[ -d "$OEMDATA_SRC/cloud-init" ]]; then
           echo "Copying OEM cloud-init tree from $OEMDATA_SRC/cloud-init to ISO..."
           rm -rf "$ISO_ROOT/oemdata/cloud-init"
           cp -a "$OEMDATA_SRC/cloud-init" "$ISO_ROOT/oemdata/cloud-init"
           echo "  ✓ cloud-init directory copied (seed/, cfg.d/, and all files)."
       fi
       if [[ -f "$OEMDATA_SRC/oem-iso-cfg.sh" ]]; then
           echo "Copying oem-iso-cfg.sh to ISO..."
           cp "$OEMDATA_SRC/oem-iso-cfg.sh" "$ISO_ROOT/oemdata/"
           echo "  ✓ oem-iso-cfg.sh copied."
       fi
   else
       echo "Warning: Repo oemdata not found at $OEMDATA_SRC" \
           "(cloud-init will not be added)."
   fi

   echo "=========================================="
   echo "OEM cloud-init contents (used by cloud-init service at first boot):"
   find "$ISO_ROOT/oemdata/cloud-init" -type f 2>/dev/null | sort || true
   echo "=========================================="
}
```

--------------------------------

### Automate ISO Customization with oem-iso-cfg.sh

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

This script runs during ISO-based installation to configure cloud-init, install custom Debian packages, and execute post-installation tasks.

```bash
#!/bin/bash

set -euo pipefail
set -x
export DEBIAN_FRONTEND=noninteractive

LOGFILE=/var/log/oem-iso-cfg.log
_OEM_TRAP='echo "[oem][fatal] script failed at line $LINENO" | '\
'tee -a "$LOGFILE" >&2; exit 1'
trap "$_OEM_TRAP" ERR
exec > >(tee -a "$LOGFILE") 2>&1

echo "[oem] Starting customization script"
OEM_DEB_SRC=/cdrom/oemdata/debs
OEM_CLOUD_SRC=/cdrom/oemdata/cloud-init
OEM_CLOUD_CFG_SRC="$OEM_CLOUD_SRC/cfg.d"
OEM_CLOUD_SEED_SRC="$OEM_CLOUD_SRC/seed"
OEM_NOCLOUD_DST=/var/lib/cloud/seed/nocloud
OEM_CFG_DST=/etc/cloud/cloud.cfg.d

if [ -d "$OEM_CLOUD_SRC" ]; then
   echo "[oem] Detected OEM cloud-init configuration at $OEM_CLOUD_SRC"
   find "$OEM_CLOUD_SRC"

   echo "[oem] Enabling cloud-init NoCloud seed and config"
   mkdir -p -v "$OEM_NOCLOUD_DST" "$OEM_CFG_DST"

   if [ -d "$OEM_CLOUD_SEED_SRC" ]; then
       echo "[oem] Copying seed files from $OEM_CLOUD_SEED_SRC -> $OEM_NOCLOUD_DST"
       cp -av "$OEM_CLOUD_SEED_SRC"/. "$OEM_NOCLOUD_DST"/
   else
       echo "[oem] No seed directory found at $OEM_CLOUD_SEED_SRC"
   fi

   if [ -d "$OEM_CLOUD_CFG_SRC" ]; then
       echo "[oem] Copying cfg files from $OEM_CLOUD_CFG_SRC -> $OEM_CFG_DST"
       cp -av "$OEM_CLOUD_CFG_SRC"/. "$OEM_CFG_DST"/
   else
       echo "[oem] No cfg.d directory found at $OEM_CLOUD_CFG_SRC"
   fi

   echo "[oem] cloud-init OEM configuration enabled."
else
   echo "[oem] No OEM cloud-init configuration found."
fi

echo "[oem] oemdata contents"
find /cdrom/oemdata -type f

if [ ! -f /cdrom/oemdata/build_type ]; then
   echo "build_type is not found, no further customization"
   exit 0
fi

BUILD_TYPE=$(cat /cdrom/oemdata/build_type | tr '[:upper:]' '[:lower:]')
echo "[oem] Build Type: ${BUILD_TYPE}"

echo "[oem] Install packages"
pushd ${OEM_DEB_SRC}

if ls "$OEM_DEB_SRC"/*.deb >/dev/null 2>&1; then
 echo "[oem] Installing OEM packages from $OEM_DEB_SRC"

 # Prepare isolated APT environment
 APT_DIR="$(mktemp -d /tmp/oem-apt-XXXXXX)"
 APT_ARCH="$(dpkg --print-architecture)"
 mkdir -p "$APT_DIR/lists" "$APT_DIR/cache" "$APT_DIR/state" "$APT_DIR/debs"
 cp -a "$OEM_DEB_SRC"/.  "$APT_DIR/debs"
 cd "$APT_DIR/"
 dpkg-scanpackages debs /dev/null > "$APT_DIR/Packages"
 TEMP_SOURCE_LIST="$APT_DIR/oemrepo.list"
 echo "deb [trusted=yes] file:$APT_DIR ./" > "$TEMP_SOURCE_LIST"

 echo "[oem] Installing OEM packages from $OEM_DEB_SRC"
 echo "================================================
```

--------------------------------

### GRUB Configuration for PXE Boot

Source: https://docs.nvidia.com/dgx/dgx-spark/pxe.html

Example configuration for the grub.cfg file to define boot menu entries and kernel parameters.

```text
set default=0
set timeout=5

menuentry 'Install BaseOS 7.0.0' {
   linux /baseos/vmlinuz fsck.mode=skip autoinstall ip=dhcp url=http://<Server IP>/base_os_7.0.0/base_os_7.0.0.iso nvme-core.multipath=n nouveau.modeset=0
   initrd /baseos/initrd
}
```

--------------------------------

### Install LVFS Sync Dependencies

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Installs required Python packages for the sync-pulp.py script.

```bash
sudo apt install -y python3 python3-requests python3-lxml
```

--------------------------------

### Verify NVIDIA Container Toolkit installation

Source: https://docs.nvidia.com/dgx/dgx-spark/nvidia-container-runtime-for-docker.html

Check the installed version of the NVIDIA container toolkit.

```bash
nvidia-ctk --version
```

--------------------------------

### PXE Server Directory Structure

Source: https://docs.nvidia.com/dgx/dgx-spark/pxe.html

Example directory layout for HTTP and TFTP servers to support PXE booting.

```text
/local/
   http/
      base_os_7.0.0/
         base_os_7.0.0.iso

   tftp/
      baseos/
         vmlinuz
         initrd
      grub/
         grub.cfg
      grubnetaa64.efi.signed
```

--------------------------------

### Run a development container

Source: https://docs.nvidia.com/dgx/dgx-spark/ngc.html

Starts a container with persistent storage mapped to the local project directory.

```bash
# Run a development container with persistent storage
docker run -it --gpus=all \
  -v /path/to/your/project:/workspace \
  nvcr.io/nvidia/pytorch:24.08-py3
```

--------------------------------

### ISO Validation and Setup

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Initializes debug mode and validates the provided ISO file and volume ID parameters.

```bash
# Enable verbose output if debug mode is on
if [[ "$DEBUG" == "true" ]]; then
   set -x
   VERBOSE_OUTPUT="/dev/stdout"
else
   VERBOSE_OUTPUT="/dev/null"
fi

check_iso() {

   # Validate ISO file exists
   if [[ ! -f "$ISO_FILE" ]]; then
       echo "Error: ISO file '$ISO_FILE' does not exist"
       exit 1
   fi

   # Generate default VOLUME_ID if not provided
   if [[ -z "$VOLUME_ID" ]]; then
       # Get the basename without path and remove .iso extension
       ISO_BASENAME=$(basename "$ISO_FILE" .iso)
       # Take first 32 characters
       VOLUME_ID="${ISO_BASENAME:0:32}"
       # Trim trailing special characters to end on alphanumeric
       VOLUME_ID=$(echo "$VOLUME_ID" | sed 's/[^a-zA-Z0-9]*$//')
   fi

   # Validate VOLUME_ID length
   if [[ ${#VOLUME_ID} -gt 32 ]]; then
       echo "Error: Volume ID must be 32 characters or less"
       echo "Current volume ID: '$VOLUME_ID' (${#VOLUME_ID} characters)"
       exit 1
   fi

   if [[ -z "$VOLUME_ID" ]]; then
       echo "Error: Volume ID cannot be empty"
       exit 1
   fi

   echo "=========================================="
   echo "DGX OS ISO Update Script"
   echo "=========================================="
   echo "ISO File: $ISO_FILE"
   echo "ISO Root: $ISO_ROOT"
   echo "Volume ID: $VOLUME_ID"
   echo "=========================================="
}
```

--------------------------------

### Configure OEMDATA Metadata Files

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Examples of content for configuration files used by the hook script to locate repositories and packages.

```text
http://192.168.1.1:8080/lvfs-mirror/signbinpack-2.152.3-release
```

```text
http://192.168.1.1:8080
```

```text
nvidia-spark-ota-check
```

--------------------------------

### Add NVIDIA CUDA Repository Key

Source: https://docs.nvidia.com/dgx/dgx-spark/support.html

Required step to prepare the system for installing packages from the NVIDIA CUDA repository.

```bash
sudo mkdir -p /usr/share/keyrings
curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/sbsa/cuda-archive-keyring.gpg | sudo tee /usr/share/keyrings/cuda-archive-keyring.gpg > /dev/null
```

--------------------------------

### AI Prompt for Patch Generation

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Use this prompt to generate configuration patches for APT and LVFS mirroring after initial setup.

```text
Generate a patch from the PDF for APT and LVFS mirroring.
```

--------------------------------

### Repack BaseOS with Custom Paths

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Example usage of the repack script specifying a local ISO file and a custom extraction directory.

```bash
ISO=~/Downloads/tmp/BaseOS/7.4.0/DGXOS-7.4.0-2026-01-26-16-04-58-arm64.iso
OUT=~/Downloads/tmp/BaseOS/Repack
./repack_baseos.sh -iso "$ISO" -iso-root "$OUT"
```

--------------------------------

### Configure Network Share Server Script

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

A bash script to automate the setup of a network share server with static IP, DHCP, TFTP, and HTTP services. Requires root privileges to execute.

```bash
#!/usr/bin/env bash

set -euo pipefail

# Setup a dedicated cloud-init network share server:
# - static IP on dedicated interface
# - DHCP for clients on same subnet
# - TFTP service (for PXE or future expansion)
# - HTTP service with hook.sh at http://<server_ip>:8080/hook.sh
#
# Usage:
#   sudo ./server-network-share.sh <interface> [server_cidr] [range_start] [range_end]
#
# Example:
#   sudo ./server-network-share.sh eno2 192.168.1.1/24 192.168.1.100 192.168.1.199

if [[ "${EUID}" -ne 0 ]]; then
 echo "Run as root (sudo)."
 exit 1
fi

SERVER_IFACE="${1:-eno2}"
SERVER_CIDR="${2:-192.168.1.1/24}"
DHCP_RANGE_START="${3:-192.168.1.100}"
DHCP_RANGE_END="${4:-192.168.1.199}"

SCRIPT_DIR="$(cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P)"
HOOK_SOURCE="${SCRIPT_DIR}/hook.sh"

TFTP_DIR="/var/nvidia/tftp"
HTTP_ROOT="/var/nvidia/www/html"
HTTP_PORT="8080"

if [[ ! -f "${HOOK_SOURCE}" ]]; then
 echo "Hook script not found: ${HOOK_SOURCE}"
 exit 1
fi

SERVER_IP="${SERVER_CIDR%/*}"
SUBNET_PREFIX="${SERVER_IP%.*}"
SUBNET_NETWORK="${SUBNET_PREFIX}.0"
SUBNET_NETMASK="255.255.255.0"

echo "==> Installing required packages"
apt update
apt install -y isc-dhcp-server tftpd-hpa apache2

echo "==> Configuring ${SERVER_IFACE} with ${SERVER_CIDR}"
ip link set "${SERVER_IFACE}" up
ip addr flush dev "${SERVER_IFACE}" || true
ip addr add "${SERVER_CIDR}" dev "${SERVER_IFACE}"

echo "==> Configuring TFTP server"
mkdir -p "${TFTP_DIR}"
cat > /etc/default/tftpd-hpa <<EOF
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="${TFTP_DIR}"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
EOF

echo "==> Configuring DHCP server"
cat > /etc/default/isc-dhcp-server <<EOF
INTERFACESv4="${SERVER_IFACE}"
INTERFACESv6=""
DHCPDARGS="${SERVER_IFACE}"
EOF

cat > /etc/dhcp/dhcpd.conf <<EOF
default-lease-time 600;
max-lease-time 7200;
authoritative;
ping-check false;

subnet ${SUBNET_NETWORK} netmask ${SUBNET_NETMASK} {
 option routers ${SERVER_IP};
 option subnet-mask ${SUBNET_NETMASK};
 option domain-name-servers ${SERVER_IP};
 range ${DHCP_RANGE_START} ${DHCP_RANGE_END};
}
EOF

echo "==> Configuring HTTP server and publishing hook.sh"
mkdir -p "${HTTP_ROOT}"
cp -f "${HOOK_SOURCE}" "${HTTP_ROOT}/hook.sh"
chmod 644 "${HTTP_ROOT}/hook.sh"

for share_name in apt lvfs; do
 share_source="${SCRIPT_DIR}/${share_name}"
 share_target="${HTTP_ROOT}/${share_name}"
 if [[ -d "${share_source}" ]]; then
   rm -rf "${share_target}"
   ln -s "${share_source}" "${share_target}"
   echo "  Linked ${share_name}: ${share_target} -> ${share_source}"
 fi
done


cat > /etc/apache2/conf-available/nvidia-cloud-init-port.conf <<EOF
Listen ${HTTP_PORT}
EOF

a2enconf nvidia-cloud-init-port >/dev/null

cat > /etc/apache2/sites-available/000-default.conf <<EOF
<VirtualHost *:${HTTP_PORT}>
   DocumentRoot ${HTTP_ROOT}
   <Directory ${HTTP_ROOT}>
       Require all granted
       Options Indexes FollowSymLinks
       AllowOverride None
   </Directory>
</VirtualHost>
EOF

systemctl restart tftpd-hpa
systemctl restart isc-dhcp-server
systemctl restart apache2

systemctl --no-pager --full status tftpd-hpa isc-dhcp-server apache2 | sed -n '1,60p'

echo
echo "cloud-init network share server ready:"
echo "  Interface : ${SERVER_IFACE}"
echo "  Server IP : ${SERVER_IP}"
echo "  DHCP pool : ${DHCP_RANGE_START} - ${DHCP_RANGE_END}"
echo "  Hook URL  : http://${SERVER_IP}:${HTTP_PORT}/hook.sh"
echo
echo "Client-side cloud-init can use:"
echo "  CLOUDINIT_IFACE=enP7s7"
echo "  CLOUDINIT_SERVER_IP=${SERVER_IP}"
echo "  CLOUDINIT_SERVER_PORT=${HTTP_PORT}"
```

--------------------------------

### Configure APT Sources for Local Mirror

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Create a DEB822 formatted source file to point the client to a local Ubuntu mirror.

```text
# Ubuntu from local mirror (under web root .../apt/mirror/)
Types: deb deb-src
URIs: http://192.168.1.1:8080/apt/mirror/ports.ubuntu.com/ubuntu-ports/
Suites: noble-proposed
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg
```

--------------------------------

### Define Web Root and Repository Directories

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Sets up the directory structure for the APT repository and LVFS mirror with appropriate permissions.

```bash
WEB_ROOT=/var/www   # or for example $HOME/oem-server
REPO_DIR="$WEB_ROOT/deb-repo"
LVFS_DIR="$WEB_ROOT/lvfs-mirror"
sudo mkdir -p "$REPO_DIR" "$LVFS_DIR"
sudo chown "$USER" "$REPO_DIR" "$LVFS_DIR"
```

--------------------------------

### Extract GUIDs from fwupdmgr

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Uses jq to parse JSON output from fwupdmgr and extract unique GUIDs into a file.

```bash
fwupdmgr get-devices --json | jq -r '
  .. | objects | select(has("Guid")) | .Guid,
  (.. | objects | select(has("Guids")) | .Guids[]?)
' | sort -u > ~/mirror/guids.txt
```

--------------------------------

### Initialize Mirror Directory and Sync Script

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Creates the necessary directory structure and downloads the LVFS synchronization tool.

```bash
mkdir -p ~/mirror/apt ~/mirror/lvfs
cd ~/mirror
wget -O sync-pulp.py https://gitlab.com/fwupd/lvfs-website/raw/master/contrib/sync-pulp.py
chmod +x sync-pulp.py
```

--------------------------------

### Verify GPU access

Source: https://docs.nvidia.com/dgx/dgx-spark/ngc.html

Confirms that the NVIDIA Container Runtime is correctly installed and accessible.

```bash
# Verify NVIDIA Container Runtime is installed
docker run --rm --gpus=all nvcr.io/nvidia/cuda:13.0.1-devel-ubuntu24.04 nvidia-smi
```

--------------------------------

### Mounting and Preparing ISO Files

Source: https://docs.nvidia.com/dgx/dgx-spark/pxe.html

Commands to mount the ISO and extract kernel and initrd files for the TFTP directory.

```bash
sudo mount -o loop /local/http/base_os_7.0.0/base_os_7.0.0.iso /mnt
```

```bash
cp /mnt/casper/vmlinuz /local/tftp/baseos/vmlinuz
cp /mnt/casper/initrd /local/tftp/baseos/initrd
```

```bash
umount /mnt
```

--------------------------------

### Configure Spark Autostart and Keyboard

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Sets up desktop autostart entries and executes custom keyboard configuration scripts if present.

```bash
_hook_oobe_spark_autostart_and_keyboard() {
 install -d -m 0755 -o YOUR_USERNAME -g YOUR_USERNAME \
  /home/YOUR_USERNAME/.config/autostart 2>/dev/null || true
 if [ ! -f /home/YOUR_USERNAME/.config/autostart/nvidia-spark-docs.desktop ]; then
   ( umask 022
     cat > /home/YOUR_USERNAME/.config/autostart/nvidia-spark-docs.desktop << 'EOF'
[Desktop Entry]
Type=Application
Name=NVIDIA Spark documentation
Exec=xdg-open https://build.nvidia.com/spark
X-GNOME-Autostart-enabled=true
EOF
   ) 2>/dev/null || true
   chown YOUR_USERNAME:YOUR_USERNAME \
     /home/YOUR_USERNAME/.config/autostart/nvidia-spark-docs.desktop \
     2>/dev/null || true
   chmod 0644 /home/YOUR_USERNAME/.config/autostart/nvidia-spark-docs.desktop \
     2>/dev/null || true
 fi
 if [ -f "$OEM_MNT/oem-keyboard-spark.sh" ]; then
   echo "[oem hook] running $OEM_MNT/oem-keyboard-spark.sh"
   sh "$OEM_MNT/oem-keyboard-spark.sh" || true
 fi
}
```

--------------------------------

### Clean GUID file

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Removes non-UUID characters from the guids.txt file using awk.

```bash
awk '{ gsub(/[^0-9A-Fa-f-]/, "", $0); if (length($0)) print $0 }' \
    ~/mirror/guids.txt > ~/mirror/guids.txt.clean
mv ~/mirror/guids.txt.clean ~/mirror/guids.txt
```

--------------------------------

### Test GPU container startup

Source: https://docs.nvidia.com/dgx/dgx-spark/nvidia-container-runtime-for-docker.html

Run a minimal container to verify GPU access and container runtime functionality.

```bash
docker run --rm --gpus=all nvcr.io/nvidia/cuda:13.0.1-devel-ubuntu24.04 echo "GPU test successful"
```

--------------------------------

### Expected Directory Layout

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

The target directory structure for the DGX Spark custom installation after reconstruction.

```text
.
├── oemdata
│   ├── cloud-init
│   │   ├── cfg.d
│   │   │   ├── 50-dgx-base-audit.cfg
│   │   │   ├── 50-oem-default-user.cfg
│   │   │   └── 99-oem-nocloud.cfg
│   │   └── seed
│   │       ├── meta-data
│   │       └── user-data
│   ├── hook.sh
│   ├── oem-iso-cfg.sh
│   └── spark-mirror-sync.sh
├── repack_baseos.sh
├── repack_fastos.sh
└── server-network-share.sh
```

--------------------------------

### Cloud-init ISO Layout

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Directory structure for the OEM cloud-init tree on the repacked ISO.

```text
.
├── cfg.d
│   ├── 50-dgx-base-audit.cfg
│   ├── 50-oem-default-user.cfg
│   └── 99-oem-nocloud.cfg
└── seed
    ├── meta-data
    └── user-data
```

--------------------------------

### Configure and Run APT Mirror

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Defines the base path and synchronization command for the APT mirror configuration file.

```bash
set base_path /home/nvidia/mirror/apt

# Only noble-proposed for ports.ubuntu.com/ubuntu-ports (+ optional deb-src if you mirror sources)

clean http://ports.ubuntu.com/ubuntu-ports
sudo /usr/local/bin/apt-mirror /etc/apt/mirror.spark.list
```

--------------------------------

### Default System User Configuration

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Sets the default system user and group permissions for the installed system.

```yaml
# Use YOUR_USERNAME as the default user instead of ubuntu (developer flavor).
# Ensures the console and system default user is YOUR_USERNAME so login works
# after install.
system_info:
 default_user:
   name: YOUR_USERNAME
   groups: [sudo]
   shell: /bin/bash
   lock_passwd: false
```

--------------------------------

### GRUB Configuration Modification

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Backs up and modifies the GRUB configuration file by removing specific installation submenus.

```bash
# Step 3: Modify GRUB configuration
modify_grub() {
   echo ""
   echo "Step 3: Modifying GRUB configuration..."
   GRUB_CFG="$ISO_ROOT/boot/grub/grub.cfg"

   if [[ -f "$GRUB_CFG" ]]; then
       # Create a backup
       cp "$GRUB_CFG" "${GRUB_CFG}.backup"

       # Remove the "Installation Options" submenu section (from
       # 'submenu "Installation Options"' to its closing '}')
       # This uses sed to delete from the pattern to the matching closing brace
       sed_i '/^submenu "Installation Options" {$/,/^}$/d' "$GRUB_CFG"
```

--------------------------------

### Install Upstream apt-mirror

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Replaces the system apt-mirror with the current upstream version to support newer DEP-11 paths.

```bash
sudo apt install -y perl wget
sudo cp -a /usr/bin/apt-mirror /usr/bin/apt-mirror.distpkg 2>/dev/null || true
sudo wget -O /usr/local/bin/apt-mirror https://raw.githubusercontent.com/apt-mirror/apt-mirror/master/apt-mirror
sudo chmod +x /usr/local/bin/apt-mirror
```

--------------------------------

### Pull and Run a Container

Source: https://docs.nvidia.com/dgx/dgx-spark/ngc.html

Download an optimized PyTorch container and launch it with full GPU access.

```bash
# Pull a PyTorch container optimized for Grace Blackwell
docker pull nvcr.io/nvidia/pytorch:24.08-py3

# Run the container with GPU access
docker run -it --gpus=all nvcr.io/nvidia/pytorch:24.08-py3
```

--------------------------------

### Downloading GRUB Binaries

Source: https://docs.nvidia.com/dgx/dgx-spark/pxe.html

Commands to download the signed GRUB EFI binary and place it in the TFTP root directory.

```bash
cd /tmp
wget -q http://ports.ubuntu.com/ubuntu-ports/dists/jammy/main/uefi/grub2-arm64/current/grubnetaa64.efi.signed
cp grubnetaa64.efi.signed /local/tftp/
```

--------------------------------

### Execute hook.sh Automation

Source: https://docs.nvidia.com/dgx/dgx-spark/enterprise-custom-install.html

Run the hook.sh script with required environment variables to automate mirror setup and updates.

```bash
export MIRROR_SERVER_IP=192.168.1.1
export MIRROR_SERVER_PORT=8080
export LVFS_METADATA_NAME=firmware.xml.xz   # or firmware-08681-stable.xml.xz
export LVFS_WEB_SUBDIR=lvfs
sudo -E /path/to/oemdata/hook.sh
```
Tokens:
Raw