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

576

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

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

Александр Гладыш
источник
Привет, Стив! Есть проблема с моим сайтом, я добавил его в свой другой блог mind-geek.net/nosql/redis/delete-keys-specific-expiry-time , надеюсь, это поможет.
Гаурав Тевари
43
Это настолько распространенный сценарий, что я бы хотел, чтобы команда Redis рассмотрела возможность добавления собственной команды для него.
Тодд Меньер
В настоящее время вы можете просто сделать это с Луа, см. Ниже.
Александр Гладыш
3
@ToddMenier Только что предложил, вернул рассуждения о том, почему это никогда не произойдет: github.com/antirez/redis/issues/2042
Рэй
1
Множество людей задают похожие вопросы о том, как обрабатывать большое количество клавиш, клавиши со специальными символами и т. Д. Я создал отдельный вопрос, поскольку у нас сейчас есть эта проблема, и я не думаю, что ответ на этот вопрос опубликован. Вот другой вопрос: stackoverflow.com/questions/32890648/…
jakejgordon

Ответы:

431

Начиная с 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 .

mcdizzle
источник
23
Важное примечание: это не удастся, если у вас есть более пары тысяч ключей, соответствующих префиксу.
Натан Осман
93
Этот работает для большого количества ключей:EVAL "local keys = redis.call('keys', ARGV[1]) \n for i=1,#keys,5000 do \n redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) \n end \n return keys" 0 prefix:*
Sheerun
181
Ой ... Redis часто используется как простой кэш ключей / хранилищ. Это del prefix:* должно быть фундаментальной операцией: /
Ray
5
@ Откровенно говоря, если вам нужна эта функция, вы должны просто разбить данные по числовой базе данных или серверу и использовать flush / flushdb
Марк
9
Да, это не удастся, если ни один ключ не соответствует шаблону. Чтобы исправить это, я добавил ключ по умолчанию:EVAL "return redis.call('del', 'defaultKey', unpack(redis.call('keys', ARGV[1])))" 0 prefix:*
manuelmhtr
706

Выполнить в 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 и очистить старые ключи.

Casey
источник
14
Извините, но это не атомарное удаление. Кто-то может добавить новые ключи между KEYS и DEL. Я не хочу их удалять.
Александр Гладыш
36
Ключи, которые будут созданы после команды KEYS, не будут удалены.
Кейси
6
Мне просто нужно было очистить некоторые плохие ключи, поэтому первый ответ Кейси был точным, за исключением того, что мне пришлось переместить ключи за пределы кавычек: redis-cli KEYS "prefix: *" | xargs redis-cli DEL
jslatts
19
Первый ответ также помог мне. Другой вариант, если ваши ключи redis содержат кавычки или другие символы, которые запутывают xargs:redis-cli KEYS "prefix:*" | xargs --delim='\n' redis-cli DEL
переусердствуйте
18
Если у вас есть многопользовательские базы данных (пространства ключей), то это хитрость: допустим, вам нужно удалить ключи в db3:redis-cli -n 3 KEYS "prefix:*" | xargs redis-cli -n 3 DEL
Christoffer
73

Вот полностью рабочая и атомарная версия удаления шаблона, реализованная в 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

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

Eli
источник
10
Приведенный выше код сработает, если у вас будет значительное количество ключей (ошибка «слишком много элементов для распаковки»). Я рекомендую использовать цикл в части Lua:for _,k in ipairs(redis.call('keys', KEYS[1])) do redis.call('del', k) end
kikito
@ kikito, да, если lua не может увеличить стек до количества ключей, которые вы хотите удалить (скорее всего, из-за нехватки памяти), вам нужно сделать это с помощью цикла for. Я не рекомендовал бы делать это, если вам не нужно.
Эли
1
Lua unpackпреобразует таблицу в «список независимых переменных» (так называют другие языки explode), но максимальное число не зависит от системной памяти; это зафиксировано в луа через LUAI_MAXSTACKконстанту. В Lua 5.1 и LuaJIT это 8000, а в Lua 5.2 - 100000. Рекомендуется использовать опцию цикла for IMO.
Кикито
1
Стоит отметить, что сценарии lua доступны только с Redis 2.6 и выше
wallacer
1
Любое решение на основе Lua будет нарушать семантику, EVALпоскольку в нем заранее не указаны ключи, с которыми оно будет работать. Он должен работать на одном экземпляре, но не ожидайте, что он будет работать с Redis Cluster.
Кевин Кристофер Генри
67

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

