Inhoudsopgave

  1. Architectuuroverzicht
  2. Vereisten
  3. Voorbereiding van de DGX Spark-nodes
  4. Aansluiting van het managementnetwerk (10GbE)
  5. Fysieke aansluiting van het compute-netwerk (200GbE QSFP)
  6. sparkrun installeren op de Spark-nodes
  7. Snelheidstests en RDMA-tests
  8. Modellen draaien met sparkrun
  9. Resultaten en verificatie
  10. Probleemoplossing
NVIDIA DGX Spark Bundle

NVIDIA DGX Spark Bundle

2 DGX Spark-nodes, 200GbE RoCEv2 RDMA en sparkrun-clusterbeheer voor een end-to-end AI-infrastructuur.

Dit product kopen →

Dit document beschrijft de volledige installatie- en configuratiestappen voor een AI-cluster dat bestaat uit 2 NVIDIA DGX Spark-nodes in een point-to-point-topologie. Het cluster gebruikt de sparkrun-toolkit om gedistribueerde AI-workloads en de uitvoering van modellen te beheren.

Het document behandelt de voorbereiding van het managementnetwerk en het compute-netwerk, de configuratie van de ConnectX-7 QSFP112-poorten, de RoCEv2/RDMA-instellingen, SSH-toegang en de stappen voor de statuscontrole van het cluster.

Architectuuroverzicht

Component Beschrijving
DGX Spark × 2 Elk met een ConnectX-7 200GbE QSFP112-poort
QSFP112-kabel Amphenol: NJAAKK-N911
sparkrun Toolkit voor clusterbeheer, SSH-mesh en CX7-configuratie

Vereisten

Hardware

  • 2× NVIDIA DGX Spark-systemen
  • 1× Amphenol: NJAAKK-N911-kabel
  • Cat6-kabels (managementnetwerk)
  • 1× switch met RJ45-poorten (managementnetwerk)

Software en besturingssysteem

  • DGX OS (vooraf geïnstalleerd op elk Spark-systeem)
  • Internettoegang (voor het downloaden van pakketten en updates)

Kennis en toegang

  • Basiskennis van de Linux-opdrachtregel
  • Fysieke toegang tot alle apparaten (voor het aansluiten van de kabels)

Installatie van DGX Spark OS

U kunt de volgende video gebruiken voor de installatie van DGX Spark OS:

NVIDIA DGX Spark Kurulumu Part 1

Voorbereiding van de DGX Spark-nodes

Zorg ervoor dat alle Spark-systemen de nieuwste software- en firmwareversies draaien voordat u verdergaat met de fysieke verbindingen en de netwerkconfiguratie. Een aanzienlijk deel van de prestatieproblemen die tijdens de installatie optreden, komt voort uit verouderde drivers, ontbrekende updates of incompatibele firmware.

De volgende stappen moeten op beide Spark-systemen worden uitgevoerd.

Updates van systeem en firmware

Werk eerst de pakketten van het besturingssysteem bij:

sudo apt update
sudo apt dist-upgrade

Werk daarna de systeemfirmware bij:

sudo fwupdmgr refresh --force
sudo fwupdmgr upgrade

Controleer in het DGX Dashboard of er updates beschikbaar zijn en installeer deze als dat het geval is:

Start het systeem opnieuw op nadat de updates zijn voltooid:

sudo reboot

Tijdens het testen werd vastgesteld dat verouderde firmwareversies ertoe leidden dat de verbindingsprestaties achterbleven bij het verwachte niveau. Daarom wordt aanbevolen om als eerste stap alle systemen bij te werken.

Docker-configuratie

Om de containergebaseerde tools die in de volgende stappen worden gebruikt zonder sudo te kunnen draaien, worden op elke Spark de post-installatiestappen van Docker uitgevoerd.

Voeg eerst de huidige gebruiker toe aan de Docker-groep:

sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker

Controleer de configuratie met de volgende test:

docker run hello-world

Als de opdracht met succes wordt uitgevoerd en Docker de voorbeeldcontainer kan starten, is bevestigd dat de benodigde voorbereiding voor de containergebaseerde tools in de volgende stappen voltooid is.

