Team and multi-user access to a shared DGX Spark
There are two good ways to share one rented Spark across a team: separate Linux users with their own SSH keys, or a gateway in front so most people never need a shell. Which fits depends on whether your team needs a shell or just the model. A Spark instance is one container with root access, not a managed platform with team seats and roles built in, so team access is something you set up yourself.
What you're actually starting from
Whoever deploys an instance gets root in /workspace: no SSH key is needed, because GPUwerk configures the machine and the console's browser terminal works without one. Adding your own key for SSH is optional, per GPUwerk's SSH keys documentation. That root is inside your container; GPUwerk keeps administrative access to the host and platform infrastructure. There's no concept of a second GPUwerk account with scoped access to the same instance; the console and billing are tied to the account that deployed it. Anything resembling team access (separate logins, permission levels, usage limits per person) is something you configure inside the container, the same way you would on any Linux box you administer yourself.
Pattern one: separate Linux users with SSH access
If your team genuinely needs shell access, the standard approach works fine on a Spark: create a Linux user per teammate (adduser), add their public key to that user's ~/.ssh/authorized_keys rather than sharing a root key, and use sudo selectively if they need elevated commands. This keeps a per-person audit trail in auth.log and means revoking one person's access doesn't mean rotating a key everyone uses. The tradeoff is that everyone is still on one machine competing for the same GPU, so a teammate running a heavy fine-tune can slow down someone else's inference session. There's no GPU isolation set up by default; if contention becomes a real problem, you'd add it yourself with tools like CUDA MPS or manual scheduling.
This pattern makes sense for a small team of engineers who all need to poke at the filesystem, install packages, or debug the model server directly.
Pattern two: a gateway in front, no SSH needed
For a team that mostly wants to use the model, not administer the box, put a gateway between them and the GPU so SSH access stays limited to whoever maintains the machine. Two options that run well on a single Spark:
- LiteLLM as an API gateway in front of your inference engine. It issues virtual API keys per person or per service, so each teammate gets their own
sk-key instead of an SSH credential, and you can set per-key rate limits and budgets from its admin UI without touching the machine's user accounts. - Open WebUI as a chat interface in front of the model, for teammates who want a ChatGPT-style UI rather than an API. It handles its own login and user list, so onboarding someone is a web signup, not an SSH key exchange.
These two combine well: LiteLLM as the API layer, with Open WebUI or any OpenAI-compatible client pointed at it. Most of the team never touches SSH; only the person maintaining the deployment does.
Choosing between them
Ask what the team actually needs to do. Debugging model servers, installing new inference engines, or inspecting logs on disk needs a shell: pattern one. Sending prompts, building on the API, or using a chat interface doesn't, so pattern two is both simpler to onboard and safer, because it limits how many people hold a credential that can affect the whole machine. Many teams end up with a hybrid: one or two admins with SSH access running pattern one, and everyone else on a gateway.
Practical checklist
- Default to a gateway (LiteLLM, Open WebUI, or both) for anyone who only needs to use the model, not administer the machine.
- Reserve SSH access, with individual Linux users and keys, for people who need to touch the filesystem or install software.
- Never share one root SSH key among several people; create per-user accounts instead so access can be revoked individually.
- Remember contention is real on a single GPU: a heavy job from one teammate affects everyone else's latency, since there's no isolation set up by default.
- If usage genuinely needs strict per-person isolation, a second, independently rented instance is a cleaner separation than trying to enforce it inside one container. (The two-node cluster pools memory for one workload; it does not separate users.)
See the LiteLLM setup guide and Open WebUI guide for the actual install steps, or a first engagement if you want help designing access for a specific team.