The whole cloud,collapsed into memory.
Point real SDKs and CLIs at AWS, Azure & GCP running entirely on your machine. No accounts, no bills, no network — answers straight from RAM.
Every resource is live in RAM, on the real wire.
The collapse isn't marketing — it's the architecture. Each bucket, instance and table you create is a struct in an in-memory store, reachable over the actual cloud wire protocols. That's why it answers in single-digit milliseconds.
Wire it into a running app. One endpoint override.
To integrate cloudemu with an existing app, run it in server modeand set your SDK's endpoint — AWS_ENDPOINT_URL / BaseEndpoint, option.WithEndpoint, or the Azure ARM override. That runs your real code path end to end. Don't write a throwaway _test.go for integration.
Run it, point real code at it
Start the binary or Docker image and aim your already-running app, CLI or SDK — any language — at the printed endpoints. The real wire path runs end to end.
$ docker run -p 4566:4566 ghcr.io/stackshy/cloudemu
Call the drivers directly
Only inside Go code that already imports cloudemu — a fast in-process handle for unit tests. Not the path for wiring an existing service.
cloud := cloudemu.NewAWS()
Override the SDK endpoint
Production points at the real cloud; in front of cloudemu you flip one endpoint. Every SDK exposes the seam — nothing else changes.
# AWS — any SDK / CLI via env, or aws-sdk-go-v2 export AWS_ENDPOINT_URL=http://127.0.0.1:4566 o.BaseEndpoint = aws.String("http://127.0.0.1:4566") # GCP — cloud.google.com/go option.WithEndpoint("http://127.0.0.1:4569"), option.WithoutAuthentication() # Azure — azure-sdk-for-go (ARM, https + self-signed TLS) arm.ClientOptions → cloud endpoint https://127.0.0.1:4568
Run cloudemu in server mode and point your running service's SDK at it with an endpoint override (AWS_ENDPOINT_URL) — your real code path exercises it end-to-end, production unchanged.
Not a mock. A cloud you can push until it breaks.
It enforces lifecycle, throttles under load, injects outages and bends time — the failure paths your retries otherwise never run.
Chaos engineering
Schedule outages, latency spikes and throttling inside real time windows. Your backoff code runs for real, every test.
State machines
VMs walk pending → running → stopping → stopped. Start a terminated instance and you get an error, not a shrug.
Error injection
Fail every call, every Nth, the first N, or at a fixed probability — scoped to one operation or a whole service.
Recording & replay
Every call is recorded — inputs, outputs, timing — then asserted against with a fluent API. No spies to wire up.
Fake clock
A clock you advance by hand. TTL expiry, dedup windows and alarms fire on command, not on wall time.
Zero dependencies
The in-process library is standard-library only. It runs anywhere your test suite already runs.
One binary. Three clouds.
Not just mocks. Real backends.
The in-memory default stays instant and dependency-free. When a test needs the real thing, opt in — and point real Infrastructure-as-Code straight at it.
Real engines
A database, cache, function, VM, container, or bucket you create does the real thing — real SQL, real Redis, your code, real bytes. Wire one line; the rest stays in memory.
cloud := cloudemu.NewAWS(config.WithDatabaseEngine(pg))
Terraform & OpenTofu
Real apply / plan / destroy against cloudemu, proven idempotent in CI. The cloudemu-tf wrapper needs only an empty provider block.
$ cloudemu-tf apply
Freeze the whole cloud. Bring it back.
Snapshot cloudemu's entire state — across AWS, Azure, GCP and OCI — to one file, then restore it identity-preserving: every ARN, resource ID and cross-reference survives. Seed a baseline, branch from it, reset in an instant. The in-memory default stays ephemeral; persistence is opt-in.
$ cloudemu snapshot save state.json
Point real code at it.
Standalone / Docker
A long-lived local cloud. Point any app, CLI or SDK — any language — at it. The default for integration & E2E.
$ docker run -p 4566:4566 cloudemu
In-process HTTP
Wrap it in httptest and aim real SDK clients straight at the handle — for Go tests.
ts := httptest.NewServer(…)
Typed Go API
Skip the wire entirely — call the in-memory drivers directly in unit tests.
cloud := cloudemu.NewAWS()
Bring a cloud up in one line.
Point your existing tests at it today — no credentials, no network, no cleanup. A clean cloud on every run.