De storage driver controleren

Daarnaast werd op alle Spark-nodes de storage driver van Docker gecontroleerd. De uitvoer van docker info bevestigde dat de waarde van Storage Driver overlayfs is. Als overlay2 of een andere storage driver werd aangetroffen, werd Docker geconfigureerd om de containerd-snapshotter (overlayfs) te gebruiken en werd de Docker-service opnieuw gestart. Zo werd een consistente runtime-omgeving op alle nodes gewaarborgd.

Eerst werd de huidige storage driver gecontroleerd met de volgende opdracht:

docker info -f 'Driver= DriverStatus= DockerRootDir='

Als de uitvoer overlay2 toont, werd de volgende configuratie toegepast:

sudo tee /etc/docker/daemon.json >/dev/null <<'EOF'
{
  "features": {
    "containerd-snapshotter": true
  }
}
EOF

sudo systemctl restart docker

Na de configuratie werd dezelfde controleopdracht opnieuw uitgevoerd en werd bevestigd dat de storage driver overlayfs is.

Aansluiting van het managementnetwerk (10GbE)

De 10GbE-ethernetpoort van elke DGX Spark wordt met een Cat6-kabel aangesloten op een van de RJ45-poorten van de switch. Controleer na het aansluiten of de linkindicator van de betreffende poort op de switch brandt.

Open een terminal op het bureaublad van de Spark en controleer of het apparaat een IP-adres heeft gekregen:

ip addr show

Als u, zoals in het voorbeeld, een IP-adres op de 10GbE-interface ziet, is SSH-toegang via het managementnetwerk beschikbaar. Als er geen IP-adres is toegewezen, wijs er dan handmatig een toe via het bureaublad van DGX OS:

  1. Klik op het netwerkpictogram in de rechterbovenhoek → selecteer Wired Settings
  2. Klik op het tandwielpictogram (⚙) naast de betreffende 10GbE-verbinding
  3. Ga naar het tabblad IPv4
  4. Wijzig Method in Manual
  5. Voer de volgende gegevens in:
    • Address: 192.168.1.148 (verschillend voor elke Spark, bijv. .147 — pas dit aan uw netwerk aan)
    • Netmask: 255.255.255.0
    • Gateway: 192.168.1.1 (indien beschikbaar, laat het veld anders leeg)
    • DNS: 1.1.1.1,8.8.8.8
  6. Klik op Apply en schakel de verbinding uit en weer in

Als er internettoegang is, is de 10GbE-managementverbinding gereed. Herhaal dezelfde stappen op het andere Spark-systeem en wijs daarbij een ander IP-adres toe.

Controle van de verbinding tussen de nodes

Controleer of alle Spark-systemen elkaar via het managementnetwerk kunnen zien. Ping vanaf de ene Spark de andere:

ping -c 4 192.168.1.148

Als alle pings slagen, is het managementnetwerk gereed en kunnen alle nodes met elkaar communiceren.

Fysieke aansluiting van het compute-netwerk (200GbE QSFP)

In deze opstelling zijn de twee Spark-systemen via hun ConnectX-7 QSFP112-poorten met 200GbE met elkaar verbonden.

Kabelplan

De poorttoewijzing voor de fysieke verbinding tussen de twee Spark-systemen is als volgt:

Bron Bestemming
Spark1 Port0 Spark2 Port0

sparkrun installeren op de Spark-nodes

Configuratie van gebruiker en SSH

Nadat de netwerkconfiguratie is voltooid, moet op alle nodes een gemeenschappelijke gebruiker worden aangemaakt, zodat de Spark-systemen zonder wachtwoord met elkaar kunnen communiceren. sparkrun gebruikt deze gebruiker om via SSH verbinding te maken met alle nodes en de clusterbeheertaken uit te voeren.

Hostnamen instellen Geef elke Spark een unieke hostnaam. Dit is essentieel voor het beheer van SSH known_hosts, voor loganalyse en om de nodes van het cluster te kunnen volgen:

