Runtime

How to run Redis in a cloud sandbox

Install redis-server with apt in an Ubuntu 24.04 microVM, check it with redis-cli ping, and connect to 127.0.0.1:6379 from the sandbox.

On Runtime, a paused sandbox keeps Redis's dataset in memory with no persistence configured. A pause saves the machine's memory and running processes, so a cache, a queue or an agent's scratch state is there, unchanged, when the sandbox wakes, for up to 365 days. Every sandbox is a Firecracker microVM with its own kernel, so a test that runs FLUSHALL touches only its own server. An 8 GiB sandbox holding a large dataset costs $0.06125 an hour while nothing queries it: memory at $0.0075 a GiB-hour plus the 50-millicore CPU floor (pricing).

Versions on 25 September 2026

Source Redis version Install
Ubuntu 24.04 (redis-server) 7.0.15 sudo apt-get install -y redis-server
Redis's apt repository (packages.redis.io) 8.6.1 add the repository, then sudo apt-get install -y redis
Clients redis-py 8.1.0 on PyPI; redis 6.2.1 and ioredis 6.0.0 on npm pip install, npm install

Start Redis and use it

The package installs a service, and Redis's own documentation says it starts after installation and at boot. The samples ask it to answer before going on, and start it if it has not.

TypeScriptimport { Sandbox } from "withruntime";await using sbx = await Sandbox.create({ timeoutSeconds: 1800 });await sbx.exec("sudo apt-get update -qq && sudo apt-get install -y -qq redis-server", {  check: true,  timeoutMs: 600_000,});await sbx.exec("redis-cli ping | grep -q PONG || sudo systemctl start redis-server", {  check: true,});await sbx.exec("pip install --quiet redis==8.1.0", { check: true, timeoutMs: 300_000 });await sbx.files.write(  "/workspace/worker.py",  [    "import redis",    "r = redis.Redis(decode_responses=True)",    "for n in range(1, 6):",    "    r.rpush('jobs', f'job-{n}')",    "done = [r.lpop('jobs') for _ in range(r.llen('jobs'))]",    "print(len(done), 'jobs processed')",  ].join("\n"),);const run = await sbx.exec("python3 worker.py", { check: true });console.log(run.stdout);console.log((await sbx.exec("redis-cli info memory | grep used_memory_human")).stdout);
Pythonfrom withruntime import Sandboxwith Sandbox.create(timeout_seconds=1800) as sbx:    sbx.exec("sudo apt-get update -qq && sudo apt-get install -y -qq redis-server",             check=True, timeout_ms=600_000)    sbx.exec("redis-cli ping | grep -q PONG || sudo systemctl start redis-server", check=True)    sbx.exec("redis-cli set greeting hello", check=True)    print(sbx.exec("redis-cli get greeting", check=True).stdout)  # hello    sbx.exec("redis-cli --rdb /workspace/dump.rdb", check=True)   # a point-in-time copy    sbx.files.download("/workspace/dump.rdb", "dump.rdb")

redis-cli --rdb transfers an RDB dump from the server to a file the sandbox user owns, so the data can go home with you or into another Redis. Code in the sandbox reaches the server on 127.0.0.1:6379; nothing on the internet can connect in to a sandbox unless you open a way in.

Redis 8 from Redis's own repository

Redis's install guide for Ubuntu adds its signed repository. lsb_release -cs prints noble on a sandbox:

Terminalsudo apt-get install -y lsb-release curl gpgcurl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpgsudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpgecho "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.listsudo apt-get update && sudo apt-get install -y redis

It downloads over HTTPS, which the free trial allows. If Redis does not answer afterwards, the guide's fix is sudo systemctl enable redis-server and sudo systemctl start redis-server.

Park it, wake it, find the data still there

TypeScriptimport { Sandbox } from "withruntime";const cache = await Sandbox.getOrCreate("agent-cache", { image: "redis", idlePauseSeconds: 600 });await cache.exec("redis-cli set last-run $(date +%s)", { check: true });// Ten quiet minutes later the sandbox pauses by itself; billing moves to storage.// Tomorrow, from any process:const again = await Sandbox.getOrCreate("agent-cache");console.log((await again.exec("redis-cli get last-run")).stdout);

getOrCreate answers the sandbox that holds the name, woken if paused, so the same call works the first time and every time after. The redis image is built in the last section. A wake usually takes about half a second, and a paused sandbox is billed as storage: $0.08 per GB a month for the disk and memory it alone holds (pause and resume).

Inspect it from your machine

Terminalruntime sandbox port-forward agent-cache 16379:6379redis-cli -p 16379 monitor

RedisInsight or any client connects to 127.0.0.1:16379 the same way. The forward goes through Runtime's API with your key and works on the free trial (forward ports). The same call exists in the SDKs as sbx.forwardPort(6379) and sbx.forward_port(6379).

Redis in every sandbox

Build it into a custom image and the service starts with each sandbox made from it:

TypeScriptimport { Runtime } from "withruntime";const runtime = new Runtime();await runtime.images.build({  name: "redis",  recipe: { apt: ["redis-server"], pip: ["redis==8.1.0"] },});await using sbx = await runtime.sandboxes.create({ image: "redis", memoryMiB: 8192 });
Pythonfrom withruntime import Runtimeruntime = Runtime()runtime.images.build(name="redis", recipe={"apt": ["redis-server"], "pip": ["redis==8.1.0"]})sbx = runtime.sandboxes.create(image="redis", memory_mib=8192)

A sandbox gets the memory you ask for. Redis holds its data in that memory, so size memoryMiB for the dataset and keep Redis's maxmemory below it. The free trial allows up to 4 GiB per sandbox.

For Redis next to Postgres and your API, see Docker Compose integration tests; for a database with a disk that outlives sandboxes, see PostgreSQL in a sandbox.

Sources

Facts on this page were checked on 25 September 2026.

Claim 50 hours free