The tenant environment
A GPUwerk instance is your own container on a dedicated DGX Spark: not a virtual machine, not bare metal. This page tells you what that means in practice: what you can install, whether Docker and systemd work, what survives a stop or rebuild, how to start services automatically, and how the network reaches your container.
What you get
Each instance is one dedicated DGX Spark: a GB10 chip with 128 GB of unified memory shared between CPU and GPU, not split across the two. It is an ARM64 (aarch64) machine, so x86-only binaries and images do not run. Your workload runs in a container with that GPU passed straight through, and inside the container you are root. You are not root on the host.
You pick the image when you deploy: DGX OS 7 or Ubuntu 24.04 LTS, both with the CUDA 13.0 toolkit, or on GPUwerk's own Sparks a model preset (vLLM or llama.cpp serving a model) or a tool image (JupyterLab, VS Code in the browser, ComfyUI). You cannot boot your own base image, but you can install anything inside it, and on some machines run your own containers (see Docker and systemd).
The NVIDIA driver comes from the host, and the CUDA userspace comes from the image. Do not install or upgrade a driver yourself: the kernel module lives on the host, outside the container, and a rebuild restores whatever the image ships.
What the container is not
It is not a full Linux host. The kernel and the NVIDIA driver belong to the host, so you cannot load kernel modules, install a driver or reboot the machine; restarting the instance restarts your container. What does not work on any machine:
- No
/dev/net/tun: no kernel-mode VPN client or Tailscale. - No privileged mode: you cannot mount a block device or change your own cgroup limits.
Start your own services from a shell for a quick test, inside tmux so they survive a disconnect, or from the startup hook so they come back after a restart. On a system container (below) a systemd unit works too.
Docker and systemd
Docker inside the rental is available on some machines only. In November 2026 about half of the Sparks, GPUwerk's own and partners' alike, run the system container and the rest run the plain one. Which you get depends on the machine your instance lands on; you can't pick it yet, and the console does not show it before you deploy.
- System container (many Sparks, own and partner, since 28 October 2026): systemd is PID 1, so
systemctland your own units work. Docker and the NVIDIA container toolkit are installed, sodocker run --gpus allworks with arm64 images. Docker keeps its images and containers in/workspace/docker, so they survive a rebuild and use workspace space. - Plain container (the other Sparks, about half of them in November 2026, own and partner): PID 1 is the entrypoint script, which execs into
sshd(or the model server on a model preset). There is no systemd and no Docker daemon or socket, sosystemctlanddocker runfail. Install tools with pip or apt and use the startup hook.
To check which one you have, run docker info: it answers on a system container and fails on a plain one.
What persists across a restart
/workspace is a separate volume, not part of the container's own filesystem.
| Action | Under /workspace | Everything else (apt packages, system pip installs) |
|---|---|---|
| Restart | Kept | Kept |
| Stop and start | Kept | Kept while the machine is held; see below |
| Rebuild | Kept | Gone: the image is reinstalled fresh |
| Terminate | Deleted for good | Deleted |
Stop. A stop keeps the machine reserved for you with the container quiesced and /workspace on the node, so starting again takes seconds. If your credit runs out or your monthly budget is reached, the instance is stopped and its machine released. The workspace stays on that machine for up to 48 hours. Top up and start it again in that time and it picks up where it left off, unless someone else has rented the machine, which deletes it sooner. After 48 hours the instance and its /workspace are deleted for good. Nothing is copied off the machine.
Terminate is the one action that deletes /workspace for good, which is why the console asks you to type the instance name first.
Workspaces are not backed up. GPUwerk keeps no copy of /workspace, not even one to recover from a failed drive. If the drive fails, the workspace is lost. Copy anything you need off the node yourself: Get your files out has scp, rsync and Hugging Face examples.
SSH host keys are also kept in /workspace, under .hostkeys, so your instance's identity stays the same across restarts and you do not get a host-key warning each time.
The startup hook
To start your services automatically after every restart:
- Write the script below to
/workspace/.gpuwerk-init, with your own commands. - Make it executable:
chmod +x /workspace/.gpuwerk-init. - Restart the instance from the console.
It runs as root on every container start (first boot, restart or rebuild). It is launched detached, so a hook that hangs or fails cannot delay SSH. Its output goes to /workspace/.gpuwerk-init.log, not your terminal. The hook needs an image built after September 19, 2026; if your instance is older, a rebuild picks up the new image and keeps /workspace.
#!/bin/sh
# /workspace/.gpuwerk-init: must not block, it runs detached anyway
cd /workspace
nohup llama-server -m my-model.gguf --host 0.0.0.0 --port 8899 \
>> llama-server.log 2>&1 &
nohup python3 my-service.py >> my-service.log 2>&1 &
Result: after the restart, /workspace/.gpuwerk-init.log has a new timestamp line followed by your script's output, and your services are running. Each run writes its own timestamp line, so you can tell restarts apart.
Storage: the shared 1 TB NVMe
The included storage is 1 TB NVMe shared with the system and model cache, not a slice cut out for you. The host, GPUwerk's container images, staged model weights, your container and /workspace (with any Docker images you pull) all share it.
dfinside your container shows node-wide numbers, not a per-tenant quota. "Used" includes provider-side files you cannot see; inode counts work the same way.- What
dfreports as free is what you can use. How much provider-side data a node carries varies, so GPUwerk does not promise a fixed free amount on the included 1 TB. - Need more headroom on a reserved node? Get in touch.
Networking
- Address: each instance gets its own public IPv4, assigned by GPUwerk and shown on the instance page, and the hostname
<instance-name>.gpuwerk.com. This address belongs to GPUwerk, not to the network of the person who owns the machine: a partner-hosted Spark has no public IP address of its own, connects out to GPUwerk through an encrypted tunnel, and your internet traffic as a renter leaves from GPUwerk's address, never the owner's. SSH is on the standard port 22, asroot. The console's instance page shows the exact command. - Outbound: internet access is open, so
pip install,git cloneand model downloads work normally. One exception: outgoing mail on TCP ports 25 and 465 is blocked, as on most clouds, so instances cannot send mail directly to other mail servers. Sending through a mail provider on port 587 works. If you need to run your own mail server, write to support@gpuwerk.com and say what it is for. We can lift the block for your account. - Model presets: the model server listens on port 8888 inside the container, and GPUwerk publishes it as an HTTPS endpoint that requires an API key with the
inferencescope. - Your own services: a service bound to
0.0.0.0listens on the instance's network interface, which can make it reachable on the instance's public address. For anything private, bind to127.0.0.1and reach it through an SSH tunnel.
Spark Cluster 2×: the second machine
On a Spark Cluster 2× each machine runs its own container, and the two are joined by a ConnectX link on eth1. Use that interface for everything between them: eth0 is private to each machine and the other one cannot reach it. Both containers start with these variables set, in SSH sessions too:
CLUSTER_RANK,CLUSTER_SIZE: this machine's rank (0 or 1) and the machine count (2).CLUSTER_ADDR: this machine's address on the link.CLUSTER_PEERS: both link addresses in rank order.MASTER_ADDR: rank 0's link address.VLLM_HOST_IP,NCCL_SOCKET_IFNAME,GLOO_SOCKET_IFNAME: set to this machine's link address andeth1, so vLLM, NCCL and PyTorch's Gloo connect over the link. NCCL uses RDMA (RoCE) on it.
If you start a multi-node job in a shell that does not have them (for example a fresh env -i or a container of your own), set them yourself: without VLLM_HOST_IP a two-machine vLLM picks eth0 and waits for a peer it can never reach.