Migrate Redis data to a Redis Managed Database using RedisShake

Last update: October 28 2026Open in Markdown

You can migrate Redis and Valkey data to Selectel with continuous synchronization and minimal downtime using RedisShake.

RedisShake connects to the source Redis as a replica. It first transfers a data snapshot (RDB) and an append-only file (AOF), and then continuously streams new changes to the target Redis until synchronization is stopped. Applications can be switched to the new Redis during data synchronization, minimizing service downtime.

This method is suitable for migration between sites and within the same environment, supporting various topologies, including Redis with Sentinel.

For data migration using RedisShake, Redis versions from 2.8 to 7.4 are supported. We recommend that the source and target Redis versions match.

Requirements

For small RedisShake installations, a configuration of 2 CPUs, 4 GB RAM, and 10 GB disk space is sufficient. Disk space depends on the size of the RDB and AOF files (parameters sync_rdb and sync_aof). For large amounts of data, we recommend estimating the required CPU performance based on benchmarks in the RedisShake documentation.

Additionally, you will need:

• network access from the RedisShake environment to the source and target Redis;
• RedisShake 4.x;
• Docker and Docker Compose or a Kubernetes cluster if RedisShake is run in a container.

Migrate data

1. Install RedisShake.

2. Configure RedisShake.

3. Start synchronization.

4. Optional: check the migration status.

5. Complete migration.

1. Install RedisShake

1. Download the binary from the RedisShake repository on GitHub. You can also pull the Docker image:

   docker pull ghcr.io/tair-opensource/redisshake:latest

2. If Redis is password-protected, pass it:

   redis-cli -h 127.0.0.1 -p 6379 -a '<password>'

   Specify <password> — Redis password.

3. Make sure that the source Redis is accessible from the environment where RedisShake will run:

   redis-cli -h <host> -p <port> ping
   telnet <host> <port>

   Specify:

   • <host> — Redis address;
   • <port> — default Redis port.

4. Check the cluster status and node list for Redis Cluster:

   redis-cli -h <host> -p <port> cluster info
   redis-cli -h <host> -p <port> cluster nodes

   Specify:

   • <host> — Redis address;
   • <port> — default Redis port.

5. Check memory usage:

   redis-cli -h <host> -p <port> info memory

   Specify:

   • <host> — Redis address;
   • <port> — default Redis port.

6. Repeat steps 3–5 to check the target Redis.

2. Configure RedisShake

1. Open the CLI.

2. Open the shake.toml file in a text editor.

3. Set synchronization parameters. If the source or target Redis is Redis Cluster, specify cluster = true for it. For a complete reference of shake.toml parameters, see the RedisShake repository on GitHub.

Redis → Redis

[sync_reader]
cluster = false
address = "<source_address>:6379"
username = ""
password = ""
tls = false
sync_rdb = true
sync_aof = true
# prefer_replica = false
# try_diskless = false

[redis_writer]
cluster = false
address = "<target_address>:6379"
username = ""
password = ""
tls = false
off_reply = false

Specify:

• <source_address> — source Redis address;
• <target_address> — target Redis address.

Redis with Sentinel → Redis

[sync_reader]
cluster = false
sentinel = true
master = "mymaster"
address = "<source_address>:26379"
username = ""
password = ""
tls = false
sync_rdb = true
sync_aof = true
# prefer_replica = false
# try_diskless = false

[redis_writer]
cluster = false
address = "<target_address>:6379"
username = ""
password = ""
tls = false
off_reply = false

Specify:

• <source_address> — source Redis with Sentinel address;
• <target_address> — target Redis address.

Redis → Redis with Sentinel

[sync_reader]
cluster = false
address = "<source_address>:6379"
username = ""
password = ""
tls = false
sync_rdb = true
sync_aof = true
# prefer_replica = false
# try_diskless = false

[redis_writer]
cluster = false
sentinel = true
master = "mymaster"
address = "<target_address>:26379"
username = ""
password = ""
tls = false
off_reply = false

Specify:

• <source_address> — source Redis address;
• <target_address> — target Redis with Sentinel address.

General parameters

Added to the configuration in any scenario.

[advanced]
dir = "data"
ncpu = 0               
pprof_port = 0
status_port = 0

log_file = "shake.log"
log_level = "<level>"          
log_interval = <time>

rdb_restore_command_behavior = "<operation>"

pipeline_count_limit = 1024
target_redis_client_max_querybuf_len = 1024_000_000
target_redis_proto_max_bulk_len = 512_000_000

