Как атомарно удалить ключи, соответствующие шаблону, используя Redis

В моей БД Redis у меня есть несколько prefix:<numeric_id>хэшей.

Иногда я хочу очистить их все атомарно. Как мне сделать это без использования какого-либо распределенного механизма блокировки?

Начиная с redis 2.6.0, вы можете запускать сценарии lua, которые выполняются атомарно. Я никогда не писал, но я думаю, что это будет выглядеть примерно так

EVAL "return redis.call('del', unpack(redis.call('keys', ARGV[1])))" 0 prefix:[YOUR_PREFIX e.g delete_me_*]

Предупреждение . Как сказано в документе Redis , из-за факторов производительности keys команду не следует использовать для обычных операций в производстве, эта команда предназначена для отладки и специальных операций. читать далее

Смотрите документацию EVAL .

Выполнить в Bash:

redis-cli KEYS "prefix:*" | xargs redis-cli DEL

ОБНОВИТЬ

Хорошо, я понял. Как насчет этого: сохранить текущий дополнительный инкрементный префикс и добавить его ко всем вашим ключам. Например:

У вас есть такие значения:

prefix_prefix_actuall = 2
prefix:2:1 = 4
prefix:2:2 = 10

Когда вам нужно очистить данные, вы сначала измените prefix_actuall (например, установите prefix_prefix_actuall = 3), чтобы ваше приложение записывало новые данные в префикс префикса ключей: 3: 1 и префикс 3: 2. Тогда вы можете безопасно взять старые значения из префикса: 2: 1 и префикса: 2: 2 и очистить старые ключи.

Вот полностью рабочая и атомарная версия удаления шаблона, реализованная в Lua. Он будет работать намного быстрее, чем версия xargs, благодаря гораздо меньшей скорости передачи данных по сети и абсолютно атомарен, блокируя любые другие запросы от redis до его завершения. Если вы хотите атомарно удалить ключи в Redis 2.6.0 или более поздней версии, это, безусловно, путь:

redis-cli -n [some_db] -h [some_host_name] EVAL "return redis.call('DEL', unpack(redis.call('KEYS', ARGV[1] .. '*')))" 0 prefix:

Это рабочая версия идеи @ mcdizzle в ответе на этот вопрос. Кредит на идею 100% достается ему.

РЕДАКТИРОВАТЬ: Согласно приведенному ниже комментарию Kikito, если у вас есть больше ключей для удаления, чем свободной памяти на вашем сервере Redis, вы столкнетесь с ошибкой «слишком много элементов для распаковки» . В этом случае сделайте:

for _,k in ipairs(redis.call('keys', ARGV[1])) do 
    redis.call('del', k) 
end

Как предложил Кикито.

Отказ от ответственности: следующее решение не обеспечивает атомарность.

Начиная с v2.8 вы действительно хотите использовать команду SCAN вместо KEYS [1]. Следующий скрипт Bash демонстрирует удаление ключей по шаблону:

#!/bin/bash

