Asus Ascent GX10: Create a Useful Rescue Image Including Clonezilla

Using the Asus Ascent GX10 installation ISO for regular disk backups is a bit cumbersome and risky. Hit Enter too quickly, and boom—the NVMe drive gets overwritten.
You can boot into a rescue system after a few menu steps, but it lacks the better tools like dc3dd, gddrescue, and Clonezilla. It took me a while to find the guide on how to create a rescue image from the ISO and some ARM package downloads. Here’s my guide on how to do it—it might save you a few extra trips down that road (in german, just translate if if necessary):

# ASUS Ascent GX10 (NVIDIA Grace Blackwell): Autarkes Rescue-, Forensik- & Clonezilla-System (Offline)
​
Diese Anleitung beschreibt Schritt für Schritt die Erstellung eines maßgeschneiderten, hardware-kompatiblen USB-Rettungsmediums für das ASUS Ascent GX10. Es kombiniert den herstellereigenen NVIDIA-ARM64-Kernel mit einer autarken Offline-Toolsuite (`dc3dd`, `gddrescue`, `nvme-cli`, `zstd` und `clonezilla`).
​
---
​
## 1. Voraussetzungen & Hardware-Setup
​
* **Arbeits-PC (Linux):** Installierte Pakete: `p7zip-full`, `parted`, `dosfstools`, `dpkg-dev` (oder `apt`).
* **ASUS Ascent GX10:**
  * **Wichtig:** Keine Docking-Stations oder USB-Hubs verwenden.
  * Monitor direkt per HDMI anschließen, Tastatur direkt an einen USB-Port des Geräts.
  * Im UEFI-Setup (`Security/Boot`) zwingend **Secure Boot deaktivieren**.
