---
title: 'Перенести данные Redis в облачную базу данных Redis'
sidebar_label: 'Перенести данные Redis в облачную базу данных Redis'
sidebar_position: 4
description: 'Как перенести данные из Redis, какие есть ограничения, как настроить миграцию и работать с ней'
---

import Formbricks from '@theme/MDXComponents/Formbricks'
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
import { TabItemLabel } from '@selectel/docux/components';

# Перенести данные Redis в облачную базу данных Redis

Вы можете перенести данные Redis и Valkey в Selectel с непрерывной синхронизацией и минимальным простоем с помощью RedisShake.

RedisShake подключается к исходному Redis как реплика.
Сначала он переносит снимок данных (RDB) и журнал операций (AOF), а потом непрерывно передает новые изменения в целевой Redis, пока синхронизацию не остановят.
Приложения можно переключить на новый Redis, пока синхронизация еще идет, поэтому простой минимальный.

Способ подходит для переноса между площадками и внутри одного окружения, поддерживает разные топологии, включая Redis с Sentinel.
Поддерживаются Redis от 2.8 до 7.4; желательно, чтобы версии исходного и целевого Redis совпадали.

## Требования \{#requirements}

Для небольших инсталляций RedisShake хватит 2 ядер CPU, 4 ГБ RAM и 10 ГБ на диске.
Место на диске зависит от размера файлов RDB и AOF (параметры `sync_rdb` и `sync_aof`).
Для больших объемов данных нужную производительность CPU стоит оценить по тестам в [документации RedisShake](https://tair-opensource.github.io/RedisShake/).

Дополнительно нужны:

* сетевой доступ из окружения RedisShake к исходному и целевому Redis;
* RedisShake 4.x;
* Docker и Docker Compose или кластер Kubernetes, если RedisShake запускается в контейнере.

## Перенести данные \{#transfer-data}

1. [Установите RedisShake](#install-redisshake).

2. [Настройте RedisShake](#configure-redisshake).

3. [Запустите синхронизацию](#start-synchronization).

4. Optional: [проверьте статус переноса](#check-migration-status).

5. [Завершите перенос](#complete-migration).

### 1. Установить RedisShake \{#install-redisshake}

1. Скачайте бинарный файл из [репозитория RedisShake на GitHub](https://github.com/tair-opensource/RedisShake/releases).
   Вы также можете скачать Docker-образ:

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

2. Если Redis защищен паролем, передайте его:

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

   Укажите `<password>` — пароль Redis.

3. Убедитесь, что исходный Redis доступен из окружения, где будет работать RedisShake:

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

   Укажите:

   * `<host>` — адрес Redis;
   * `<port>` — стандартный порт Redis.

4. Проверьте состояние кластера и список узлов для Redis Cluster:

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

   Укажите:

   * `<host>` — адрес Redis;
   * `<port>` — стандартный порт Redis.

5. Проверьте использование памяти:

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

   Укажите:

   * `<host>` — адрес Redis;
   * `<port>` — стандартный порт Redis.

6. Повторите шаги 3—5 для проверки целевого Redis.

### 2. Настроить RedisShake \{#configure-redisshake}

1. Откройте CLI.

2. Откройте файл `shake.toml` в текстовом редакторе.

3. Задайте параметры синхронизации.
   Если исходный или целевой Redis — Redis Cluster, укажите для него `cluster = true`.
   Полный справочник параметров `shake.toml` в [репозитории RedisShake на GitHub](https://github.com/tair-opensource/RedisShake).

<Tabs queryString="transfer-type">
  <TabItem value="redis-to-redis">
    <TabItemLabel>
      Redis → Redis
    </TabItemLabel>

    ```bash
    [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
    ```

    Укажите:

    * `<source_address>` — адрес исходного Redis;
    * `<target_address>` — адрес целевого Redis.
  </TabItem>

  <TabItem value="redis-with-sentinel-to-redis">
    <TabItemLabel>
      Redis с Sentinel → Redis
    </TabItemLabel>

    ```bash
    [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
    ```

    Укажите:

    * `<source_address>` — адрес исходного Redis с Sentinel;
    * `<target_address>` — адрес целевого Redis.
  </TabItem>

  <TabItem value="redis-to-redis-with-sentinel">
    <TabItemLabel>
      Redis → Redis с Sentinel
    </TabItemLabel>

    ```bash
    [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
    ```

    Укажите:

    * `<source_address>` — адрес исходного Redis;
    * `<target_address>` — адрес целевого Redis с Sentinel.
  </TabItem>

  <TabItem value="common-parameters">
    <TabItemLabel>
      Общие параметры
    </TabItemLabel>

    Добавляются в конфигурацию при любом сценарии.

    ```bash
    [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
    ```

    Укажите:

    * `ncpu = 0` — использовать все доступные CPU;
    * `<level>` — детализацию логов. Доступные значения: `debug`, `info` или `warn`;
    * `<time>` — периодичность записи прогресса в лог в секундах;
    * `<operation>` — поведение при ошибках команды `restore`:
      * `panic` — остановиться на ошибке `Target key name is busy`;
      * `rewrite` — заменить существующий ключ новым значением;
      * `skip` — пропустить такой ключ;
    * `empty_db_before_sync = true` — целевой Redis очищается перед началом синхронизации.
      Убедитесь, что в целевом Redis нет нужных данных.
  </TabItem>
</Tabs>

### 3. Запустить синхронизацию \{#start-synchronization}

Перед запуском проверьте, что конфигурационный файл `shake.toml` заполнен и лежит по нужному пути.

<Tabs queryString="start-synchronization">
  <TabItem value="docker-compose">
    <TabItemLabel>
      Docker Compose
    </TabItemLabel>

    1. Откройте CLI.

    2. Подготовьте `docker-compose.yaml`:

       ```bash
       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. Запустите Docker Compose:

       ```bash
       docker compose up -d
       ```
  </TabItem>

  <TabItem value="docker">
    <TabItemLabel>
      Docker
    </TabItemLabel>

    1. Откройте CLI.

    2. Запустите RedisShake в Docker-контейнере для синхронизации Redis:

       ```bash
       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
       ```
  </TabItem>

  <TabItem value="binary-file">
    <TabItemLabel>
      Бинарный файл
    </TabItemLabel>

    1. Откройте CLI.

    2. Запустите RedisShake:

       ```bash
       ./redis-shake shake.toml
       ```
  </TabItem>

  <TabItem value="kubernetes">
    <TabItemLabel>
      Kubernetes
    </TabItemLabel>

    Исходный и целевой Redis должны работать внутри кластера Kubernetes.

    Если база Redis больше 10 ГБ, вместо emptyDir подключите для каталога data постоянный том на быстрых дисках — снимок RDB и журнал AOF могут занимать много места.
    Размер дисков лучше заранее посмотреть на исходном Redis и подключить диски с запасом.

    1. Откройте CLI.

    2. Подготовьте манифест `redis-shake.yml` с ConfigMap и Deployment. В ConfigMap вставьте содержимое `shake.toml`:

       ```bash
       ---
       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. Примените манифест:

       ```bash
       kubectl apply -f redis-shake.yml
       ```
  </TabItem>
</Tabs>

### 4. Optional: проверить статус миграции \{#check-migration-status}

Во время синхронизации RedisShake постоянно пишет в журнал статус и текущие операции.
По журналу можно отследить, сколько изменений еще осталось.

1. Откройте CLI.

2. Включите отображение логов RedisShake в реальном времени:

   ```bash
   tail -f data/shake.log
   ```

3. Сверьте количество ключей в исходном и целевом Redis:

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

   Укажите:

   * `<source_host>` — адрес исходного Redis;
   * `<source_port>` — порт исходного Redis;
   * `<target_host>` — адрес целевого Redis;
   * `<target_port>` — порт целевого Redis.

### 5. Завершить миграцию \{#complete-migration}

1. Переключите приложения на новый Redis, пока синхронизация еще работает.
   Так не потеряются изменения, сделанные до переключения.

2. Когда все данные перенеслись, остановите RedisShake тем же способом, которым запускали.

<Tabs queryString="complete-migration">
  <TabItem value="docker-compose">
    <TabItemLabel>
      Docker Compose
    </TabItemLabel>

    1. Откройте CLI.

    2. Остановите и удалите контейнеры:

       ```bash
       docker compose down
       ```
  </TabItem>

  <TabItem value="docker">
    <TabItemLabel>
      Docker
    </TabItemLabel>

    1. Откройте CLI.

    2. Остановите и удалите контейнер:

       ```bash
       docker kill redis-shake
       ```
  </TabItem>

  <TabItem value="binary-file">
    <TabItemLabel>
      Бинарный файл
    </TabItemLabel>

    1. Откройте CLI.

    2. Остановите процессы RedisShake на уровне ОС:

       ```bash
       pkill -f redis-shake
       ```
  </TabItem>

  <TabItem value="kubernetes">
    <TabItemLabel>
      Kubernetes
    </TabItemLabel>

    1. Откройте CLI.

    2. Удалите из кластера Kubernetes все ресурсы, описанные в манифесте:

       ```bash
       kubectl delete -f redis-shake.yml
       ```
  </TabItem>
</Tabs>

<Formbricks />