if [ $# -ne 3 ] 
then
  echo "Delete keys from Redis matching a pattern using SCAN & DEL"
  echo "Usage: $0 <host> <port> <pattern>"
  exit 1
fi

cursor=-1
keys=""

while [ $cursor -ne 0 ]; do
  if [ $cursor -eq -1 ]
  then
    cursor=0
  fi

  reply=`redis-cli -h $1 -p $2 SCAN $cursor MATCH $3`
  cursor=`expr "$reply" : '\([0-9]*[0-9 ]\)'`
  keys=${reply##[0-9]*[0-9 ]}
  redis-cli -h $1 -p $2 DEL $keys
done

[1] KEYS - опасная команда, которая может привести к DoS. Ниже приводится цитата со страницы документации:

Предупреждение: рассматривайте KEYS как команду, которую следует использовать только в производственных средах с особой осторожностью. Это может привести к снижению производительности при выполнении в больших базах данных. Эта команда предназначена для отладки и специальных операций, таких как изменение раскладки клавиатуры. Не используйте клавиши в вашем обычном коде приложения. Если вы ищете способ найти ключи в подмножестве вашего пространства ключей, подумайте об использовании наборов.

ОБНОВЛЕНИЕ: один вкладыш для того же базового эффекта -

$ redis-cli --scan --pattern "*:foo:bar:*" | xargs -L 100 redis-cli DEL

Для тех, у кого были проблемы с анализом других ответов:

eval "for _,k in ipairs(redis.call('keys','key:*:pattern')) do redis.call('del',k) end" 0

Замените key:*:patternсвой собственный шаблон и введите это, redis-cliи вы готовы.

Кредит Лиско от: http://redis.io/commands/del

Я использую команду ниже в Redis 3.2.8

redis-cli KEYS *YOUR_KEY_PREFIX* | xargs redis-cli DEL

Вы можете получить дополнительную помощь, связанную с поиском по шаблону ключей, здесь: - https://redis.io/commands/keys . Используйте удобный шаблон Glob стиле согласно вашему требованию , как *YOUR_KEY_PREFIX*или YOUR_KEY_PREFIX??или любой другой.

И если кто-то из вас интегрировал библиотеку Redis PHP, то вам поможет нижеследующая функция.

flushRedisMultipleHashKeyUsingPattern("*YOUR_KEY_PATTERN*"); //function call

function flushRedisMultipleHashKeyUsingPattern($pattern='')
        {
            if($pattern==''){
                return true;
            }

            $redisObj = $this->redis;
            $getHashes = $redisObj->keys($pattern);
            if(!empty($getHashes)){
                $response = call_user_func_array(array(&$redisObj, 'del'), $getHashes); //setting all keys as parameter of "del" function. Using this we can achieve $redisObj->del("key1","key2);
            }
        }

Спасибо :)

Решение @ mcdizle не работает, оно работает только для одной записи.

Этот работает для всех ключей с одинаковым префиксом

EVAL "for i, name in ipairs(redis.call('KEYS', ARGV[1])) do redis.call('DEL', name); end" 0 prefix*

Примечание. Вам следует заменить префикс на префикс ключа ...

Вы также можете использовать эту команду для удаления ключей:

Предположим, в вашем Redis есть много типов ключей, таких как

1. 'Xyz_category_fpc_12'
2. 'Xyz_category_fpc_245'
3. 'Xyz_category_fpc_321'
4. 'Xyz_product_fpc_876'
5. 'Xyz_product_fpc_302'
6. 'Xyz_product_fpc_01232'

Экс- « xyz_category_fpc » здесь хуг является имя_сайтом , и эти ключи связаны с продуктами и категориями сайта электронной коммерции и генерируются FPC.

Если вы используете эту команду, как показано ниже:

redis-cli --scan --pattern 'key*' | xargs redis-cli del

ИЛИ

redis-cli --scan --pattern 'xyz_category_fpc*' | xargs redis-cli del

Он удаляет все ключи, такие как ' xyz_category_fpc ' (удалить ключи 1, 2 и 3). Для удаления других 4, 5 и 6 цифровых клавиш используйте команду « xyz_product_fpc » в приведенной выше команде.

Если вы хотите удалить все в Redis , выполните следующие команды:

С редис-кли:

1. FLUSHDB - удаляет данные из базы данных CURRENT вашего соединения.
2. FLUSHALL - Удаляет данные из ВСЕХ баз данных.

Например: - в вашей оболочке:

redis-cli flushall
redis-cli flushdb

Если у вас есть пробел в имени ключей, вы можете использовать это в bash:

redis-cli keys "pattern: *" | xargs -L1 -I '$' echo '"$"' | xargs redis-cli del

Ответ @ itamar великолепен, но разбор ответа для меня не сработал, особенно. в случае, когда в данном сканировании не найдено ключей. Возможно более простое решение, прямо из консоли:

redis-cli -h HOST -p PORT  --scan --pattern "prefix:*" | xargs -n 100 redis-cli DEL

При этом также используется SCAN, который предпочтительнее, чем KEYS в производстве, но не атомарный.

У меня просто была такая же проблема. Я сохранил данные сеанса для пользователя в формате:

session:sessionid:key-x - value of x
session:sessionid:key-y - value of y
session:sessionid:key-z - value of z

Таким образом, каждая запись была отдельной парой ключ-значение. Когда сеанс уничтожен, я хотел удалить все данные сеанса, удалив ключи с шаблоном, session:sessionid:*но у redis такой функции нет.

Что я сделал: сохранить данные сеанса в хэше . Я просто создать хэш с хэш - идентификатор , session:sessionidа затем я толкаю key-x, key-y, key-zв том , что хэш (порядок не имеет для меня) , и если мне не нужно , что хэш больше просто сделать , DEL session:sessionidи все данные , связанные с этим хэш - идентификатор ушел. DELявляется атомарным, и доступ к данным / запись данных в хеш равен O (1).

Я думаю, что вам может помочь MULTI / EXEC / DISCARD . Хотя транзакции не эквивалентны 100% , вы сможете изолировать удаления от других обновлений.

FYI.

• только используя Bash и redis-cli
• не используется keys(это использует scan)
• хорошо работает в кластерном режиме
• не атомный

Может быть, вам нужно только изменить заглавные буквы.

scan-match.sh

#!/bin/bash
rcli=“/YOUR_PATH/redis-cli" 
default_server="YOUR_SERVER"
default_port="YOUR_PORT"
servers=`$rcli -h $default_server -p $default_port cluster nodes | grep master | awk '{print $2}' | sed 's/:.*//'`
if [ x"$1" == "x" ]; then 
    startswith="DEFAULT_PATTERN"
else
    startswith="$1"
fi
MAX_BUFFER_SIZE=1000
for server in $servers; do 
    cursor=0
    while 
        r=`$rcli -h $server -p $default_port scan $cursor match "$startswith*" count $MAX_BUFFER_SIZE `
        cursor=`echo $r | cut -f 1 -d' '`
        nf=`echo $r | awk '{print NF}'`
        if [ $nf -gt 1 ]; then
            for x in `echo $r | cut -f 1 -d' ' --complement`; do 
                echo $x
            done
        fi
        (( cursor != 0 ))
    do
        :
    done
done

clear-redis-key.sh

#!/bin/bash
STARTSWITH="$1"

RCLI=YOUR_PATH/redis-cli
HOST=YOUR_HOST
PORT=6379
RCMD="$RCLI -h $HOST -p $PORT -c "

./scan-match.sh $STARTSWITH | while read -r KEY ; do
    $RCMD del $KEY 
done

Запустите по приглашению Bash

$ ./clear-redis-key.sh key_head_pattern

Другие ответы могут не работать, если ваш ключ содержит специальные символы - Guide$CLASSMETADATA][1]например. Завершение каждого ключа в кавычки гарантирует, что они будут удалены должным образом:

redis-cli --scan --pattern sf_* | awk '{print $1}' | sed "s/^/'/;s/$/'/" | xargs redis-cli del

Версия, использующая SCAN вместо KEYS (как рекомендуется для производственных серверов), --pipeа не xargs.

Я предпочитаю pipe, а не xargs, потому что он более эффективен и работает, когда ваши ключи содержат кавычки или другие специальные символы, которые ваша оболочка пытается интерпретировать. Подстановка регулярного выражения в этом примере оборачивает ключ в двойные кавычки и экранирует любые двойные кавычки внутри.

export REDIS_HOST=your.hostname.com
redis-cli -h "$REDIS_HOST" --scan --pattern "YourPattern*" > /tmp/keys
time cat /tmp/keys | perl -pe 's/"/\\"/g;s/^/DEL "/;s/$/"/;'  | redis-cli -h "$REDIS_HOST" --pipe

Это не прямой ответ на вопрос, но, поскольку я попал сюда при поиске своих собственных ответов, я поделюсь этим здесь.

Если у вас есть десятки или сотни миллионов ключей, которые вы должны сопоставить, ответы, приведенные здесь, приведут к тому, что Redis не будет реагировать в течение значительного времени (минут?), И может произойти сбой из-за потребления памяти (будьте уверены, фоновое сохранение будет пнуть в середине вашей операции).

Следующий подход, несомненно, безобразен, но лучшего я не нашел. Атомность здесь не обсуждается, в этом случае главная цель - поддерживать Redis в рабочем состоянии и реагировать 100% времени. Он будет отлично работать, если у вас есть все ваши ключи в одной из баз данных, и вам не нужно сопоставлять какой-либо шаблон, но вы не можете использовать http://redis.io/commands/FLUSHDB из-за его природы блокировки.

