Instances
Coming from another cloud?
▸AWS·EC2 Instances
EC2 Instances
- Uses EC2 RunInstances API instead of Nova servers.create.
- Requires predefined instance type selection.
- Supports per-second On-Demand billing and Spot/Reserved options.
- Includes hibernation state not standard in OpenStack.
▸Azure·Virtual Machines
Virtual Machines
- Uses Azure Resource Manager (ARM) REST API at /providers/Microsoft.Compute/virtualMachines instead of OpenStack Nova API at /v2.1/servers.
- Tightly integrated with Azure services like Azure Active Directory for authentication, unlike OpenStack's Keystone.
- VM creation requires specifying size from predefined series with hardware-specific features (e.g., AMD/Intel/ARM), not custom flavor configs.
- Billed per second with complex pricing tiers based on series/reservation options, vs OpenStack's typically hourly or usage-based.
▸DigitalOcean·Droplets
Droplets
- API surface is DigitalOcean’s proprietary REST/CLI/Terraform tooling rather than OpenStack Nova/Neutron/Glance APIs (Droplets are managed via DigitalOcean UI/CLI/API/Terraform).
- Billing is usage-based with per-second billing (60-second minimum and monthly cap) rather than the typical per-hour, quota-based charge model users often see in OpenStack-based clouds.
- Droplets include a bundled outbound transfer allowance with each plan (starting at 500 GiB/month) rather than a separate bandwidth quota/metering model users often encounter in OpenStack deployments.
- Droplets are described as Linux-based VMs on virtualized hardware with local SSD storage, whereas OpenStack deployments commonly expose distinct block storage (Cinder) and image services (Glance) and may not bundle bandwidth/monitoring/firewalls into the instance offering.
▸Google Cloud·VM instances
VM instances
- Uses REST API 'instances.insert' instead of Nova 'servers.create' with different auth via service accounts vs Keystone.
- Supports bare metal instances (no hypervisor), not in standard OpenStack Nova.
- Network interfaces tied to VPC subnets; differs from Neutron ports/floating IPs.
▸Hetzner·Cloud Servers
Cloud Servers
- Servers provisioned individually via Hetzner API (hcloud), not OpenStack Nova flavors; fixed instance types like CX11 (1 vCPU, 2GB RAM, 20GB NVMe).
- No flavor customization; choose from predefined shared/dedicated vCPU series.
- Billing hourly with monthly cap per server (e.g., €3.29/mo cap for CX11), charged even when powered off until deleted, unlike typical OpenStack stop-to-pause billing.
- Custom REST API at api.hetzner.cloud/v1/servers instead of OpenStack Nova /v2.1/servers (different auth, payloads, response formats).
Instances
Instances are virtual machines (VMs) that run on Quake AI. They give you isolated compute (CPU, memory, disk, and network), so you deploy applications and services inside projects without sharing an OS with other tenants. You manage them through the Console, CLI, or API.
Documentation and APIs sometimes still say servers for historical reasons; on Quake AI the service-accurate term is instances.
What an instance represents#
In the data center, a physical machine runs a hypervisor and hosts many guests. Each instance is one of those guests: it looks like a standalone computer to the operating system inside it, with virtual devices backed by real hardware somewhere in the cloud.
That abstraction is the foundation of cloud computing. Instances provide the CPU cycles, RAM, and I/O your workloads need, while the platform handles placement, migration boundaries, and integration with networking and storage.
How instance hardware maps to the cloud#
Physical servers use processors, RAM, disks, and NICs. On Quake AI you do not pick a motherboard; you choose a flavor that defines vCPU, memory, and root disk characteristics, and an image that defines the software stack. The analogy still helps: more vCPU and RAM behave like a more flexible machine; SSD-backed storage behaves like faster local disks; network attachment points connect you to project networks the same way NICs connect a machine to a LAN.
Protocols instances typically run#
Instances run the same network protocols as any machine on a TCP/IP network. Common examples include HTTP and HTTPS for web traffic, SSH (and sometimes RDP) for administration, DNS for name resolution, SMTP for mail, and FTP or object APIs for file movement. You choose which protocols matter by what you install and which ports you expose through security groups, floating IPs, reverse proxies, and external edge services.
Common roles for instances#
Instances host websites and APIs, run mail and collaboration software, hold databases and caches, provide shared file services, and underpin virtualization and container platforms. In Quake AI they also participate in the shared services model: storage volumes attach for durable data, networking connects them to routers and floating IPs, and identity-linked key pairs control administrative access.
Platform features around instances#
The Compute service (OpenStack Nova) runs guests on hypervisors such as KVM. Flavors define resource shape. Images supply the OS and initial software. Networking attaches instances to project networks. Security groups filter traffic at the port level. Key pairs enable SSH and similar access without password login. Volumes add persistent disks beyond ephemeral root storage. Projects (tenants) isolate ownership and quotas. Other services integrate so storage, identity, and network behavior stay consistent from boot to access.
Lifecycle and behavior#
Creating an instance ties together an image, a flavor, network attachments, and optional security groups, key pairs, and user data. The scheduler places the instance on a compute node with enough capacity and respecting any affinity rules you set. The hypervisor boots the guest from the image; network ports receive addresses from your subnets.
After boot you start, stop, reboot, resize, or delete instances as needed. Snapshots capture disk state into an image for backup or cloning. Volumes attach or detach for data that should survive instance deletion. Floating IPs associate when you need a stable public entry point. You typically access instances via SSH with a private key; security groups enforce which remote traffic reaches the instance.
The platform dedicates flavor-defined resources to each instance, which limits noisy-neighbor effects through scheduling and isolation.
How flavors, images, and networks interact#
Each instance combines several choices. The flavor sets the resource envelope (vCPU, memory, root disk size). The image (or snapshot, or bootable volume) determines what operating system and software stack boots inside that envelope. The network attachment decides which subnets the instance can reach: private networks for internal traffic, with routers and floating IPs layered on for external access when needed.
Security groups filter traffic at the port level, so the combination of network attachment and group rules defines the instance's reachable surface. User data (cloud-init scripts) automates first-boot configuration: package installs, service setup, and SSH key injection without manual steps after launch.
Further reading#
On this platform:
- Create an instance: step-by-step instance creation via Console, CLI, and API
- Flavors: vCPU, memory, and disk configurations for instances
- Images: operating system templates for instance provisioning
- Key pairs: SSH key authentication for instance access
- Volumes: persistent block storage that attaches to instances
- Instances console: Console reference for instance management
External resources:
- OpenStack Nova documentation: upstream Compute service architecture and admin reference
- cloud-init documentation: first-boot configuration and user data formats for cloud instances
Quick answers
- Why does `openstack image save` write a 0-byte file for my boot-from-volume instance?CLI
- Why does `openstack server create` fail with "Only volume-backed servers are allowed for flavors with zero disk"?CLIAPITerraform
- Why does my project still have a 10 GiB Cinder volume after I deleted my instance?CLIAPI
Related content
Pages
How-tos
Add an SSH key pair to your account
Tools
How to add a block volume to a template
Automation
How to auto-scale a VM tier with Heat
Automation
How to back up and restore a Quake AI VM
Compute
How to boot a virtual machine from an ISO image
Compute
How to build a golden VM image with Packer
Compute
How to configure a VM with cloud-init
Compute
How to create a virtual machine image
Compute
How to Create a Virtual Machine Instance
Compute
How to Create a VM on a Private Network
Compute
How to Create a VM on a Public Network
Compute
How to create an instance snapshot
Compute
How to customize a template's image and flavor
Automation
How to Deploy a Containerized Application with Docker Compose on a Quake AI VM
Compute
How to deploy a multi-tier application with Terraform
Automation
How to deploy an application to a Quake AI VM from CI
Automation
How to deploy on git push with a webhook listener
Automation
How to deploy VMs with Terraform (simple example)
Automation
How to emulate a branchable Postgres workflow
Automation
How to harden a Quake AI virtual machine
Compute
How to launch a Windows Server VM
Compute
How to maintain a Quake AI VM over its lifetime
Compute
How to migrate MySQL or MariaDB to Quake AI
Databases
How to migrate PostgreSQL to Quake AI
Databases
How to operate a running Quake AI VM
Compute
How to patch and update a Quake AI VM
Compute
How to provision a production-ready VM
Compute
How to provision a server with an AI agent
Tools
How to resize a Quake AI VM to a dedicated-CPU plan
Compute
How to restore PostgreSQL from a self-managed-postgres backup
Automation
How to schedule recurring jobs on a Quake AI VM
Compute
How to self-host a CI server on a VM
Automation
How to self-host authoritative DNS on Quake AI
Network
How to set a password on a virtual machine instance
Compute
How to set up a site-to-site or remote-access VPN to Quake AI
Network
How to set up SSH bastion access into a private subnet
Network
How to store application secrets and inject them at runtime
Security
How to use a container registry with Quake AI
Kubernetes
How to use the virtual machine console
Compute
Sending Mail (SMTP) with Your Virtual Machine
Compute
Tutorials
Add persistent storage to your server
Block storage
Automate your infrastructure with OpenTofu
Automation
Deploy a containerized web application
Compute
Deploy a database sandbox
Compute
Deploy an API service
Compute
Deploy OpenClaw on Quake AI
Compute
Get started with Infrastructure as Code on Quake AI
Automation
Host a static website on Quake AI
Compute
Launch your first server
Platform
Explanations
Apps
Compute
Authoring IaC templates for Quake AI
Automation
cloud-init and first-boot configuration
Compute
Droplets on Quake AI
Compute
EC2 on Quake AI
Compute
Flavors
Compute
Floating IPs
Network
Images
Compute
IP address management
Network
Key pairs
Compute
Security Groups
Network
Self-managed relational databases
Databases
Servers (compute instances)
Compute
Terraform and OpenTofu on Quake AI
Automation
Virtual machines (VMs)
Compute
Volumes
Block storage
Reference
Apps console
Compute
Compute API error reference
Compute
Compute Console
Compute
Compute Service API Reference
Compute
Compute Service CLI Reference
Compute
Documentation Changelog
Platform
Flavors CLI Reference
Compute
Floating IP API Reference
Network
Floating IP CLI Reference
Network
Instance Snapshots CLI Reference
Compute
Instance Snapshots Console
Compute
Instances API Reference
Compute
Instances CLI Reference
Compute
Instances Console
Compute
Networks Console
Network
Topology Console
Network
Overviews
migration
Compute migration guides
Compute
How to migrate from Docker Compose to OpenTofu on Quake AI
Automation
Migrate a B2B SaaS application to Quake AI
Automation
Migrate a Docker container app from AWS to Quake AI
Compute
Migrate a web application to Quake AI
Automation
Migrate from AWS EC2 to Quake AI compute
Compute
Migrate from Azure Virtual Machines to Quake AI Compute
Compute
Migrate from DigitalOcean Droplets to Quake AI Compute
Compute
Migrate from GCP Compute Engine to Quake AI compute
Compute
Migrate from Hetzner Cloud Servers to Quake AI Compute
Compute
Migrate from Linode compute instances to Quake AI compute
Compute
Migrate from Vultr to Quake AI compute
Compute
Migrating from AWS to Quake AI
Platform
Migrating from Azure to Quake AI
Platform
Migrating from DigitalOcean to Quake AI
Platform
Migrating from GCP to Quake AI
Platform
Migrating from Hetzner Cloud to Quake AI
Platform
Migrating from Linode (Akamai Cloud Computing) to Quake AI
Platform
Migrating from Vultr to Quake AI
Platform
runbook
troubleshooting
quickstart
deployment
Build a private network with two virtual machines
Network
Deploy a bursty-GPU control plane with a queue and workers
Compute
Deploy a Next.js app with the nextjs-app template
Compute
Deploy a private container registry with OpenTofu
Automation
Deploy a Redis or Valkey cache with the redis-cache template
Automation
Deploy a regional edge cache with the edge-cache template
Automation
Deploy a self-hosted CI runner
Compute
Deploy a self-hosted git forge and CI with OpenTofu
Automation
Deploy a self-hosted identity provider with the auth-oidc template
Automation
Deploy Airbyte with the airbyte template
Automation
Deploy Airflow with the airflow template
Automation
Deploy an API gateway with the api-gateway template
Automation
Deploy an edge reverse proxy with the edge-reverse-proxy template
Automation
Deploy an edge tunnel gateway with the edge-tunnel-gateway template
Automation
Deploy an edge WAF with the edge-waf template
Automation
Deploy an inference gateway with OpenTofu
Automation
Deploy Appsmith with the appsmith-internal-tools template
Automation
Deploy Cal.com with the calcom-scheduling template
Automation
Deploy ClickHouse with the clickhouse template
Automation
Deploy Coolify with the coolify-host template
Automation
Deploy edge functions with the edge-functions template
Automation
Deploy Excalidraw with the excalidraw-whiteboard template
Automation
Deploy Feast with the feast template
Automation
Deploy GlitchTip with the glitchtip template
Automation
Deploy Infisical with the infisical-secrets template
Automation
Deploy JupyterHub with the jupyterhub template
Compute
Deploy Mattermost with the mattermost-team-chat template
Automation
Deploy Metabase with the Metabase template
Compute
Deploy MinIO + Iceberg with the minio-iceberg template
Automation
Deploy MLflow with the mlflow template
Compute
Deploy n8n with the n8n-workflow template
Automation
Deploy Nextcloud with the nextcloud-files template
Automation
Deploy Outline with the outline-docs template
Automation
Deploy Plane with the plane-project-management template
Automation
Deploy Redpanda with the redpanda template
Automation
Deploy Selenium Grid with the selenium-grid-testing template
Automation
Deploy self-hosted Supabase with Docker Compose
Compute
Deploy Streamlit with the streamlit template
Automation
Deploy Supabase with the supabase-selfhost template
Automation
Deploy Superset with the superset template
Automation
Deploy the audio post-production worker template with OpenTofu
Automation
Deploy the CPU render-farm worker pool template with OpenTofu
Automation
Deploy the Creator-AI inference worker template with OpenTofu
Automation
Deploy the development environment template with OpenTofu
Automation
Deploy the full-stack application template with OpenTofu
Automation
Deploy the Heat Simple Stack template with the OpenStack CLI
Automation
Deploy the Kubernetes cluster bootstrap template with OpenTofu
Automation
Deploy the live RTMP/SRT ingest and restream template with OpenTofu
Automation
Deploy the monitoring stack template with OpenTofu
Automation
Deploy the MySQL/MariaDB database template with OpenTofu
Automation
Deploy the self-managed PostgreSQL template with OpenTofu
Automation
Deploy the Simple VM template with OpenTofu
Automation
Deploy the three-tier application template with OpenTofu
Automation
Deploy the WordPress + MySQL template with OpenTofu
Automation
Deploy Trino with the trino template
Automation
Deploy Umami with the analytics-umami template
Automation
Deploy Unleash with the unleash-feature-flags template
Automation
Deploy Uptime Kuma with the uptime-kuma template
Automation
Run a Cursor SDK agent in CI on a self-hosted runner
Automation
Run dbt transforms as a scheduled job
Automation
Set up a Minecraft server
Compute
Templates
Airbyte ingestion (ELT)
→Apache Airflow orchestration
→Apache Superset BI
→API gateway
→Appsmith internal tools
→Audio post-production worker
→Cal.com scheduling
→ClickHouse analytical column store
→Containerized App on Compute
→Coolify host
→CPU render-farm worker pool
→Creator-AI inference worker
→Development Environment
→Edge cache
→Edge functions
→Edge reverse proxy
→Edge tunnel gateway
→Edge web application firewall appliance
→Excalidraw whiteboard
→Feast feature store
→Forgejo Git and CI
→Full-Stack Application
→Harbor registry
→Heat Simple Stack
→Inference gateway
→Infisical secrets management
→JupyterHub notebook server
→Kubernetes Cluster Bootstrap
→Live RTMP/SRT ingest and restream
→Mattermost team chat
→Metabase BI dashboards
→MinIO + Apache Iceberg lakehouse
→MLflow experiment tracking
→Monitoring Stack (Prometheus + Grafana)
→MySQL/MariaDB Database
→n8n workflow automation
→Next.js App on Compute
→Nextcloud files and collaboration
→Outline team knowledge base
→Plane project management
→Private Network + VPN
→Qdrant vector database
→Redis / Valkey cache
→Redpanda Kafka-API streaming
→Selenium Grid testing
→Self-hosted error telemetry (GlitchTip)
→Self-hosted OIDC identity provider (Keycloak)
→Self-Managed PostgreSQL
→Simple VM with Floating IP
→Streamlit data-app host
→Supabase self-host stack
→Three-Tier Application
→Trino federated query engine
→Umami self-hosted analytics
→Unleash feature flags
→Uptime Kuma status and monitoring
→WordPress + MySQL on Compute
→Troubleshooting
- Compute API errors Compute API error reference →
- Instance connectivity failure Instance connectivity troubleshooting →
- Instance lifecycle failure Instance lifecycle troubleshooting →
- VM boot failure How to Interrupt a Virtual Machine (VM) Boot Process →