# On Spark 1:
sudo hostnamectl set-hostname spark1

# On Spark 2:
sudo hostnamectl set-hostname spark2

Een gedeelde gebruiker aanmaken Op alle Spark-systemen moet dezelfde gebruikersnaam worden aangemaakt. In dit document wordt de gebruikersnaam nvidia gebruikt. Voer de volgende opdrachten uit op beide Spark-systemen:

sudo useradd -m nvidia
sudo usermod -aG sudo nvidia
sudo passwd nvidia

Gebruik op alle systemen hetzelfde wachtwoord — dat vereenvoudigt het beheer. Tijdens het opzetten van de SSH-mesh door sparkrun wordt dit wachtwoord bij de eerste verbinding gevraagd; daarna neemt authenticatie op basis van sleutels het over.

Sudo zonder wachtwoord configureren

sparkrun voert tijdens de CX7-netwerkconfiguratie opdrachten uit met sudo. Om te voorkomen dat er telkens om een wachtwoord wordt gevraagd, moet sudo zonder wachtwoord worden geconfigureerd:

echo "nvidia ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/nvidia
sudo chmod 440 /etc/sudoers.d/nvidia

Installatie van sparkrun

De installatie wordt uitgevoerd onder het gebruikersaccount nvidia.

su - nvidia

Installeer eerst het pakket uv:

curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

Installeer daarna sparkrun:

uvx sparkrun setup

Beantwoord de vragen tijdens de installatie:

  1. Voer eerst de IP-adressen van de apparaten in:
  2. Geef het cluster een naam
  3. Voer nvidia in als SSH-gebruikersnaam (aangemaakt in de vorige stap)

  4. Kies Y voor de MESH-installatie

  5. Antwoord Y op “Configure CX7 networking?”:

  6. Antwoord Y op “Add ‘nvidia’ to the docker group on all hosts?”
  7. Antwoord Y op “Generate the NVIDIA CDI spec on all hosts?”
  8. Antwoord Y op “Install sudoers entries?”
  9. Antwoord Y op “Install earlyoom?”

  10. Wanneer het bericht “Setup complete” verschijnt, is de installatie met succes voltooid

Snelheidstests en RDMA-tests

In deze stap controleren we of het compute-netwerk correct functioneert en of de RDMA-communicatie via RoCEv2 naar verwachting presteert.

Referentie voor IP-toewijzing Hieronder staan de IP-adressen die de sparkrun-wizard aan de CX7-interfaces heeft toegewezen. Gebruik in uw scenario in plaats daarvan uw eigen adressen:

Spark Management (enP7s7) enp1s0f1np1 enP2p1s0f1np1
Spark 1 192.168.1.148 192.168.0.148 192.168.2.148
Spark 2 192.168.1.147 192.168.0.147 192.168.2.147

In de huidige topologie zijn er 2 subnetten tussen de nodes. De tests worden op één subnet uitgevoerd; de tests voor het andere subnet kunnen op dezelfde manier worden herhaald:

  • Subnet 1: 192.168.0.0/24
  • Subnet 2: 192.168.2.0/24

IP- en MTU-test Test vanaf Spark 1 de connectiviteit en jumboframes door Spark 2 te pingen:

# On Spark 1:
ping -c 4 192.168.0.147
ping -M do -s 8972 -c 4 192.168.0.147

De eerste ping test de basisconnectiviteit; de tweede test een MTU van 9000 bytes. -M do verhindert fragmentatie — als het pakket niet wegvalt, werkt MTU 9000 end-to-end.

TCP-doorvoertest (iperf3) Meet de basisbandbreedte (bandwidth) over de Ethernet/IP-laag. Deze test is geen RDMA — hij gebruikt TCP, waarbij de CPU betrokken is.

# On Spark 2 (server):
iperf3 -s
# On Spark 1 (client):
iperf3 -c 192.168.0.147 -P 8 -t 30

-P 8 betekent acht parallelle streams, -t 30 een testduur van dertig seconden. Verwacht resultaat: in totaal ~100-120 Gbps doorvoer (throughput).

