{"slug": "can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev", "title": "Can Docker Sandboxes Run on NVIDIA Arm? I Tried It on a GH200 with NVIDIA Brev", "summary": "A Docker Sandbox microVM booted on a bare-metal NVIDIA GH200 Grace Hopper server running NVIDIA's 64 KB page kernel in about 15 minutes from a blank NVIDIA Brev account, according to a hands-on test by Ajeet Raina. The test found Docker Sandboxes (`sbx`) work on Arm hosts, but GPU passthrough remains x86_64-only, so the GH200's GPU stays on the host and the sandbox receives only CPU and memory. Raina rented the GH200 from DMZ (LaunchPad) on NVIDIA Brev at $3.36/hr with 72 Grace cores and 480 GB RAM, noting Arm cloud VMs almost never offer the nested virtualization local sandboxes require, making bare metal necessary.", "body_md": "# Can Docker Sandboxes Run on NVIDIA Arm? I Tried It on a GH200 with NVIDIA Brev\n\nI ran Docker Sandboxes on a bare-metal NVIDIA GH200 via NVIDIA Brev. It works on Arm, even with the 64K kernel. Here's every step and what's inside.\n\nYes. A Docker Sandbox microVM booted on a bare-metal NVIDIA GH200 Grace Hopper server, running NVIDIA's 64 KB page kernel, in about 15 minutes from a blank NVIDIA Brev account. The catch: the GPU stays on the host, because sandbox GPU passthrough only works on x86 today.\n\nLots of people now run AI agents on NVIDIA Arm machines like DGX Spark, Jetson and Grace servers. Docker Sandboxes (`sbx`) puts each agent in its own microVM with its own kernel. I wanted to know if that works on NVIDIA's Arm hardware. I don't have a Grace machine on my desk, so I rented one on [NVIDIA Brev](https://brev.nvidia.com/?ref=ajeetraina.com) and tested it step by step.\n\nIn this post you will see:\n\n- What Docker Sandboxes needs from the host machine\n- How to pick a bare-metal Arm server on NVIDIA Brev\n- Every command I ran, with the real output\n- What the microVM sees from the inside\n- What this tells us about DGX Spark and Jetson\n\n## What Docker Sandboxes needs from the host\n\nOn Linux, a local sandbox needs Ubuntu 24.04 or later, a 64-bit Intel, AMD or Arm CPU, and KVM turned on. Your user must also be in the `kvm` group. These come from the [Docker Sandboxes install docs](https://docs.docker.com/ai/sandboxes/install/?ref=ajeetraina.com).\n\n| Requirement | What it means | \n|---|---|\n| Ubuntu 24.04 or later | Ubuntu derivatives are not tested or supported | \n| 64-bit CPU | Intel, AMD or Arm all work | \n| KVM | Hardware virtualization must be on. Inside a VM, the cloud must support nested virtualization | \n| `kvm` group | Your user needs access to `/dev/kvm` | \n| GPU passthrough (`--gpu` ) | Experimental, x86_64 only, needs a spare NVIDIA GPU and IOMMU ([docs](https://docs.docker.com/ai/sandboxes/configuration/gpu-passthrough/?ref=ajeetraina.com) ) | \n\nTwo things matter for NVIDIA Arm boxes. First, Arm cloud VMs almost never offer nested virtualization, so you need bare metal. The [Arm install guide for sbx](https://learn.arm.com/install-guides/sbx/?ref=ajeetraina.com) says the same. Second, GPU passthrough is x86 only, so on Arm the sandbox gets CPU and memory but no GPU.\n\nCloud sandboxes don't need any of this, since they run on Docker's side. This post is only about local sandboxes.\n\n## Picking a bare-metal Arm box on NVIDIA Brev\n\nI picked the GH200 from DMZ (LaunchPad), because it was the only NVIDIA Arm option that looked like a whole physical server. [NVIDIA Brev](https://brev.nvidia.com/?ref=ajeetraina.com) lets you rent GPU machines from many clouds in one place. It has no Jetson or DGX Spark in the cloud, but it does have two NVIDIA Arm families.\n\n| Option | CPU | RAM | Price | Bare metal? | \n|---|---|---|---|---|\n| GH200, DMZ (LaunchPad) | 72 Grace cores | 480 GB | $3.36/hr | Likely, it's the full chip | \n| GH200, Lambda | 64 cores | 432 GiB | $3.11/hr | Likely a VM | \n| T4g x2, AWS | 64 Graviton2 cores | 128 GiB | $3.29/hr | Size matches AWS `g5g.metal` | \n| T4g x1, AWS | 4 to 32 cores | 8 to 64 GiB | $0.50 to $1.65/hr | VMs | \n\nThe GH200 is also the closest cousin to DGX Spark, since both use NVIDIA's own Grace-family chips. If you own a DGX Spark, Brev Connect can add it to your Brev account instead.\n\nIn the Brev console I went to **Compute**, then **Create a cloud instance**, picked the **GH200** family and chose the **DMZ (launchpad)** option. I kept the default software setup, **VM Mode w/ Jupyter**, named the instance `sbx-kvm-gh200` and clicked **Deploy**.\n\nOne thing to know before you click Deploy: this instance type can't be stopped, only deleted. It bills from the moment it starts until you delete it.\n\n## Launching the instance\n\nThe instance was ready about 4 minutes after I clicked Deploy, with 0 errors in the build log. Brev's setup script runs first, then installs `uv`, Python 3.12 and JupyterLab for the default user, `nvidia`.\n\nHere is the build log, trimmed to the important lines:\n\n```\n--- instance exec attempt 1 ---\n/bin/bash\nBREV_ENV_ID=mw0ghvcnl\n[INFO] [2026-11-22T04:34:13+0000] Starting instance bootstrap oneshot script\n[INFO] [2026-11-22T04:34:13+0000] Setting up instance-oneshot service\n[INFO] [2026-11-22T04:34:13+0000] Creating systemd service file\n[INFO] [2026-11-22T04:34:13+0000] Starting instance-oneshot service\n[INFO] [2026-11-22T04:36:11+0000] Service has exited after 0s\n[INFO] [2026-11-22T04:36:11+0000] Instance bootstrap oneshot script completed\nInstalling uv...\ndownloading uv 0.13.9 aarch64-unknown-linux-gnu\ninstalling to /home/nvidia/.local/bin\nInstalling Python 3.12 with uv...\nInstalled Python 3.12.16 in 405ms\nInstalling JupyterLab in virtual environment...\nInstalled 90 packages in 66ms\n + jupyterlab==4.6.6\nCreating JupyterLab systemd service...\nBuild completed successfully.\n```\n\nTo get a shell, install the Brev CLI on your laptop and connect:\n\n```\nbrew install brevdev/homebrew-brev/brev\nbrev login\nbrev shell sbx-kvm-gh200\n```\n\n## Checking the host: bare metal and KVM\n\nThe machine passed every check except one: my user wasn't in the `kvm` group yet. I ran this block to check the OS, CPU, KVM and GPU in one go:\n\n```\necho \"=== OS ===\"; cat /etc/os-release | head -4; uname -a\necho \"=== CPU ===\"; lscpu | grep -E \"Architecture|Model name|^CPU\\(s\\)|Virtualization|Hypervisor\"\necho \"=== Bare metal or VM? ===\"; systemd-detect-virt; cat /sys/class/dmi/id/sys_vendor /sys/class/dmi/id/product_name 2>/dev/null\necho \"=== KVM ===\"; ls -l /dev/kvm; lsmod | grep kvm; sudo dmesg | grep -i kvm | head -5\necho \"=== Groups ===\"; id\necho \"=== GPU ===\"; nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv\necho \"=== RAM/Disk ===\"; free -h | head -2; df -h / | tail -1\n```\n\nThe output:\n\n```\n=== OS ===\nPRETTY_NAME=\"Ubuntu 24.04.5 LTS\"\nNAME=\"Ubuntu\"\nVERSION_ID=\"24.04\"\nVERSION=\"24.04.5 LTS (Noble Numbat)\"\nLinux brev-mw0ghvcnl 7.0.0-1025-nvidia-64k #26~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Nov  3 21:35:34 UTC 2 aarch64 aarch64 aarch64 GNU/Linux\n=== CPU ===\nArchitecture:                            aarch64\nCPU(s):                                  72\nModel name:                              Neoverse-V2\n=== Bare metal or VM? ===\nnone\nQuanta Cloud Technology Inc.\nQuantaGrid S74G-2U 1S7GZBZ0001\n=== KVM ===\ncrw-rw---- 1 root kvm 10, 232 Nov 19 02:42 /dev/kvm\n[    1.616107] kvm [1]: nv: 570 coarse grained trap handlers\n[    1.616133] kvm [1]: nv: 664 fine grained trap handlers\n[    1.616185] kvm [1]: IPA Size Limit: 48 bits\n[    1.621798] kvm [1]: GICv4 support disabled\n[    1.621799] kvm [1]: GICv3: no GICV resource entry\n=== Groups ===\nuid=1000(nvidia) gid=1000(nvidia) groups=1000(nvidia),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),101(lxd),988(docker)\n=== GPU ===\nname, driver_version, memory.total [MiB]\nNVIDIA GH200 480GB, 595.91.07, 97871 MiB\n=== RAM/Disk ===\n               total        used        free      shared  buff/cache   available\nMem:           573Gi        46Gi       534Gi        82Mi        24Gi       526Gi\n/dev/mapper/ubuntu--vg-ubuntu--lv  877G   13G  820G   2% /\n```\n\nWhat this tells us:\n\n- **It's bare metal.**`systemd-detect-virt` prints`none` , and the hardware is a QuantaGrid S74G-2U server.\n- **The OS fits.** Ubuntu 24.04.5 meets the sbx requirement.\n- **KVM is ready.**`/dev/kvm` exists and the kernel set up KVM at boot.`lsmod` shows nothing because KVM is built into this kernel, not loaded as a module.\n- **The user needs a fix.**`nvidia` is in the`docker` group but not the`kvm` group.\n- **The kernel uses 64 KB pages.** This is NVIDIA's`nvidia-64k` kernel. Most microVM tools are tested on 4 KB pages, so I expected this could cause trouble.\n\nOne more detail: `free` shows 573 GiB, more than the 480 GB Brev lists. On GH200 the GPU's 96 GB of HBM can show up as system memory too.\n\n## Installing sbx and starting the first sandbox\n\nThe first sandbox started on the first try, 64 KB kernel and all. You don't need Docker Desktop or Docker Engine for sbx. Add Docker's package repository, install the `docker-sbx` package, and add yourself to the `kvm` group:\n\n```\ncurl -fsSL https://get.docker.com | sudo REPO_ONLY=1 sh\nsudo apt install -y docker-sbx\nsudo usermod -aG kvm $USER\nnewgrp kvm\nsbx version\nsbx login\n```\n\n`sbx login` gives you a link to sign in to Docker Hub in your browser.\n\nNext, make a project folder and start a plain shell sandbox. A shell sandbox needs no model API key, which keeps the test simple:\n\n```\nmkdir -p ~/sbx-test && cd ~/sbx-test\nsbx run shell .\n```\n\nThe sandbox boots and drops you into a prompt inside the microVM:\n\n```\n  Docker Sandbox Kit by DHI\n  shell-sbx-test\n  shell 1.1.0\n\n✓ agent@shell-sbx-test:/home/nvidia/sbx-test$\n```\n\nThe sandbox is named `shell-sbx-test` and uses the `shell 1.1.0` template, which is built on Docker Hardened Images. Your project folder shows up inside at the same path, `/home/nvidia/sbx-test`.\n\n## Looking inside the microVM\n\nThe sandbox is a real VM with its own kernel, a slice of the CPU and memory, and no GPU. I ran these commands inside it:\n\n```\nuname -a; nproc; free -h\ncat /proc/cpuinfo | grep -m3 -E \"CPU implementer|CPU part|Features\"\ngetconf PAGESIZE\nls /dev/kvm /dev/nvidia* 2>&1\n```\n\nThe output:\n\n```\nLinux shell-sbx-test 7.0.14 #1 SMP PREEMPT Sat Nov  7 12:31:08 UTC 2026 aarch64 GNU/Linux\n16\n               total        used        free      shared  buff/cache   available\nMem:            31Gi       428Mi        30Gi        92Ki       220Mi        30Gi\nSwap:             0B          0B          0B\nFeatures        : fp asimd aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm jscvt fcma lrcpc dcpop sha3 sm3 sm4 asimddp sha512 asimdfhm dit uscat ilrcpc flagm ssbs sb dcpodp flagm2 frint i8mm bf16 dgh\nCPU implementer : 0x41\nCPU part        : 0xd4f\n4096\nls: cannot access '/dev/kvm': No such file or directory\nls: cannot access '/dev/nvidia*': No such file or directory\n```\n\nHere is how the host and the sandbox compare:\n\n|  | Host (GH200) | Sandbox (microVM) | \n|---|---|---|\n| Kernel | 7.0.0-1025-nvidia-64k (NVIDIA) | 7.0.14 (built by Docker, Nov 7 2026) | \n| CPUs | 72 | 16 | \n| Memory | 573 GiB | 31 GiB | \n| Page size | 64 KB | 4 KB | \n| `/dev/kvm` | Yes | No | \n| GPU | GH200, 96 GB | None | \n\nWhat stands out:\n\n- **Different kernel.** The sandbox boots its own Linux 7.0.14, not the host kernel. That's the main difference from a container.\n- **Same CPU.** Implementer`0x41` is Arm, and part`0xd4f` is Neoverse V2, the Grace core. Flags like`bf16` and`i8mm` pass straight through.\n- **Page size is not a problem.** The host runs 64 KB pages, but the sandbox kernel picks its own 4 KB pages. Grace users can keep NVIDIA's 64K kernel.\n- **No GPU and no nested KVM.** This is expected on Arm, where sbx GPU passthrough is not supported.\n\n## What this means for DGX Spark and Jetson\n\nIf an NVIDIA Arm box runs Ubuntu 24.04 with `/dev/kvm` on bare metal, sbx should work. I only tested the GH200, so treat the rest of this table as my best guess until someone tries it.\n\n| Device | Will a sandbox start? | GPU inside the sandbox? | \n|---|---|---|\n| GH200 (tested) | Yes | No | \n| DGX Spark (GB10) | Likely. DGX OS is based on Ubuntu 24.04. Check for `/dev/kvm` | No. Passthrough is x86 only, and the GPU is part of the chip | \n| Jetson Thor | Possible, needs testing | No | \n| Jetson Orin Nano | Unlikely. JetPack 6 is based on Ubuntu 22.04, and KVM may not be enabled | No | \n\nTo check any machine, run these three commands. You want Ubuntu 24.04 or later, a `/dev/kvm` device, and `none` from `systemd-detect-virt`:\n\n```\ngrep VERSION_ID /etc/os-release\nls -l /dev/kvm\nsystemd-detect-virt\n```\n\nThe GPU limit is less of a problem than it sounds. An agent doesn't need to drive the GPU itself, it only needs a model to call. The next step for this setup is to run Docker Model Runner on the host GPU and let the sandboxed agent reach it at `host.docker.internal:12434`. The agent stays locked in its microVM, and the model gets the full GPU.\n\n## Clean up and wrap up\n\nDelete the instance as soon as you're done, because a DMZ GH200 can't be stopped and bills at $3.36 an hour until it's gone. Leave the sandbox with `exit`, then delete the instance from the Brev console with the **Delete** button, or from your laptop:\n\n```\nbrev delete sbx-kvm-gh200\n```\n\nThe whole test took about 15 minutes and cost about a dollar.\n\nTo sum up:\n\n- Docker Sandboxes runs on NVIDIA Grace Hopper, on bare metal, with NVIDIA's 64 KB page kernel.\n- Each sandbox gets its own kernel, its own share of the CPU and memory, and the full Grace CPU features.\n- The GPU stays on the host for now, because sbx GPU passthrough is x86 only.\n- NVIDIA Brev is a quick way to try this without owning the hardware. Pick a bare-metal Arm option.\n\nIf you have a DGX Spark or a Jetson Thor, try the three checks above and tell me what you find.", "url": "https://wpnews.pro/news/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev", "canonical_source": "https://www.ajeetraina.com/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev/", "published_at": "2026-11-22 04:54:53+00:00", "updated_at": "2026-11-22 15:49:20.578937+00:00", "lang": "en", "topics": ["ai-agents", "ai-infrastructure", "developer-tools"], "entities": ["Docker", "Docker Sandboxes", "NVIDIA", "NVIDIA GH200 Grace Hopper", "NVIDIA Brev", "DMZ (LaunchPad)", "DGX Spark", "Jetson"], "also_reported_by": [], "takeaway": "Docker Sandboxes run on Arm hosts like the GH200 with the 64 KB page kernel, but GPU passthrough is x86_64-only, so Arm sandboxes get CPU and memory only and require bare metal since Arm cloud VMs rarely support nested virtualization.", "recommendation": {"advice": "Run agent sandboxes on bare-metal Arm hosts with KVM enabled, since Arm cloud VMs rarely support nested virtualization, and keep GPU work on the host because passthrough is x86_64-only.", "playbook": "agent-security", "playbook_url": "https://wpnews.pro/playbooks/agent-security"}, "alternates": {"html": "https://wpnews.pro/news/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev", "markdown": "https://wpnews.pro/news/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev.md", "text": "https://wpnews.pro/news/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev.txt", "jsonld": "https://wpnews.pro/news/can-docker-sandboxes-run-on-nvidia-arm-i-tried-it-on-a-gh200-with-nvidia-brev.jsonld"}}