RedisShake is an MIT-licensed, Go-based data processing and migration tool that moves data between Valkey and Redis deployments, built for operators and platform teams relocating standalone instances, clusters, or cloud-hosted Redis-compatible services without taking the source offline.

What it is

RedisShake is a command-line tool distributed by the tair-opensource project that reads data out of one Valkey or Redis deployment and writes it into another, optionally transforming and filtering keys along the way. It is written in Go, licensed under MIT, and lives in the Infrastructure and Operations / Databases space alongside the Redis ecosystem itself. It operates on live servers rather than on files, connecting to a source over PSync, loading an RDB dump, or walking the keyspace with Scan, then feeding the results to a destination writer.

The concrete problem it solves is moving Redis data between environments that do not share a native replication link. Redis replication is topology-bound: it works within a master–slave chain or a cluster, but not from an on-premise instance to a managed cloud service, not from standalone to sentinel, and not across cloud providers. RedisShake replaces ad-hoc scripting around DUMP/RESTORE, manual RDB file shuffling, and hand-rolled key scans with a single configuration file and one invocation, while keeping the source serving traffic.

Key capabilities

• Performs zero-downtime migration without data loss or service interruption, so the source keeps serving reads and writes during the transfer.
• Reads from three source modes: a PSync reader, an RDB reader, and a Scan reader.
• Supports Redis versions 2.8 through 8.4.x and Valkey 8.x through 9.x across standalone, master–slave, sentinel, and cluster deployments.
• Integrates with cloud Redis-compatible services, including Alibaba Cloud Tair (Redis OSS-Compatible), AWS ElastiCache, and AWS MemoryDB.
• Understands Tair module data types: TairString, TairZSet, and TairHash.
• Applies filter rules declared in shake.toml, such as block_key_prefix = ["temp:", "cache:"], to skip keys by prefix.
• Supports script-based data transformation through the function filter, allowing values to be rewritten in flight.

Who uses it and how

• Operators running a local cutover, invoking ./redis-shake shake.toml with a [sync_reader] source and a [redis_writer] destination to copy one instance into another.
• Teams lifting data out of a self-managed cluster and into a managed service such as ElastiCache or MemoryDB, where no native replication path exists between the two.
• Container-based deployments that pull ghcr.io/tair-opensource/redisshake and drive a run through environment variables such as SYNC=true, SHAKE_SRC_ADDRESS, and SHAKE_DST_ADDRESS instead of a config file.
• Users holding Tair module data who need TairString, TairZSet, or TairHash values preserved rather than dropped during a move.
• Automation and agent-driven workflows, using the project's README_FOR_AGENTS.md guide as a machine-readable usage reference.

Getting started

Download a binary from the project Releases page, run the published container image ghcr.io/tair-opensource/redisshake:latest, or clone the repository and run sh build.sh with Go installed. A run then takes a single shake.toml configuration file, for example: ./redis-shake shake.toml.

How it compares

The facts do not present a list of paid products that RedisShake is positioned to replace; instead they name commercial alternatives in the same problem space. Alibaba Cloud DTS and Tair Global Active-Active are cited as commercial solutions that can resume from the last checkpoint after an interruption, a capability RedisShake 4.x does not offer. RedisShake's distinction is that it is MIT-licensed, self-hosted, and runs against any Redis or Valkey endpoint without a vendor account.

When to use it — and when not to

Resumable transfer and checkpointing are not supported in version 4.x: an interrupted run does a full resync from the beginning, which makes long migrations over unstable links or very large keyspaces risky. A self-hoster operates the tool itself plus both Redis endpoints; no database, object storage, or SMTP service is required beyond those endpoints. Choose it when the source can stay live and the migration can complete in one pass, and look to a checkpointing commercial service when the dataset is large enough that restarting from zero is unacceptable.

docker run --network host \
    -e SYNC=true \
    -e SHAKE_SRC_ADDRESS=127.0.0.1:6379 \
    -e SHAKE_DST_ADDRESS=127.0.0.1:6380 \
    ghcr.io/tair-opensource/redisshake:latest

git clone https://github.com/tair-opensource/RedisShake
cd RedisShake
sh build.sh

Read the RedisShake usage guide and help me with my task:
https://raw.githubusercontent.com/tair-opensource/RedisShake/v4/README_FOR_AGENTS.md

[sync_reader]
address = "127.0.0.1:6379"

[redis_writer]
address = "127.0.0.1:6380"

[filter]
# skip keys with "temp:" or "cache:" prefix
block_key_prefix = ["temp:", "cache:"] 

./redis-shake shake.toml