Redis安全高效删除包含特定模式的所有键值对的完整方案

-- 查找所有匹配的键
KEYS "*202512*"

-- 手动或编程方式删除
DEL key1 key2 key3 ...

# 一次性删除（生产环境慎用）
redis-cli KEYS "*202512*" | xargs redis-cli DEL

-- 第一次迭代
SCAN 0 MATCH "*202512*" COUNT 100

-- 后续迭代（使用返回的新游标）
SCAN "游标值" MATCH "*202512*" COUNT 100

# 使用SCAN逐步删除
cursor="0"
while [ "$cursor" != "0" ] || [ "$first" == "true" ]; do
    if [ "$cursor" == "0" ]; then first="false"; fi
    result=$(redis-cli SCAN $cursor MATCH "*202512*" COUNT 1000)
    cursor=$(echo "$result" | head -1)
    keys=$(echo "$result" | tail -n +2)
    
    if [ -n "$keys" ]; then
        echo "$keys" | tr ' ' '\n' | xargs -L 1000 redis-cli DEL
    fi
done

EVAL "
local pattern = '*202512*'
local batchSize = 1000
local deletedCount = 0
local cursor = '0'

repeat
    -- 使用SCAN获取一批key
    local scanResult = redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', batchSize)
    cursor = scanResult[1]
    local keys = scanResult[2]
    
    -- 如果找到key，批量删除
    if #keys > 0 then
        redis.call('DEL', unpack(keys))
        deletedCount = deletedCount + #keys
        
        -- 可选：添加延迟，减少对主线程的影响
        -- if #keys >= batchSize then
        --     redis.call('DEBUG', 'SLEEP', '0.001')
        -- end
    end
    
    -- 如果游标回到0，表示迭代完成
until cursor == '0'

return {
    totalDeleted = deletedCount,
    status = 'COMPLETED'
}
" 0

-- 在删除前检查内存使用
INFO memory

-- 删除后手动触发内存整理（Redis 4.0+）
MEMORY PURGE

# 使用pipeline提高效率
redis-cli --scan --pattern "*202512*" | awk '{print "DEL "$0}' | redis-cli --pipe

-- 监控删除过程中的内存变化
MONITOR

-- 查看删除进度
INFO stats

EVAL "
local function safeDelete(pattern)
    local maxAttempts = 3
    local attempt = 1
    local cursor = '0'
    local totalDeleted = 0
    
    while attempt <= maxAttempts do
        local success, errorMsg = pcall(function()
            repeat
                local result = redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', 1000)
                cursor = result[1]
                local keys = result[2]
                
                if #keys > 0 then
                    redis.call('DEL', unpack(keys))
                    totalDeleted = totalDeleted + #keys
                end
            until cursor == '0'
        end)
        
        if success then
            break
        else
            -- 记录错误，等待后重试
            redis.log(redis.LOG_WARNING, 'Attempt ' .. attempt .. ' failed: ' .. errorMsg)
            attempt = attempt + 1
            if attempt <= maxAttempts then
                redis.call('DEBUG', 'SLEEP', '0.5')
            end
        end
    end
    
    return totalDeleted
end

return safeDelete('*202512*')
" 0

# 直接简单的方案
redis-cli KEYS "*202512*" | xargs -n 1000 redis-cli DEL

# 带详细日志的方案
redis-cli --scan --pattern "*202512*" --count 1000 | \
while read key; do
    echo "Deleting: $key"
    redis-cli DEL "$key"
done

#!/bin/bash
# 分时段删除脚本
MAX_KEYS_PER_BATCH=1000
SLEEP_TIME=1

total_deleted=0
cursor=0

while true; do
    result=$(redis-cli SCAN $cursor MATCH "*202512*" COUNT $MAX_KEYS_PER_BATCH)
    cursor=$(echo $result | cut -d' ' -f1)
    keys=$(echo $result | cut -d' ' -f2-)
    
    if [ -n "$keys" ]; then
        count=$(echo $keys | wc -w)
        redis-cli DEL $keys
        total_deleted=$((total_deleted + count))
        echo "$(date): Deleted $count keys, total: $total_deleted"
    fi
    
    if [ "$cursor" -eq "0" ]; then
        break
    fi
    
    sleep $SLEEP_TIME
done

# 1. 准备测试数据
for i in {1..100000}; do
    redis-cli SET "test:202512:key$i" "value$i"
done

# 2. 测试各种方法
time redis-cli EVAL "...Lua脚本..." 0

# 3. 监控性能指标
redis-cli INFO stats | grep -E "(keyspace_hits|keyspace_misses|expired_keys|evicted_keys)"

-- 先使用TTL检查是否为临时数据
EVAL "
local pattern = '*202512*'
local cursor = '0'
local permanentKeys = {}

repeat
    local result = redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', 100)
    cursor = result[1]
    local keys = result[2]
    
    for _, key in ipairs(keys) do
        local ttl = redis.call('TTL', key)
        if ttl == -1 then  -- 永久数据
            table.insert(permanentKeys, key)
        end
    end
until cursor == '0'

return permanentKeys
" 0

# 获取所有节点
redis-cli CLUSTER NODES | grep master | awk '{print $2}' | cut -d: -f1 | \
while read node; do
    redis-cli -h $node --scan --pattern "*202512*" | xargs -L 1000 redis-cli -h $node DEL
done

# Python自动化脚本示例
import redis
import logging
from datetime import datetime

class RedisKeyCleaner:
    def __init__(self, host='localhost', port=6379):
        self.redis = redis.Redis(host=host, port=port)
        self.logger = logging.getLogger(__name__)
    
    def safe_delete_by_pattern(self, pattern, batch_size=1000, max_keys=None):
        """安全删除指定模式的key"""
        deleted_count = 0
        cursor = '0'
        
        self.logger.info(f"Starting deletion for pattern: {pattern}")
        
        while True:
            cursor, keys = self.redis.scan(
                cursor=cursor,
                match=pattern,
                count=batch_size
            )
            
            if keys:
                # 分批删除
                for i in range(0, len(keys), 100):
                    batch = keys[i:i+100]
                    self.redis.delete(*batch)
                    deleted_count += len(batch)
                    
                    self.logger.info(f"Deleted {len(batch)} keys, total: {deleted_count}")
                    
                    # 检查是否达到上限
                    if max_keys and deleted_count >= max_keys:
                        self.logger.info(f"Reached max limit: {max_keys}")
                        return deleted_count
            
            if cursor == 0:
                break
        
        self.logger.info(f"Deletion completed. Total deleted: {deleted_count}")
        return deleted_count

# 使用示例
cleaner = RedisKeyCleaner()
cleaner.safe_delete_by_pattern("*202512*", batch_size=500)

# Prometheus监控配置示例
rules:
  - alert: RedisMassDeletion
    expr: rate(redis_command_duration_seconds_sum{command="DEL"}[5m]) > 100
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "大量删除操作进行中"
      description: "Redis DEL命令执行频率异常升高"

-- 先重命名，观察业务影响
RENAME old_key deleted:old_key

-- 确认无误后再真正删除
DEL deleted:old_key