Opmerking: installeer iperf3 als het nog niet is geïnstalleerd:

sudo apt install iperf3

RDMA-apparaten identificeren Toon de namen van de RDMA-apparaten:

ibdev2netdev

Voorbeelduitvoer: rocep1s0f0 port 1 ==> enp1s0f0np0 (Down) rocep1s0f1 port 1 ==> enp1s0f1np1 (Up) roceP2p1s0f0 port 1 ==> enP2p1s0f0np0 (Down) roceP2p1s0f1 port 1 ==> enP2p1s0f1np1 (Up)

RDMA-schrijftest (ib_write_bw) Meet de bandbreedte van RDMA-schrijfbewerkingen via RoCEv2. Hiermee wordt directe geheugenoverdracht zonder betrokkenheid van de CPU getest.

Subnet 1: Op Spark 2 (server):

ib_write_bw -d rocep1s0f1 -F --report_gbits

Op Spark 1 (client):

ib_write_bw -d rocep1s0f1 -F --report_gbits 192.168.0.147

Verwacht resultaat: ~100-111 Gbps.

Subnet 2: Op Spark 2 (server):

ib_write_bw -d roceP2p1s0f1 -F --report_gbits

Op Spark 1 (client):

ib_write_bw -d roceP2p1s0f1 -F --report_gbits 192.168.2.147

Verwacht resultaat: ~100-111 Gbps.

Als beide interfaces ~100 Gbps leveren, is er tussen de Spark-systemen in totaal ~200 Gbps RDMA-bandbreedte beschikbaar.

RDMA-leestest (ib_read_bw) Meet de bandbreedte van RDMA-leesbewerkingen:

Subnet 1: Op Spark 2 (server):

ib_read_bw -d rocep1s0f1 -F --report_gbits

Op Spark 1 (client):

ib_read_bw -d rocep1s0f1 -F --report_gbits 192.168.0.147

Verwacht resultaat: ~95-110 Gbps.

Subnet 2: Op Spark 2 (server):

ib_read_bw -d roceP2p1s0f1 -F --report_gbits

Op Spark 1 (client):

ib_read_bw -d roceP2p1s0f1 -F --report_gbits 192.168.2.147

Verwacht resultaat: ~95-110 Gbps.

RDMA-latentietest (ib_write_lat) Op Spark 2 (server):

ib_write_lat -d rocep1s0f1

Op Spark 1 (client):

ib_write_lat -d rocep1s0f1 192.168.0.147

Verwacht resultaat: een latentie (latency) van ~1-3 microseconden.

Modellen draaien met sparkrun

In deze stap draaien we via sparkrun een inferentieworkload (inference) over meerdere nodes om te controleren of het cluster end-to-end werkt.

Model en recipe Voor deze test wordt het model nvidia/MiniMax-M2.7-NVFP4 gebruikt. Het model draait met tensorparallellisme (tensor parallelism, TP=2) over 2 nodes. Het ingebouwde recipe van sparkrun is geconfigureerd voor de runtime vllm-distributed; daarom is een eigen YAML-bestand opgesteld om voor 2 nodes de runtime vllm-ray te gebruiken.

Het model draaien Sla het volgende YAML-bestand op als minimax-M2.7-nvfp4.yaml:

model: nvidia/MiniMax-M2.7-NVFP4
name: MiniMax-M2.7-NVFP4
runtime: vllm-ray
min_nodes: 2
container: sparkrun-eugr-vllm

defaults:
  max_model_len: 196608
  host: 0.0.0.0
  port: 8000
  tensor_parallel: 2
  gpu_memory_utilization: 0.85
  reasoning_parser: minimax_m2
  tool_call_parser: minimax_m2
  load_format: instanttensor
  pipeline_parallel: 1
recipe_version: '2'
env:
  VLLM_MARLIN_USE_ATOMIC_ADD: '1'
builder: eugr
metadata:
  quantization: nvfp4
  head_dim: 128
  num_kv_heads: 8
  description: MiniMax-M2.7 NVFP4 (NVIDIA quant)
  kv_dtype: fp8
  model_dtype: nvfp4
  quant_bits: 4
  num_layers: 62

