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

-- 手動(dòng)或編程方式刪除
DEL key1 key2 key3 ...

# 一次性刪除（生產(chǎn)環(huán)境慎用）
redis-cli KEYS "*202512*" | xargs redis-cli DEL

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

-- 后續(xù)迭代（使用返回的新游標(biāo)）
SCAN "游標(biāo)值" 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
        
        -- 可選：添加延遲，減少對(duì)主線(xiàn)程的影響
        -- if #keys >= batchSize then
        --     redis.call('DEBUG', 'SLEEP', '0.001')
        -- end
    end
    
    -- 如果游標(biāo)回到0，表示迭代完成
until cursor == '0'

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

-- 在刪除前檢查內(nèi)存使用
INFO memory

-- 刪除后手動(dòng)觸發(fā)內(nèi)存整理（Redis 4.0+）
MEMORY PURGE

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

-- 監(jiān)控刪除過(guò)程中的內(nèi)存變化
MONITOR

-- 查看刪除進(jìn)度
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
            -- 記錄錯(cuò)誤，等待后重試
            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

# 直接簡(jiǎn)單的方案
redis-cli KEYS "*202512*" | xargs -n 1000 redis-cli DEL

# 帶詳細(xì)日志的方案
redis-cli --scan --pattern "*202512*" --count 1000 | \
while read key; do
    echo "Deleting: $key"
    redis-cli DEL "$key"
done

#!/bin/bash
# 分時(shí)段刪除腳本
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. 準(zhǔn)備測(cè)試數(shù)據(jù)
for i in {1..100000}; do
    redis-cli SET "test:202512:key$i" "value$i"
done

# 2. 測(cè)試各種方法
time redis-cli EVAL "...Lua腳本..." 0

# 3. 監(jiān)控性能指標(biāo)
redis-cli INFO stats | grep -E "(keyspace_hits|keyspace_misses|expired_keys|evicted_keys)"

-- 先使用TTL檢查是否為臨時(shí)數(shù)據(jù)
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  -- 永久數(shù)據(jù)
            table.insert(permanentKeys, key)
        end
    end
until cursor == '0'

return permanentKeys
" 0

# 獲取所有節(jié)點(diǎn)
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自動(dòng)化腳本示例
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}")
                    
                    # 檢查是否達(dá)到上限
                    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監(jiān)控配置示例
rules:
  - alert: RedisMassDeletion
    expr: rate(redis_command_duration_seconds_sum{command="DEL"}[5m]) > 100
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "大量刪除操作進(jìn)行中"
      description: "Redis DEL命令執(zhí)行頻率異常升高"

-- 先重命名，觀(guān)察業(yè)務(wù)影響
RENAME old_key deleted:old_key

-- 確認(rèn)無(wú)誤后再真正刪除
DEL deleted:old_key