Google Compute Engine vs IONOS Cloud
Google Compute Engine is a hyperscaler's VM service with 43 regions, Arm machines and Nvidia GPUs up to B200. IONOS Cloud is a German public cloud that rents plain KVM servers in Europe and the US, with Cubes billed by the minute.
The companies and products
Google Compute Engine
Google Compute Engine is Google Cloud's general-purpose VM service, not a sandbox product: you rent virtual machines by the second and set them up yourself.
You pick a machine type (E2, N2D, C3D, Arm T2A, GPU families and more), a boot image and a network, and Compute Engine boots a KVM-based VM with its own kernel and root access. Disks are Persistent Disk or Hyperdisk volumes, traffic goes through VPC firewall rules, and anything agent-specific (agents, desktops, HTTPS URLs, key handling) is yours to build. It is built for every kind of server workload, from websites to GPU training, across Google Cloud's worldwide regions.
IONOS Cloud
IONOS Cloud is the public cloud of IONOS, a German hosting company in the United Internet group. It is a hyperscaler-style IaaS cloud, not an agent sandbox.
You rent KVM virtual machines: Cubes (fixed sizes from 1 to 16 vCPU with a local NVMe disk, billed by the minute), vCPU servers up to 60 vCPU and 230 GB of RAM, Dedicated Core servers and H200 GPU VMs. You build them in the Data Center Designer or through the Cloud API, SDKs and Terraform, next to block storage, private networks, firewalls and managed services. It is for teams that want to run their own servers in Germany, the rest of Europe or the US, and set up everything on them themselves.
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “16th cheapest of 364” means 15 of the other 363 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Google Compute Engine: price rank | IONOS Cloud: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 120th of 367, with limits $1,106 a month | 64th of 367, with limits $492 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 177th of 366, with limits $1,433 a month | 107th of 366, with limits $540 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code-interpreter bursts fit IONOS (53rd) and Compute Engine (92nd) better than bochka (186th), whose start limits queue large bursts. | 92nd of 345, with limits $133 a month | 53rd of 345, with limits $27 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month bochka ranks 1st for sandboxes for your users; on IONOS (35th) and Compute Engine (92nd) you build HTTPS access, isolation per user and lifecycle tooling yourself. | 92nd of 361, with limits $836 a month | 35th of 361, with limits $182 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month IONOS ranks 9th for RL rollouts, ahead of bochka at 34th and Compute Engine at 36th. | 36th of 360, with limits $2,085 a month | 9th of 360, with limits $740 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 16th cheapest of 364 $263 a month | 93rd of 364, with limits $137 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month IONOS ranks 1st of 377 for CI runners and Compute Engine 41st; bochka ranks 4th and adds /dev/kvm for Android and VM builds, which E2 VMs lack. | 41st cheapest of 377 $359 a month | Cheapest of 377 $60 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB For a dev box that stays on all month, IONOS ranks 9th, bochka 18th and Compute Engine 82nd. | 82nd cheapest of 368 $109 a month | 9th cheapest of 368 $20 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither cloud has a desktop stream or computer-use API, so you install and stream one yourself; bochka ranks 6th with a 60fps desktop on every machine. | 129th of 369, with limits $293 a month | 86th of 369, with limits $137 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ranks 7th with Chromium and browser control ready; on IONOS (156th) and Compute Engine (212th) you install and wire the browser yourself. | 212th of 367, with limits $244 a month | 156th of 367, with limits $74 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 218th of 346, with limits $179 a month | 153rd of 346, with limits $40 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 108th of 338, with limits $2,978 a month | 39th of 338, with limits $897 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 152nd of 360, with limits $120 a month | 105th of 360, with limits $38 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Both clouds rent GPUs: Compute Engine has Nvidia T4 up to GB200, and IONOS has H200 VMs with 1 to 8 GPUs; bochka has no GPUs. | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Google Compute Engine | IONOS Cloud | bochka |
|---|---|---|---|
| Kind of product | General cloud VMs from a hyperscaler | General cloud servers (Cubes, vCPU and Dedicated Core servers) plus storage, networks and managed services | Sandboxes for AI agents: a full VM with agents, desktop, URLs and snapshots set up |
| Isolation | Every instance is a full KVM-based VM with its own kernel | Every server is a KVM VM with its own kernel | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Docker, root and systemd; nested KVM only on some Intel families and N4D, not on E2, Arm or other AMD VMs | Root Linux VM where you install Docker; running your own VMs inside is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Stopping a machine | A stopped VM stops CPU and memory charges; disks and external IPs keep billing | Suspended Cubes keep billing; to stop paying you snapshot and delete the Cube | A stopped sandbox costs nothing and keeps its disk |
| Snapshots | On demand or on a schedule you set | Manual full snapshots of one volume, usable only in the same location | Automatic snapshots every minute and on stop |
| Fork and suspend | Suspend keeps memory for up to 60 days; cloning means a machine image and a new VM | Snapshot a disk, then create new VMs from it; disk only, no memory | Fork a running sandbox in one call; resume reboots from disk |
| Coding agents | None preinstalled; you install agents and drive them over SSH | None in the VM; an MCP server lets your AI client manage IONOS resources | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the machine | No credential proxy; service account tokens and Secret Manager values are read inside the VM | None; you put secrets into the VM yourself | AI credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Desktop and computer use | No managed desktop, browser or computer-use API on Linux VMs | None; a remote console for troubleshooting servers | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Reaching the machine | External IPv4 and any port through firewall rules; HTTPS needs your own certificate and a load balancer or web server | Public IP on each VM and any port you open; reserved IPv4 billed per 30 days; load balancers | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound network rules | VPC egress firewall rules by IP and port; domain rules on Cloud NGFW Standard, a paid tier | Network Security Groups with egress rules by IP, port and protocol | Open internet on every plan; no provider-side allowlist |
| GPUs | Nvidia GPUs from T4 and L4 up to H100, H200, B200 and GB200 | NVIDIA H200 PCIe VMs with 1 to 8 GPUs | None |
| Operating systems and CPUs | Linux and Windows Server on Intel, AMD and Arm | Linux and Windows Server VMs, Windows licence billed per vCPU | Linux on AMD Ryzen 9 9950X (Zen 5); Wine for Windows apps |
| Regions | 43 regions and 130 zones worldwide | Germany, UK, France, Spain and the US | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Google Compute Engine | IONOS Cloud | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Not published | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | Yes | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | Yes | Yes | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | Yes | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Compute Engine or IONOS Cloud: neither was in StarSling's public benchmark run we use. In that run on 2026-09-29, bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on dedicated AMD Ryzen 9 9950X hosts. Compute Engine speed depends on the machine family you pick, and IONOS's CPU model varies by location.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Google Compute Engine and IONOS Cloud have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Google Compute Engine, a month | IONOS Cloud, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $31 · Pay-as-you-go billing account (no plan fee) | $5 · Pay as you go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $64 · Pay-as-you-go billing account (no plan fee) · with limits | $20 · Pay as you go | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $1,291 · Pay-as-you-go billing account (no plan fee) | $240 · Pay as you go | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $378 · Pay-as-you-go billing account (no plan fee) | $74 · Pay as you go · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $690 · Pay-as-you-go billing account (no plan fee) | $148 · Pay as you go · with limits | $2,000 · $2000/mo · with limits |
Google Compute Engine: Compute Engine bills each VM per second after a 1 minute minimum at its list rate, here E2 sizes on demand in us-central1, with no platform fee. Disks and external IPs bill on top, also while stopped, and the always-on price shown needs a 3-year commitment.
IONOS Cloud: IONOS bills Cubes by the minute at a fixed rate per size with the NVMe disk included, and vCPU servers per core and per GB of RAM. Suspended Cubes keep billing, so the $5 workday figure assumes you snapshot and delete the machine each night.
Limits in those scenarios
Compute Engine caps vCPUs per region with quotas that vary by project, so 50 agents or 300 user sandboxes may need a quota request first, and a free trial account cannot ask for more. IONOS does not publish how many machines a fresh account can run at once, so 300 user sandboxes and 1,000 short jobs at once are not confirmed there; you ask IONOS Cloud Support to raise the limits. On bochka, the 1,000-job burst does not fit: the $2,000 plan allows 90 starts a minute, 600 an hour and 2,400 a day.
| Scenario | Google Compute Engine | IONOS Cloud | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Google Compute Engine when
you need regions outside Europe, a wide range of GPUs, Arm machines, or domain-based egress rules, and you have people to build the tooling on top.
- Regions all over the world. Useful if users sit in Asia, Australia or the Americas: Compute Engine runs in 43 regions and 130 zones.
- More GPUs, Arm and nested VMs. Useful for model work or Arm builds: Nvidia GPUs up to GB200, Arm machine types, and nested KVM on some families.
- Memory suspend and domain rules. Useful if a VM must resume with its processes running, or code may reach only chosen domains.
Use IONOS Cloud when
you want lower list prices from a German provider, plain servers in Europe, the UK or the US, and H200 GPUs or Windows Server.
- Lower list prices. Useful for steady servers on a budget: IONOS comes out cheaper than Compute Engine in every scenario we priced.
- A German company with UK and US sites. Useful if you want a European provider with data centers in Germany, France, Spain, the UK and the US.
- Simple billing with free traffic. Useful if you want fixed Cube sizes billed by the minute, with the first 2 TB of outgoing traffic free each month.
Where bochka fits
Compute Engine and IONOS both rent plain cloud VMs that you set up yourself. If what you are really running is AI agents, bochka gives each one a ready full VM with coding agents, /dev/kvm, a desktop and HTTPS URLs. Pick one of the two clouds if you need GPUs, Windows or regions outside the EU.
Coding agents you drive from outside
On both clouds you install each agent, copy real API keys into the VM and write the code that prompts and watches it. bochka ships the agents, a prompt, steer and events API, and a credentials proxy that keeps keys outside.
/dev/kvm, minute snapshots and free stops
E2 VMs have no nested KVM and IONOS does not document it, so Android emulators can fail. Compute Engine disks bill while stopped, and suspended IONOS Cubes keep billing unless you snapshot and delete them.
Desktop and HTTPS URLs ready
Neither cloud has a desktop for computer-use agents, so you install a desktop and a streaming server on each VM. Showing a user an agent's app needs your own certificate and load balancer; bochka gives HTTPS URLs on 50 ports.
Use bochka when your agents need a ready full VM: coding agents you drive by API, keys kept outside, /dev/kvm, a desktop, HTTPS URLs, snapshots every minute and free stops. Compare it one to one: bochka vs Google Compute Engine and bochka vs IONOS Cloud.
Questions people ask
Is Google Compute Engine cheaper than IONOS Cloud?
No. IONOS is cheaper in every scenario we priced: one agent running all month is $20 on IONOS and $64 on Compute Engine with a 3-year commitment, and 50 agents in parallel come to $240 against $1,291. On bochka they cost $26 and $317.
Which is faster, Compute Engine or IONOS?
We have no comparable measurement for either: neither was in the public benchmark run we use. In that run bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Can Compute Engine and IONOS run Docker?
Yes, both give you a root Linux VM where you install Docker. Nested virtualization is another matter: Compute Engine does not offer it on E2, Arm or most AMD VMs, and IONOS does not document it. bochka has Docker and /dev/kvm on every machine.
Does a stopped machine cost money?
On Compute Engine, a stopped VM stops CPU and memory charges, but its disks and external IPs keep billing. IONOS says suspended Cubes continue to incur costs, so you snapshot and delete a Cube to stop paying. On bochka, a stopped sandbox costs nothing and keeps its disk.
Which has GPUs and more regions?
Compute Engine has more of both: Nvidia GPUs from T4 up to GB200 across 43 regions. IONOS rents H200 GPU VMs in Frankfurt and Worcester, with servers in Germany, the UK, France, Spain and the US. bochka has no GPUs and runs only in the EU.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Google Compute Engine
- bochka vs IONOS Cloud
- AWS EC2 vs Google Compute Engine
- Google Compute Engine vs Azure Virtual Machines
- Google Compute Engine vs Oracle Cloud
- Google Compute Engine vs DigitalOcean
- Google Compute Engine vs Hetzner Cloud
- Google Compute Engine vs Vultr
- Google Compute Engine vs Linode
- Google Compute Engine vs Scaleway
- Google Compute Engine vs OVHcloud
- Google Compute Engine vs Contabo