​
---
​
## 2. USB-Stick vorbereiten & formatieren
​
> **Hinweis:** Prüfe mit `lsblk`, welches Device dein USB-Stick ist (nachfolgend `/dev/sda` – bitte bei Abweichung anpassen).
​
```bash
# 1. Bestehende Mounts lösen
sudo umount /dev/sda* 2>/dev/null || true
​
# 2. Dateisystem-Signaturen und alte GPT-Partitionstabellen löschen
sudo wipefs -a /dev/sda
sudo dd if=/dev/zero of=/dev/sda bs=1M count=10 status=progress
​
# 3. Frische GPT-Partitionstabelle anlegen & FAT32-Partition (Label: GX10RESCUE) erstellen
sudo parted /dev/sda --script mklabel gpt mkpart ESP fat32 1MiB 100%
sudo parted /dev/sda --script set 1 esp on
sudo mkfs.vfat -F32 -n "GX10RESCUE" /dev/sda1

3. Originales Recovery-ISO auf den USB-Stick extrahieren

Bash

# 1. USB-Stick einhängen
sudo mkdir -p /mnt/usb
sudo mount /dev/sda1 /mnt/usb
​
# 2. ASUS/NVIDIA Recovery-ISO direkt auf den Stick entpacken
# (Ersetze den Pfad durch den tatsächlichen Ort deiner ISO-Datei)
sudo 7z x /pfad/zu/asus-gx10-recovery.iso -o/mnt/usb/

4. Forensik- & Clonezilla-Pakete (ARM64) für Offline-Nutzung bereitstellen

Lade alle benötigten Werkzeuge inklusive des drbl-Basispakets und der aktuellen t64-Bibliotheken herunter:

Bash

# 1. Paketverzeichnis vorbereiten
sudo mkdir -p /mnt/usb/packages /tmp/arm64-pkgs
cd /tmp/arm64-pkgs
​
# 2. ARM64-Pakete herunterladen (ohne Fehlerumleitung für volle Sichtbarkeit)
sudo apt download \
  dc3dd:arm64 \
  gddrescue:arm64 \
  nvme-cli:arm64 \
  zstd:arm64 \
  smartmontools:arm64 \
  libsmartcols1:arm64 \
  libnvme1t64:arm64 \
  clonezilla:arm64 \
  drbl:arm64 \
  partclone:arm64 \
  dialog:arm64 \
  whiptail:arm64 \
  bc:arm64 \
  pv:arm64 \
  gdisk:arm64 \
  parted:arm64 \
  fdisk:arm64 \
  e2fsprogs:arm64 \
  dosfstools:arm64 \
  ntfs-3g:arm64 \
  btrfs-progs:arm64 \
  xfsprogs:arm64 \
  pigz:arm64 \
  pixz:arm64 \
  lzop:arm64 \
  pbzip2:arm64 \
  cifs-utils:arm64 \
  sshfs:arm64 \
  libncursesw6:arm64 \
  libtinfo6:arm64
​
# 3. Heruntergeladene Pakete auf den USB-Stick kopieren und temporäre Dateien bereinigen
sudo cp -f /tmp/arm64-pkgs/*.deb /mnt/usb/packages/
sudo rm -rf /tmp/arm64-pkgs

5. Offline-Installationsskript hinterlegen

Erstelle das Skript /mnt/usb/install-offline.sh, das die Werkzeuge im laufenden Live-System per dpkg in den Arbeitsspeicher installiert:

Bash

cat << 'EOF' | sudo tee /mnt/usb/install-offline.sh
#!/bin/bash
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
echo "==> Installiere Offline-Pakete (Forensik + Clonezilla)..."
​
# Pakete entpacken und Abhängigkeiten auflösen
dpkg -i --force-depends $DIR/packages/*.deb 2>/dev/null || true
dpkg --configure -a 2>/dev/null || true
​
# DRBL-Pfade für Clonezilla bereitstellen
export PATH="/usr/share/drbl/sbin:/usr/share/drbl/bin:$PATH"
​
echo "==> Alle Tools erfolgreich installiert!"
echo "==> dc3dd, gddrescue, nvme-cli und clonezilla stehen zur Verfügung."
EOF
​
sudo chmod +x /mnt/usb/install-offline.sh

6. Sichere GRUB-Konfiguration anlegen

Diese Konfiguration leitet den Startvorgang direkt in die isolierte rescue.target-Shell um und verhindert das automatische Re-Imaging der internen NVMe.

Bash

# GRUB-Verzeichnisse sicherstellen
sudo mkdir -p /mnt/usb/boot/grub /mnt/usb/EFI/BOOT
​
# grub.cfg anlegen
cat << 'EOF' | sudo tee /mnt/usb/boot/grub/grub.cfg
set default=0
set timeout=5
​
menuentry "ASUS GX10 Safe Forensic Rescue (NVIDIA Kernel)" {
    search --no-floppy --set=root --label GX10RESCUE
    linux /casper/vmlinuz boot=casper rescue/enable=true systemd.unit=rescue.target console=tty0 console=ttyAMA0,115200 ---
    initrd /casper/initrd
}
​
menuentry "Reboot" {
    reboot
}
​
menuentry "Shutdown" {
    halt
}
EOF
​
# Konfiguration in das UEFI-Bootverzeichnis spiegeln
sudo cp -f /mnt/usb/boot/grub/grub.cfg /mnt/usb/EFI/BOOT/grub.cfg
​
# Sicher synchronisieren und aushängen
sync
sudo umount /mnt/usb

7. Ausführung am ASUS Ascent GX10

  1. Stecke den USB-Stick in das GX10 und schalte das System ein.

  2. Wähle im Bootmenü ASUS GX10 Safe Forensic Rescue.

  3. Das System bootet über den NVIDIA-Kernel direkt in die Root-Eingabeaufforderung.

  4. Schreibschutz für die interne NVMe aktivieren (Schutz vor versehentlichem Überschreiben):

    Bash

    blockdev --setro /dev/nvme0n1
    
  5. Tools direkt aus dem automatisch eingebundenen /cdrom-Verzeichnis installieren:

    Bash

    /cdrom/install-offline.sh
    

8. Backup & Restore Workflows

Option A: Interaktive Clonezilla-Oberfläche

Starte die Klon-Oberfläche einfach über den Befehl:

Bash

clonezilla

Option B: Bitgenaues Image via dc3dd (CLI)

1. Backup erstellen (Image sichern & komprimieren)

Bash

dc3dd if=/dev/nvme0n1 hash=sha256 log=/pfad/ziel/image.log | zstd -c > /pfad/ziel/nvme0n1.raw.zst

2. Restore durchführen (Image dekomprimieren & zurückschreiben)

Wichtig: Vor dem Restore muss der Schreibschutz der NVMe wieder aufgehoben werden!

Bash

# 1. NVMe wieder beschreibbar machen
blockdev --setrw /dev/nvme0n1
​
# 2. Image dekomprimieren, schreiben und Integrität verifizieren
zstd -d -c /pfad/ziel/nvme0n1.raw.zst | dc3dd of=/dev/nvme0n1 hash=sha256 log=/pfad/ziel/restore.log

Thanks for sharing, bookmarked, will experiment!

Currently using manual dd to clone the whole 4T into NAS, pretty messy as it involves cold boot and 3-4hrs of downtime. Continue my quest for a dummy proof bare-metal backup solution ;-)

Danke für die Anleitung! :-)

Leider für mich zu wenig Schritt-für-Schritt :-(

Wäre es vielleicht möglich den fertigen Stick als Image irgendwo hochzuladen? Ich bin sicher, hunderte würden den Stick dringend benötigen und heiß lieben - nicht nur ich.

Als Hobby-Programmierer schrieb ich in 20 Jahren über 130.000 Zeilen VB-Code. Den würde ich jetzt gerne in C++ übertragen und dabei das C++ lernen. Als vorsichtiger Mensch wäre mir CloneZilla wahrlich ‘Gold wert’. Mit anderen Worten, ich würde auch dafür spenden o.ä.

Wirklich!