Идея проста: написать скрипт, который запускается в цикле и использует операцию O (1), например http://redis.io/commands/SCAN или http://redis.io/commands/RANDOMKEY, чтобы получить ключи, проверяет, если они сопоставьте шаблон (если он вам нужен) и http://redis.io/commands/DEL поочередно .

Если есть лучший способ сделать это, пожалуйста, дайте мне знать, я обновлю ответ.

Пример реализации с помощью randomkey в Ruby, как задача rake, неблокирующая замена чего-то вроде redis-cli -n 3 flushdb:

desc 'Cleanup redis'
task cleanup_redis: :environment do
  redis = Redis.new(...) # connection to target database number which needs to be wiped out
  counter = 0
  while key = redis.randomkey               
    puts "Deleting #{counter}: #{key}"
    redis.del(key)
    counter += 1
  end
end

Это просто реализуется с помощью функции «Удалить ветку» в FastoRedis , просто выберите ветку, которую вы хотите удалить.

Пожалуйста, используйте эту команду и попробуйте:

redis-cli --raw keys "$PATTERN" | xargs redis-cli del

Я попробовал большинство методов, упомянутых выше, но они не сработали для меня, после некоторых поисков я нашел следующие пункты:

• если у вас есть более одной базы данных на Redis, вы должны определить базу данных, используя -n [number]
• если у вас есть несколько ключей, delно если есть тысячи или миллионы ключей, лучше использовать, unlinkпотому что unlink не блокирует, а del блокирует, для получения дополнительной информации посетите эту страницу unlink vs del
• также keysкак дель и блокирует

поэтому я использовал этот код для удаления ключей по шаблону:

 redis-cli -n 2 --scan --pattern '[your pattern]' | xargs redis-cli -n 2 unlink 

Бедняжка атомная масса-удалить?

может быть, вы могли бы настроить их все на EXPIREAT в одну и ту же секунду - как несколько минут в будущем - и затем подождать до этого времени и увидеть, как они все «самоуничтожаются» одновременно.

но я не совсем уверен, насколько это будет атомно.

Теперь вы можете использовать клиент Redis и выполнить сначала SCAN (поддерживает сопоставление с шаблоном), а затем DEL каждую клавишу в отдельности.

Тем не менее, существует проблема на официальном Redis GitHub создать скороговорка-сопрягая-дель здесь , идет показать ему некоторую любовь , если вы найдете его полезным!

Я поддерживаю все ответы, связанные с наличием какого-либо инструмента или выполнением выражения Lua.

Еще один вариант с моей стороны:

В наших производственных и опытных базах данных тысячи ключей. Время от времени нам нужно удалять некоторые ключи (по некоторой маске), изменять по некоторым критериям и т. Д. Конечно, невозможно сделать это вручную из CLI, особенно с использованием шардинга (512 логических дБ в каждом физическом).

Для этого я пишу клиентский инструмент Java, который выполняет всю эту работу. В случае удаления ключей утилита может быть очень простой, там только один класс:

public class DataCleaner {

    public static void main(String args[]) {
        String keyPattern = args[0];
        String host = args[1];
        int port = Integer.valueOf(args[2]);
        int dbIndex = Integer.valueOf(args[3]);

        Jedis jedis = new Jedis(host, port);

        int deletedKeysNumber = 0;
        if(dbIndex >= 0){
            deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, dbIndex);
        } else {
            int dbSize = Integer.valueOf(jedis.configGet("databases").get(1));
            for(int i = 0; i < dbSize; i++){
                deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, i);
            }
        }

        if(deletedKeysNumber == 0) {
            System.out.println("There is no keys with key pattern: " + keyPattern + " was found in database with host: " + host);
        }
    }

    private static int deleteDataFromDB(Jedis jedis, String keyPattern, int dbIndex) {
        jedis.select(dbIndex);
        Set<String> keys = jedis.keys(keyPattern);
        for(String key : keys){
            jedis.del(key);
            System.out.println("The key: " + key + " has been deleted from database index: " + dbIndex);
        }

        return keys.size();
    }

}

Ниже команда сработала для меня.

redis-cli -h redis_host_url KEYS "*abcd*" | xargs redis-cli -h redis_host_url DEL

Spring RedisTemplate сам обеспечивает функциональность. RedissonClient в последней версии устарел функциональность «deleteByPattern».

Set<String> keys = redisTemplate.keys("geotag|*");
redisTemplate.delete(keys);