Redis 内存数据结构存储

# 查看集群 Slot 分布
redis-cli cluster slots

# 手动分配 Slot
redis-cli --cluster add-node new-node:6379 existing-node:6379
redis-cli --cluster reshard <target-node>:6379

# 1. 新节点加入集群
redis-cli --cluster add-node <new-node-ip>:6379 <existing-node-ip>:6379

# 2. 重新分配 Slot（在线迁移）
redis-cli --cluster reshard <target-node-ip>:6379 \
  --cluster-from <source-node-id> \
  --cluster-to <target-node-id> \
  --cluster-slots <slot-count>

# 添加从节点
redis-cli --cluster add-node <new-node-ip>:6379 <existing-node-ip>:6379 \
  --cluster-slave --cluster-master-id <master-node-id>

# 删除节点
redis-cli --cluster del-node <node-ip>:6379 <node-id>

Redis Pod（sidecar: redis_exporter）
  └── Prometheus（ServiceMonitor / PodMonitor）
        └── Grafana Dashboard
              └── AlertManager（告警规则）

groups:
- name: redis
  rules:
  - alert: RedisMemoryHigh
    expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.85
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Redis 内存使用率超过 85%"

  - alert: RedisDown
    expr: redis_up == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Redis 实例 {{ $labels.instance }} 不可达"

  - alert: RedisReplicationLag
    expr: (redis_master_repl_offset - redis_slave_repl_offset) > 10485760
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Redis 主从复制延迟超过 10MB"

# 配置慢查询
CONFIG SET slowlog-log-slower-than 10000   # 超过 10ms 记录
CONFIG SET slowlog-max-len 128             # 最多保留 128 条

# 查看慢查询
SLOWLOG GET 10    # 最近 10 条
SLOWLOG LEN       # 总数
SLOWLOG RESET     # 清空

maxmemory 4gb
maxmemory-policy allkeys-lru

# 查看碎片率
INFO memory   # mem_fragmentation_ratio

# 自动碎片整理（Redis 4.0+）
CONFIG SET activedefrag yes
CONFIG SET active-defrag-ignore-bytes 100mb
CONFIG SET active-defrag-threshold-lower 10   # 碎片率 > 1.1

pipe := rdb.Pipeline()
incr := pipe.Incr(ctx, "pipeline_counter")
pipe.Expire(ctx, "pipeline_counter", time.Hour)
cmds, err := pipe.Exec(ctx)

# 写入
XADD mystream * field1 value1 field2 value2

# 读取（阻塞）
XREAD BLOCK 0 STREAMS mystream 0

# 消费者组
XGROUP CREATE mystream mygroup $ MKSTREAM
XREADGROUP GROUP mygroup consumer1 BLOCK 0 STREAMS mystream >

# 确认
XACK mystream mygroup <message-id>

# 限制长度
XADD mystream MAXLEN ~ 10000 * field value

# 加锁
SET lock:order:123 unique-client-id NX EX 30

# 释放（Lua 脚本保证原子性）
EVAL "
  if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
  else
    return 0
  end
" 1 lock:order:123 unique-client-id

# 添加元素
BF.ADD cache-filter "key:12345"
BF.EXISTS cache-filter "key:12345"

# 大规模导入
BF.RESERVE large-filter 0.01 1000000   # 错误率 1%，100 万容量
BF.MADD large-filter key1 key2 key3

func GetData(key string) (string, error) {
    val, err := rdb.Get(ctx, key).Result()
    if err == redis.Nil {
        // 缓存未命中，使用互斥锁
        lockKey := "lock:" + key
        locked, _ := rdb.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
        if locked {
            defer rdb.Del(ctx, lockKey)
            val = queryDB(key)
            rdb.Set(ctx, key, val, 30*time.Minute)
        } else {
            time.Sleep(100 * time.Millisecond)
            return GetData(key) // 重试
        }
    }
    return val, err
}

   # Hash 分批删除字段
   HSCAN key 0 COUNT 100 → HDEL key field1 field2 ...

rdb := redis.NewClient(&redis.Options{
    Addr:         "redis-headless:6379",
    Password:     os.Getenv("REDIS_PASSWORD"),
    DB:           0,
    PoolSize:     50,
    MinIdleConns: 10,
    MaxIdleConns: 50,
    PoolTimeout:  5 * time.Second,
    IdleTimeout:  5 * time.Minute,
    DialTimeout:  5 * time.Second,
    ReadTimeout:  3 * time.Second,
    WriteTimeout: 3 * time.Second,
})

maxclients 10000
timeout 300          # 空闲连接超时秒数
tcp-keepalive 60     # TCP keepalive 间隔
tcp-backlog 511      # TCP 完成队列大小

# redis.conf
tls-port 6380
port 0                          # 禁用非 TLS 端口
tls-cert-file /etc/tls/tls.crt
tls-key-file /etc/tls/tls.key
tls-ca-cert-file /etc/tls/ca.crt
tls-auth-clients yes            # 要求客户端证书
tls-protocols "TLSv1.2 TLSv1.3"
tls-ciphers DEFAULT:!MEDIUM

apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: redis-tls
spec:
  secretName: redis-tls-secret
  duration: 2160h
  renewBefore: 360h
  dnsNames:
  - "redis-0.redis-headless.redis.svc.cluster.local"
  - "*.redis-headless.redis.svc.cluster.local"
  issuerRef:
    name: ca-issuer
    kind: ClusterIssuer

# 创建用户
ACL SETUSER reader on >password ~* +@read -@write -@dangerous
ACL SETUSER writer on >password ~* +@all -@dangerous
ACL SETUSER appuser on >password ~prefix:* +@all

# 查看用户
ACL LIST
ACL GETUSER reader

# 配置文件持久化
aclfile /etc/redis/users.acl

# 从节点配置
replica-read-only yes        # 从节点只读（默认）
# 或
replica-read-only no         # 允许写入（数据会被主节点覆盖）

// 主节点（写入）
master := redis.NewClient(&redis.Options{
    Addr: "redis-master:6379",
})
// 从节点（读取）
slaves := redis.NewRing(&redis.RingOptions{
    Addrs: map[string]string{
        "slave0": "redis-slave-0.redis-headless:6379",
        "slave1": "redis-slave-1.redis-headless:6379",
    },
})

// 业务代码
master.Set(ctx, "key", "value", 0)
slaves.Get(ctx, "key")

SET key value
WAIT 1 1000    # 等待至少 1 个从节点确认，超时 1000ms

# Redis-Shake K8s Job
apiVersion: batch/v1
kind: Job
metadata:
  name: redis-shake-migration
spec:
  template:
    spec:
      containers:
      - name: redis-shake
        image: apsaradb/redis-shake:latest
        command:
        - redis-shake.linux
        args:
        - -type=sync            # sync / restore / scan
        - -conf=/etc/shake.toml
        volumeMounts:
        - name: config
          mountPath: /etc
      volumes:
      - name: config
        configMap:
          name: redis-shake-config
      restartPolicy: Never

[sync_reader]
address = "source-redis:6379"
password = "source-pwd"

[redis_writer]
address = "target-redis:6379"
password = "target-pwd"

affinity:
  podAntiAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
    - labelSelector:
        matchExpressions:
        - key: app
          operator: In
          values: ["redis"]
      topologyKey: kubernetes.io/hostname
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: node-role.kubernetes.io/redis
          operator: Exists

topologySpreadConstraints:
- maxSkew: 1
  topologyKey: topology.kubernetes.io/zone
  whenUnsatisfiable: DoNotSchedule
  labelSelector:
    matchLabels:
      app: redis
- maxSkew: 1
  topologyKey: kubernetes.io/hostname
  whenUnsatisfiable: ScheduleAnyway
  labelSelector:
    matchLabels:
      app: redis

tolerations:
- key: "dedicated"
  operator: "Equal"
  value: "redis"
  effect: "NoSchedule"
nodeSelector:
  node-group: redis

-- 分布式限流：令牌桶
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

local tokens = tonumber(redis.call('HGET', key, 'tokens')) or capacity
local last_time = tonumber(redis.call('HGET', key, 'last_time')) or now

local delta = math.max(0, now - last_time)
local new_tokens = math.min(capacity, tokens + delta * rate)

if new_tokens >= 1 then
    redis.call('HSET', key, 'tokens', new_tokens - 1)
    redis.call('HSET', key, 'last_time', now)
    return 1
else
    redis.call('HSET', key, 'tokens', new_tokens)
    redis.call('HSET', key, 'last_time', now)
    return 0
end

EVAL "<script>" 1 "rate_limit:user:123" 10 0.5 <current_timestamp>

WATCH balance:user:100
val = GET balance:user:100
MULTI
SET balance:user:100 <val - amount>
EXEC   # 如果 key 被修改，EXEC 返回 nil

# redis.conf
loadmodule /usr/lib/redis/modules/redisearch.so
loadmodule /usr/lib/redis/modules/rejson.so
loadmodule /usr/lib/redis/modules/redistimeseries.so

containers:
- name: redis
  image: redis/redis-stack-server:7.2.0-v10
  # 已内置 RedisJSON、RedisSearch、RedisTimeSeries、RedisBloom、RedisGraph

FT.CREATE idx:articles ON JSON PREFIX 1 article: SCHEMA \
  $.title AS title TEXT SORTABLE \
  $.content AS content TEXT \
  $.tags.* AS tags TAG

FT.SEARCH idx:articles "@title:kubernetes @tags:{redis}" RETURN 2 title tags

TS.CREATE ts:sensor:temp RETENTION 86400000 LABELS sensor_id 1
TS.ADD ts:sensor:temp * 23.5
TS.RANGE ts:sensor:temp <start> <end> AGGREGATION avg 60000   # 1 分钟均值

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: redis-pdb
spec:
  maxUnavailable: 1        # Sentinel：最多 1 个 Pod 不可用
  selector:
    matchLabels:
      app: redis

# Cluster 模式：每个 StatefulSet 至少保留 N-1 个可用
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: redis-cluster-pdb
spec:
  minAvailable: 5          # 6 节点集群至少保持 5 个可用
  selector:
    matchLabels:
      app: redis-cluster