command: |-
  vllm serve {model} \
    --trust-remote-code \
    --gpu-memory-utilization {gpu_memory_utilization} \
    -tp {tensor_parallel} \
    -pp {pipeline_parallel} \
    --max-model-len {max_model_len} \
    --load-format {load_format} \
    --enable-auto-tool-choice \
    --tool-call-parser {tool_call_parser} \
    --reasoning-parser {reasoning_parser} \
    --host {host} \
    --port {port}

Start daarna het model:

sparkrun run minimax-M2.7-nvfp4.yaml

SSH-autorisatiefout oplossen Als u na het uitvoeren van de opdracht een autorisatiegerelateerde fout krijgt wanneer sparkrun verbinding probeert te maken met zichzelf, gebruik dan de volgende opdracht en voer sparkrun opnieuw uit:

cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys

Controleren of het model gereed is Wanneer het model start, ziet u het bericht “Application startup complete.”; dit geeft aan dat het model klaar is voor gebruik:

Benchmarkresultaten De gemiddelde waarden uit tests met de benchmarktool op het op deze manier uitgerolde model zijn als volgt:

Gelijktijdige verzoeken TTFT (ms) Token/s Latentie (s) Doorvoer (RPS)
1 245 26.27 4.87 0.21
2 299 22.34 5.74 0.17
4 386 17.24 7.43 0.13
8 450 12.69 10.09 0.10
16 435 9.05 14.16 0.07

Resultaten en verificatie

Door de stappen in dit document te volgen, wordt een volledig functioneel DGX Spark AI-cluster opgezet dat uit de volgende componenten bestaat:

Component Status Verificatiemethode
Managementnetwerk (10GbE) Gereed Ping tussen de nodes geslaagd
Compute-netwerk (200GbE QSFP) Gereed ib_write_bw ~100-111 Gbps
RoCEv2 / RDMA Gereed ib_write_lat ~1-3 µs
sparkrun-cluster Gereed sparkrun setup voltooid
Modelservice Gereed Bericht “Application startup complete.”

Samenvatting van de statuscontrole van het cluster

U kunt de volgende controles uitvoeren om te verifiëren dat de installatie voltooid is:

  1. Managementnetwerk: Kunnen alle nodes elkaar pingen?
  2. Compute-netwerk: Levert elk subnet ~100 Gbps in de test ib_write_bw?
  3. MTU: Slaagt de test ping -M do -s 8972 zonder pakketverlies?
  4. sparkrun-mesh: Werkt SSH-toegang zonder wachtwoord naar alle nodes?
  5. Model: Komen de benchmarkresultaten overeen met de tabel hierboven?

Als alle controles slagen, is het cluster gereed voor AI-workloads.

Probleemoplossing

De storage driver van Docker toont overlay2

Als u overlay2 ziet in de uitvoer van docker info, voeg dan de feature containerd-snapshotter toe aan het bestand /etc/docker/daemon.json en start Docker opnieuw (zie Docker-configuratie).

Jumboframetest met ping -M do mislukt

Controleer of de MTU-waarden van de CX7-interfaces aan de kant van de Spark op 9000 zijn ingesteld: ip link show.

Lage RDMA-bandbreedte (onder ~100 Gbps)

  • Controleer of alle systeem- en firmware-updates zijn toegepast (zie Updates van systeem en firmware).
  • Controleer of de kabels goed vastzitten.
  • Controleer de toewijzing van interfaces aan apparaten met de uitvoer van ibdev2netdev.

SSH-autorisatiefout bij sparkrun

Als u bij het uitvoeren van sparkrun een autorisatiefout krijgt:

cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys

Voer de bovenstaande opdracht uit en voer sparkrun opnieuw uit.

NVIDIA DGX Spark Bundle

NVIDIA DGX Spark Bundle

2 DGX Spark-nodes, 200GbE RoCEv2 RDMA en sparkrun-clusterbeheer voor een end-to-end AI-infrastructuur.

Dit product kopen →