Upload data to a cloud GPU and download results

The right transfer tool depends on how much data you have and where it lives now: scp for a few files, rsync for a folder you will send more than once, tar over SSH for a pile of small files, rclone when the data already sits in object storage, and the Hugging Face Hub for models and datasets you are happy to host there. Whatever you pick, the disk it lands on is deleted when the instance stops, so the same tools bring your results back out.

Pick the tool by size and source

Check the SSH user and the disk with du and df

Vast.ai containers, which exist in the dashboard only, log in as root on the proxy port shown there, and Vast.ai bills bandwidth separately. Compare your data with the room on the VM before you start:

du -sh ./dataset          # on your machine
df -h ~                   # on the VM

Budget for the dataset, any unpacked copy of it, your checkpoints and the model caches, which all share one disk. A compressed archive needs room for itself and for its contents at the same time, unless you extract it as it arrives, as in the tar section below. On QuantaCloud, Massed Compute and Hyperstack there is no resizing, so a disk that is too small means a different offer. Verda lets you choose the size at launch. Volumes on Verda and Hyperstack survive stopping, arrive unformatted and are billed hourly while they exist, as the volumes documentation explains.

Upload with scp and rsync -avP

# Create the target folder once
ssh ubuntu@YOUR_VM_IP 'mkdir -p ~/data'

# One file or a small folder. scp takes the port with a capital P
scp -P 22 model.tar ubuntu@YOUR_VM_IP:~/data/

# A folder you will resend: ssh takes the port with a lowercase p
rsync -avP -e "ssh -p 22" ./dataset/ ubuntu@YOUR_VM_IP:~/data/dataset/

The rsync manual, checked 1 October 2026, defines -P as --partial --progress, so an interrupted file is kept and the same command continues from it, where scp starts the file again. It also says a trailing slash on the source avoids creating an extra directory level, so ./dataset/ copies the contents and ./dataset would create dataset/dataset on the VM. Skip -z for data that is already compressed, such as images, archives and safetensors. When the connection is shaky, let a loop do the retrying:

until rsync -avP -e "ssh -p 22" ./dataset/ ubuntu@YOUR_VM_IP:~/data/dataset/; do
  echo "rsync stopped, retrying in 10 seconds"; sleep 10
done

Pack many small files with tar over ssh

ssh ubuntu@YOUR_VM_IP 'mkdir -p ~/data'
tar cf - ./dataset | ssh ubuntu@YOUR_VM_IP 'tar xf - -C ~/data'

# An archive you already have, extracted on arrival so the archive never lands on the disk
cat dataset.tar.gz | ssh ubuntu@YOUR_VM_IP 'tar xzf - -C ~/data'

Every file costs protocol overhead in scp and rsync, so a dataset of many small files usually moves faster as one stream. It also avoids a second problem, because a directory with millions of small files can exhaust inodes before the disk is full, which the No space left on device page explains.

Pull from object storage with rclone copy

When the data already lives in S3, R2 or a similar service, skip your laptop and pull it from the VM. The rclone install page gives one command for Linux. Its configuration docs say a remote can be defined entirely with RCLONE_CONFIG_ environment variables, so no secret lands in a file:

curl https://rclone.org/install.sh | sudo bash
export RCLONE_CONFIG_DATA_TYPE=s3
export RCLONE_CONFIG_DATA_PROVIDER=AWS
export RCLONE_CONFIG_DATA_REGION=us-east-1
read -rsp "Access key ID: " RCLONE_CONFIG_DATA_ACCESS_KEY_ID; export RCLONE_CONFIG_DATA_ACCESS_KEY_ID
read -rsp "Secret access key: " RCLONE_CONFIG_DATA_SECRET_ACCESS_KEY; export RCLONE_CONFIG_DATA_SECRET_ACCESS_KEY
rclone copy data:my-bucket/train ~/data/train -P --transfers 16

The copy command skips identical files and does not delete anything at the destination. The sync command makes the destination match the source, and the rclone documentation warns that this can cause data loss, so test it with --dry-run first. The --transfers flag sets how many files move in parallel and defaults to 4, per the rclone flag documentation. For Cloudflare R2 or another S3-compatible service, set the provider and endpoint as the rclone S3 page describes. A rented VM is shared infrastructure, so use a key limited to one bucket, read-only for downloads, and delete it afterwards. Your storage provider may also charge for data that leaves its network.

Use the Hugging Face Hub for models, datasets and checkpoints

hf upload your-name/my-dataset ./dataset . --repo-type dataset --private
hf download your-name/my-dataset --repo-type dataset --local-dir ~/data/dataset

If the repository does not exist, hf upload creates it, and --private makes the new repository private. Upload once from your laptop and every later launch pulls the data from the Hub instead of waiting for your home connection again. Set a token with export HF_TOKEN=... first. On the VM, use a fine-grained token with write access to that one repository and delete it when you are done. The download guide covers the download side in full.

Verify the copy with sha256sum

# On your machine, from inside the dataset folder
find . -type f -exec sha256sum {} + > ../SHA256SUMS
rsync -avP -e "ssh -p 22" ../SHA256SUMS ubuntu@YOUR_VM_IP:~/data/

# On the VM. No output means every file matched
cd ~/data/dataset && sha256sum -c ../SHA256SUMS | grep -v ': OK$'

Get results off before you stop

Stopping deletes the instance and its disk, so move results as they appear rather than at the end. My preference is to pull them from my own machine, so that none of my credentials sit on a rented VM:

rsync -avP -e "ssh -p 22" ubuntu@YOUR_VM_IP:~/outputs/ ./outputs/

Or push them from the VM to object storage with rclone copy, or to the Hub with hf upload. A volume on Verda or Hyperstack keeps data across launches, but it is deleted permanently, with no email, if your balance cannot pay for it, so it is a convenience and not your only copy. The stop guide has the full checklist, and checkpoint and resume shows how to do this while a job runs.

Five transfer problems and their causes