Начиная с 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
Итамар Хабер
источник
9
Тем не менее, избегание использования KEYS определенно считается наилучшей практикой, так что это отличное решение, когда возможны неатомарные удаления.
fatal_error
Это сработало для меня; однако мои ключи оказались в базе данных 1. Поэтому мне приходилось добавлять -n 1к каждому redis-cliвызову:redis-cli -n 1 --scan --pattern "*:foo:bar:*" | xargs -L 100 redis-cli -n 1 DEL
Роб Йохансен
Обратите внимание, что это не работает, если ваши ключи содержат специальные символы
mr1031011
Интересная и ценная находка ... Интересно, есть ли способ процитировать вещи для xargs ...
Итамар Хабер
что делает -L 100 ??
Апарна
41

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

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

randomor
источник
37

Я использую команду ниже в 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);
            }
        }

Спасибо :)

Яшрайсиньх Джадежа
источник
23

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

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

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

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

efaruk
источник
2
Использование lua намного быстрее, чем использование xargs, порядка 10 ^ 4.
Дипак
22

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

Предположим, в вашем 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
Вишал Тхакур
источник
3
Спасибо, но вывод трубопровода redis-cli delне является атомарным.
Александр Гладыш
13

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

redis-cli keys "pattern: *" | xargs -L1 -I '$' echo '"$"' | xargs redis-cli del
работе 33
источник
10

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

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

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

Guitan
источник
8

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

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).

Максимум
источник
Хорошее решение, но мои ценности сами по себе хэши. И Redis хранит хэш внутри другого хэша.
Александр Гладыш
3
Тем не менее, поля в хэше не имеют функциональности expire, что иногда действительно полезно.
Эви Сонг
для меня это самый чистый / самый простой ответ на сегодняшний день
Себастьен Х.
Разве набор не имеет больше смысла?
Джек Так
5

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

alexpopescu
источник
4
Но я не могу понять, как использовать их здесь. DEL сам по себе атомарен (или я так думаю). И я не могу получить значения из KEYS, пока не выполню EXEC, поэтому я не могу использовать KEYS и DEL в одном и том же MULTI.
Александр Гладыш
5

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
plhn
источник
5

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

redis-cli --scan --pattern sf_* | awk '{print $1}' | sed "s/^/'/;s/$/'/" | xargs redis-cli del
Квентин С.
источник
2
Этот скрипт отлично работает, протестирован с более чем 25000 ключей.
Джорди
1
Вы также можете добавить одинарные кавычки в awk, используя это забавное выражение `awk '{print"' "'" "$ 1"' "'"' "} '`
Роберто Конгиу
3

Версия, использующая 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
tekumara
источник
Это решение хорошо сработало даже для ключей длиной около 7 метров!
Дэнни
2

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

Если у вас есть десятки или сотни миллионов ключей, которые вы должны сопоставить, ответы, приведенные здесь, приведут к тому, что 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
Spajus
источник
2

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

введите описание изображения здесь

Топильский Александр
источник
Это делает это атомарно? И как это помогает сделать это в коде ?
Мэтью Читал
2

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

redis-cli --raw keys "$PATTERN" | xargs redis-cli del
Suf_Malek
источник
Не атомарный, а дублирует другие ответы.
Мэтью Читал
1

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

  • если у вас есть более одной базы данных на 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 
Махди Юсефи
источник
0

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

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

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

Крис
источник
0

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

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

Asalle
источник
-1

Я поддерживаю все ответы, связанные с наличием какого-либо инструмента или выполнением выражения 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();
    }

}
Denys
источник
-1

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

redis-cli -h redis_host_url KEYS "*abcd*" | xargs redis-cli -h redis_host_url DEL
Sumit Saurabh
источник
-3

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

Set<String> keys = redisTemplate.keys("geotag|*");
redisTemplate.delete(keys);
Ариджит Саха
источник
2
Я обновил образец кода Redisson. Ваш код не в атомарном подходе, как в Redisson. Между ключами keysи deleteвызовами методов могут появиться новые ключи .
Никита Кокшаров