empty_db_before_sync = true

Specify:

• ncpu = 0 — use all available CPUs;
• <level> — log level. Available values: debug, info or warn;
• <time> — frequency of logging progress, in seconds;
• <operation> — behavior on restore command errors:
  • panic — stop on error Target key name is busy;
  • rewrite — replace an existing key with a new value;
  • skip — skip such a key;
• empty_db_before_sync = true — flush data in the target Redis before starting synchronization. Make sure there is no required data in the target Redis.

3. Start synchronization

Before starting, check that the configuration file shake.toml is populated and located in the correct path.

Docker Compose

1. Open the CLI.

2. Prepare docker-compose.yaml:

   services:
       redis-shake:
       image: ghcr.io/tair-opensource/redisshake:latest
       container_name: redis-shake
       volumes:
           - ./shake.toml:/app/shake_sync_env.toml:ro
           - ./data:/app/data
       environment:
           SYNC: "true"

3. Run Docker Compose:

   docker compose up -d

Docker

1. Open the CLI.

2. Run RedisShake in a Docker container to synchronize Redis:

   docker run --rm \
   --name redis-shake \
   -e SYNC=true \
   -v $(pwd)/shake.toml:/app/shake_sync_env.toml \
   -v $(pwd)/data:/app/data \
   ghcr.io/tair-opensource/redisshake:latest

Binary

1. Open the CLI.

2. Run RedisShake:

   ./redis-shake shake.toml

Kubernetes

The source and target Redis must run inside the Kubernetes cluster.

If the Redis database is larger than 10 GB, instead of emptyDir, attach a persistent volume on fast disks for the data directory — the RDB snapshot and AOF log can take up a lot of space. We recommend checking the disk size on the source Redis in advance and attaching disks of sufficient size.

1. Open the CLI.

2. Prepare the redis-shake.yml manifest with ConfigMap and Deployment. In the ConfigMap, paste the contents of shake.toml:

   ---
   apiVersion: v1
   kind: ConfigMap
   metadata:
       name: redis-shake-config
       namespace: redis
   data:
       shake.toml: |
       [sync_reader]
       ...
       [redis_writer]
       ...
       [advanced]
       ...
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
       name: redis-shake
       namespace: redis
       labels:
       app: redis-shake
   spec:
       replicas: 1
       selector:
       matchLabels:
           app: redis-shake
       template:
       metadata:
           labels:
           app: redis-shake
       spec:
           containers:
           - name: redis-shake
               image: ghcr.io/tair-opensource/redisshake:latest
               volumeMounts:
               - name: config-volume
                   mountPath: /app/shake_sync_env.toml
                   subPath: shake.toml
               - name: data-volume
                   mountPath: /app/data
               resources:
               limits:
                   cpu: 2
                   memory: 4Gi
               requests:
                   cpu: 10m
                   memory: 2Gi
               env:
               - name: SYNC
                   value: "true"
           volumes:
           - name: config-volume
               configMap:
               name: redis-shake-config
           - name: data-volume
               emptyDir: {}

3. Apply the manifest:

   kubectl apply -f redis-shake.yml

4. Optional: Check migration status

During synchronization, RedisShake continuously writes status and current operations to the log. You can use the log to track how many changes are still remaining.

1. Open the CLI.

2. Enable real-time display of RedisShake logs:

   tail -f data/shake.log

3. Verify the number of keys in the source and target Redis:

   redis-cli -h <source_host> -p <source_port> dbsize
   redis-cli -h <target_host> -p <target_port> dbsize

   Specify:

   • <source_host> — source Redis address;
   • <source_port> — source Redis port;
   • <target_host> — target Redis address;
   • <target_port> — target Redis port.

5. Complete migration

1. Switch applications to the new Redis while synchronization is still running. This ensures that changes made prior to the switch are not lost.

2. When all data has been transferred, stop RedisShake using the same method you used to start it.

   Docker Compose

   1. Open the CLI.

   2. Stop and remove containers:

      docker compose down

   Docker

   1. Open the CLI.

   2. Stop and remove the container:

      docker kill redis-shake

   Binary

   1. Open the CLI.

   2. Stop RedisShake processes at the OS level:

      pkill -f redis-shake

   Kubernetes

   1. Open the CLI.

   2. Delete all resources described in the manifest from the Kubernetes cluster:

      kubectl delete -f redis-shake.yml