Skip to content

Quickstart

Account setup is required before using any product below. Each section is a self-contained walkthrough, enough to get the thing running without leaving this page. For the full walkthrough, follow the link at the end of each section to that product's own dedicated page.

Account setup

  1. Create your account. Go to console.verda.com/signin, fill in the registration form, and click Create account. Check your email and verify your address, then log in to the console.
  2. Add funds. In the dashboard, open Billing & settings. Under Add funds to your project balance, enter an amount, add a payment method, and click Save billing details, then Complete payment. (For a bank transfer instead of a card, use My Account → Bank transfer.)
  3. Generate a credential. Open the Credentials page from the sidebar. Under Cloud API credentials, click + Create and copy the Client ID and Client Secret. The secret is shown only once, so store it safely. This one pair authenticates the CLI, Terraform, OpenTofu, and integrations like dstack and SkyPilot. For hosted model endpoints, create a key under Inference API Keys → + Create instead. Both are tied to the team member who created them and are deleted automatically if that member is removed from the project.

See Account & access for the full account setup guide.

Instances

Getting a working instance takes three steps: deploy it, add an SSH key so you can reach it, then connect. Steps 1 and 2 can be done in either order.

  1. Create an instance. On the Instances page, click Deploy Instance (top right). Then:
    • Choose a contract: On-demand (Pay As You Go, billed in 10-minute increments) or Spot (cheaper, but can be evicted at any time).
    • Pick a GPU or CPU model, then a size from the card (greyed-out sizes are unavailable). The location is usually selected automatically; any storage you attach must be in that same location.
    • Choose an operating system (Ubuntu, or JupyterLab in various configurations).
    • Optionally add storage (Add volume / Add shared filesystem / Add existing storage) and a startup script.
    • Set a hostname and description (the hostname can't be changed after deployment).
    • Review the order summary and click Deploy now.
  2. Add an SSH key. Generate a key pair on your own machine, then register the public half with Verda:
    • On Linux or macOS, run ssh-keygen -t ed25519 and view the public key with cat ~/.ssh/id_ed25519.pub. On Windows, generate an Ed25519 key in PuttyGen and copy the Public key field.
    • In the console, go to Keys → SSH Keys → Create and paste the public key. Add it before you deploy and it's authorized on the instance automatically.
  3. Connect. Copy the SSH login shown on the instance card, then connect with your private key:

    ssh -i /path/to/your/key root@<INSTANCE_IP>
    

    Use the username root for a standard instance. If your key has a passphrase, you'll be prompted for it.

See Get started with Instances for the full walkthrough.

Private Networks

Pilot feature

Private Networks is in a limited pilot. It is enabled per project and only offered in some datacenters.

A private network gives your project its own private IPv4 address space, so instances talk to each other over addresses that are never routed on the public internet. Networking is chosen when you deploy an instance and can't be changed afterwards.

  1. Create a network. In the console sidebar, under Networking, open Private networks and create a network. You can skip this step: if your project has no network, the first deploy that asks for a private address creates one named default.
  2. Deploy an instance onto it. In the deploy form's Network step, pick a subnet, or choose Create new next to the Subnet dropdown and enter an IP range in CIDR notation from a private range, for example 10.0.0.0/24. Then choose:
    • Public + Private IP: the instance gets a private address and a public IPv4, so you can SSH to it directly.
    • Private IP only: the instance has no public address and no outbound internet. Reach it through a jump host on the same network that has a public IP.
  3. Connect. SSH to the public IP as usual. Inside the instance, ip addr shows only the private address; the public IP is applied as 1:1 NAT outside the guest.

Plan your access before deploying

An instance deployed with a private IP only, into a network with no jump host and no route, is unreachable.

See Private Networks for the full walkthrough.

Clusters

  1. Deploy an Instant Cluster. On the Clusters page, click Deploy Cluster (top right). Then:
    • Choose a contract duration (from one day) and the number of GPUs.
    • Select a job orchestrator (Kubernetes or Slinky/Slurm), an OS, and a CUDA toolkit.
    • Choose a shared filesystem size. The SFS mounts to /home on every node including the jump host; local storage mounts to /mnt/local_disk on each worker.
    • Supply your SSH public key and set a hostname (worker nodes inherit it as a prefix), then deploy.
  2. Wait and connect. Allow around 20 minutes for the cluster to validate; the jump host becomes reachable a few minutes before the workers. The default user is ubuntu. Copy the ssh ubuntu@<CLUSTER_IP> command from the console to log in to the jump host, and reach a worker from there with ssh <WORKER_NAME> (tab-completion works).
  3. Run your first job. Manage jobs through the orchestrator you chose at deploy time, following its getting-started guide (Kubernetes or Slinky). Deployment and jump-host access use the same SSH basics as Instances.

See Get started with Clusters for the full walkthrough.

Serverless Containers

  1. Create a deployment. Go to Serverless Containers → New deployment and give it a name.
  2. Pick a Compute Type with enough VRAM for the workload.
  3. Set the image. Point at a public image to start, for example the official vLLM container docker.io/vllm/vllm-openai, toggled Public. Always use a specific version tag (e.g. :1.0); :latest is rejected. For a private image, add registry credentials under Container registries first.
  4. Configure the port and health check to match what the container serves on. For vLLM: exposed HTTP port 8000, health path /health.
  5. Deploy, then generate an inference API key under Credentials → Inference API Keys and call the endpoint shown on the deployment page.

See Serverless Containers for the full walkthrough.

Storage

Verda has four storage types. Which one you reach for depends mostly on how many machines need to read the data:

  • Block Volumes: a persistent disk for a single VM, for datasets, checkpoints, or a database beyond the boot disk.
  • Shared Filesystems (SFS): a POSIX filesystem several VMs can mount at once, for distributed training or a shared team dataset.
  • Object Storage: S3-compatible buckets, with sync tooling and presigned URLs.
  • Container Registry: a private image registry for storing and deploying container images inside Verda.

For a single VM, attach a Block Volume (during instance creation, or from the Storage page). Once attached it appears as a device such as /dev/vdb; format it if it's new, then mount it:

mkfs.ext4 /dev/vdb                 # new volumes only
mkdir /mnt/data
mount /dev/vdb /mnt/data
echo "/dev/vdb /mnt/data ext4 defaults,nofail 0 0" >> /etc/fstab   # mount on every reboot

For several VMs, create a Shared Filesystem: on the Shared filesystems screen click Create filesystem, choose size and region, and share it with the instances that need it. Then mount it on each one (replace SFS_NAME, the datacenter DC, and the filesystem's PSEUDO path):

mkdir -p /mnt/SFS_NAME
mount -t nfs -o nconnect=16 nfs.DC.verda.com:PSEUDO /mnt/SFS_NAME

See Storage for the full walkthrough.