redka

Redka is a Redis-compatible data store that reimplements core Redis functionality using a SQL backend (SQLite or PostgreSQL). It allows data to exceed RAM capacity, supports ACID transactions, and provides SQL views for analysis.

Redka can be used in two ways:

1. Standalone Server: A Redis-compatible server implementing the RESP wire protocol.
2. Go Module: An in-process library for embedding Redka directly into Go applications.

Redka supports both SQLite and PostgreSQL. You must install a driver for your chosen database using go get.

SQLite Drivers

• github.com/mattn/go-sqlite3: CGO-based, fastest performance.
• github.com/ncruces/go-sqlite3: Pure Go, supports WASM.
• modernc.org/sqlite: Pure Go, libc port.

PostgreSQL Drivers

• github.com/lib/pq
• github.com/jackc/pgx/v5

go get github.com/ncruces/go-sqlite3

To create an in-memory database that does not persist to disk, use the special path file:/redka.db?vfs=memdb with redka.Open(). Note that all data will be lost once the database is closed.

// All data is lost when the database is closed.
redka.Open("file:/redka.db?vfs=memdb", nil)

Redka is distributed as a single-file binary. You can run it using the following command structure:

redka [-h host] [-p port] [-s unix-socket] [db-path]

Arguments and Flags:

• -h host: The network interface to listen on (defaults to localhost).
• -p port: The port to listen on (defaults to 6379).
• -s unix-socket: The path to a Unix socket. If provided, this overrides the host and port arguments.
• db-path: The path to a SQLite database file. If omitted, Redka runs with an in-memory database (data is not persisted).

# Use in-memory sqlite database.
./redka

# Use file sqlite database.
./redka redka.db

# Listen on all network interfaces.
./redka -h 0.0.0.0 -p 6379 redka.db

# Listen on unix socket.
./redka -s /tmp/redka.sock redka.db

# Use postgres database.
./redka -p 6379 "postgres://redka:redka@localhost:5432/redka?sslmode=disable"

To build from source, you must have Go 1.23+ and GCC installed. The resulting binary will be located at ./build/redka.

git clone https://github.com/nalgeon/redka.git
cd redka
make setup build

When accessing Redka data via SQL, do not query the raw tables directly. Instead, use the provided views which join the metadata from rkey with the specific data type tables.

There is a dedicated view for every data type:

• vkey: General key metadata
• vstring: String data
• vlist: List data
• vset: Set data
• vhash: Hash data
• vzset: Sorted set data

Note that etime (expiration) and mtime (modification) timestamps are stored in UTC.

You can run Redka using Docker containers. The default host is 0.0.0.0, the default port is 6379, and the default database is an in-memory SQLite database.

Use the following commands for different storage configurations:

# In-memory sqlite database.
docker run --rm -p 6379:6379 nalgeon/redka

# Persistent sqlite database using a host directory volume.
docker run --rm -p 6379:6379 -v /path/to/data:/data nalgeon/redka redka.db

# Postgres database on host machine.
docker run --rm -p 6379:6379 nalgeon/redka "postgres://redka:redka@host.docker.internal:5432/redka?sslmode=disable"

Redka provides ACID-compliant transactions that support automatic rollback in case of failure. You can manage transactions using the following commands via the DB.View or DB.Update Go APIs:

• MULTI: Starts a new transaction.
• EXEC: Executes all commands queued within the current transaction.
• DISCARD: Discards the current transaction and its queued commands.

Note: Unlike Redis, Redka does not support WATCH or UNWATCH commands.

Pull the Redka image from Docker Hub. This works for both x86 and ARM architectures.

docker pull nalgeon/redka

Download the latest Linux x86 binary, unzip it, and grant execution permissions.

curl -L -O "https://github.com/nalgeon/redka/releases/latest/download/redka_linux_amd64.zip"
unzip redka_linux_amd64.zip
chmod +x redka