Practical guides

Guides for getting work done on a cloud GPU

Practical guides for renting a GPU and getting work done on it: SSH access, self-hosting LLMs, vLLM, stopping without losing work and API error handling.

Explore the collection

Find your next step.

25 pages
Guide

How to rent a GPU

Renting a GPU by the hour, step by step: pick the GPU from your memory needs, fund the account, launch, connect over SSH and stop it without paying for idle time.

Explore
Guide

SSH into a cloud GPU

Connect to a rented GPU over SSH: which key to use, the right username per provider, port forwarding for Jupyter or an API, and VS Code Remote-SSH setup.

Explore
Guide

Stop a GPU instance

Stopping a DeployGPU instance deletes its disk. How to copy results off first, what you get refunded when you stop and how volumes keep data between runs.

Explore
Guide

Self-host an LLM

How to pick a model, a GPU and a serving stack for a self-hosted LLM on rented hardware, with the memory math, hourly costs and the security basics.

Explore
Guide

vLLM

Run vLLM's OpenAI-compatible server with Docker on a rented GPU VM, reach it safely through an SSH tunnel and size the GPU for your model and context.

Explore
Guide

Handle provisioning failures

What to do when a GPU launch fails through the DeployGPU API: failure codes, the retryable flag, 503 cooldowns with Retry-After and why blind retries cost money.

Explore
Guide

Quantization

Which quantization format to deploy: FP8, AWQ and GPTQ for vLLM, GGUF for llama.cpp and Ollama, MXFP4 and NVFP4 on newer GPUs, and which GPUs run each.

Explore
Guide

First five minutes

The checks to run in the first five minutes on a rented GPU: nvidia-smi, driver and CUDA versions, disk space, Docker GPU access and a quick PyTorch test.

Explore
Guide

Keep jobs running

Keep a training run or a model server alive when your SSH session drops, with tmux, nohup or a systemd unit, and find the job again when you reconnect.

Explore
Guide

SSH port forwarding

Reach Jupyter, vLLM, TensorBoard or any web app on a rented GPU through an SSH tunnel instead of an open port, with local and dynamic forwarding examples.

Explore
Guide

Multi-GPU training

Run training across every GPU in one rented node with torchrun, DDP, FSDP or DeepSpeed, check that NVLink is in use, and size the node for the model.

Explore
Guide

Fine-tuning

How to fine-tune an open model on rented GPUs: full fine-tuning, LoRA or QLoRA, which tools to use, how much GPU memory each needs and how to keep the result.

Explore
Guide

Download models fast

Pull model weights onto a rented GPU quickly with the Hugging Face CLI, put the cache on the right disk, and avoid downloading the same model twice.

Explore
Guide

Install PyTorch with CUDA

Install a PyTorch build that matches the GPU and driver on a rented VM, check that CUDA works, and use the CUDA 12.8 or newer builds Blackwell cards need.

Explore
Guide

Move data

Get datasets onto a rented GPU and results back off it with scp, rsync, rclone or the Hugging Face Hub, and pick the fastest route for the size of the data.

Explore
Guide

Checkpoint and resume

Save training checkpoints somewhere that outlives a rented GPU and resume on a new one, with PyTorch and Hugging Face Trainer examples and storage options.

Explore
Guide

ComfyUI models and nodes

Install checkpoints, LoRAs and custom nodes in the DeployGPU ComfyUI template with ComfyUI-Manager or over SSH, and what happens to them when you stop.

Explore
Guide

Whisper transcription

Run Whisper large-v3 or faster-whisper on a rented GPU to transcribe audio in batches: which GPU to pick, the commands, and how to move files in and out.

Explore
Guide

GPU containers

Run GPU containers on a rented VM with Docker and the NVIDIA Container Toolkit: check the setup, the --gpus flag, CUDA image versions and common errors.

Explore
Guide

VS Code Remote-SSH

Open a rented GPU in VS Code with Remote-SSH: the config entry, the extension, port forwarding for notebooks and servers, and what to do when it fails.

Explore
Guide

llama.cpp server

Run llama.cpp's server with CUDA on a rented GPU, load a GGUF model from Hugging Face and reach its OpenAI-compatible API through an SSH tunnel.

Explore
Guide

SGLang

Run SGLang's OpenAI-compatible server with Docker on a rented GPU VM, keep it private behind an SSH tunnel and size the GPU for the model you serve.

Explore
Guide

Batch jobs with the API

Launch a GPU VM from a script, copy the job in, run it, copy the results out and stop the machine, with a full Python example and failure handling.

Explore
Guide

API cost guardrails

Guardrails that keep automated GPU launches from running up a bill: runtime limits, stop-on-exit traps, a sweeper job, balance checks and key hygiene.

Explore
Guide

GPU cloud aggregators

How GPU cloud aggregators and multi-provider marketplaces work, who holds the provider accounts, what they add or take away, and when to rent direct.

Explore

The guides on this site are written for one situation: you are paying for a GPU by the hour, so every hour spent on setup, lost files or an instance nobody stopped is money gone. Each guide covers one task on DeployGPU from start to finish, with the commands to copy and the platform details that generic tutorials leave out, such as which username each provider uses and what stopping an instance deletes.

Where to start

New to renting GPUs? Read how to rent a cloud GPU first. It walks the whole loop in 9 steps: picking a GPU by memory, adding credits, launching, connecting and stopping.

Connecting to the machine is the next thing that goes wrong, usually because of the username or the key. SSH into a cloud GPU covers keys, the username per provider, ~/.ssh/config, VS Code and tunnels.

Before your first stop, read save your work, then stop your GPU. Stopping deletes the instance and its disk, and that guide is about not learning it the hard way.

Your first session on the machine

Once connected, check a new GPU in the first five minutes with nvidia-smi before you copy anything onto it. Keeping jobs running after you disconnect covers tmux, nohup and systemd, and SSH port forwarding reaches Jupyter, TensorBoard or a model server without opening a port. Getting software and data onto the machine has 4 guides: installing PyTorch with CUDA, running Docker with GPUs, downloading Hugging Face models fast and moving data to and from a cloud GPU. VS Code Remote-SSH turns the VM into your editor.

Running models

For open-weight LLMs, self-hosting an LLM on a rented GPU is the overview: which model, which GPU, which serving stack. From there, deploy vLLM on a cloud GPU sets up an OpenAI-compatible API on a GPU VM, and two comparisons help you choose: vLLM, Ollama, llama.cpp or SGLang, and Ollama Cloud or your own GPU. The engine guides cover llama.cpp server for GGUF files and SGLang, and the quantization guide explains which formats each one runs. For other workloads, see Whisper transcription and models and custom nodes in ComfyUI. The models section has the memory math per model.

Training and fine-tuning

Fine-tuning on cloud GPUs is the starting point, with step-by-step guides for Unsloth and image-model LoRAs. Multi-GPU training covers torchrun, DDP and FSDP on one 8-GPU VM, and checkpoint and resume keeps a run from dying with the instance.

Automating with the API

If you launch GPUs from code, handling provisioning failures covers failure codes, the 503 cooldown and why a create call must never be retried blindly. Batch GPU jobs from a script runs a job end to end, and API cost guardrails stops machines that would otherwise keep billing. The API page has a complete launch script, and GPU cloud aggregators explained covers how a multi-provider platform like this one works.

Every guide

Browse all 25 pages above ↑

When something breaks rather than needs setting up, the troubleshooting section is organised by the error message you see.