Redis on Kubernetes 面试题

# Sentinel Deployment（3 副本）
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-sentinel
spec:
  replicas: 3
  selector:
    matchLabels:
      app: redis-sentinel
  template:
    spec:
      containers:
      - name: sentinel
        image: redis:7.2
        command: ["redis-sentinel"]
        args: ["/etc/redis/sentinel.conf"]
        ports:
        - containerPort: 26379

# Redis StatefulSet（3 副本：1 主 2 从）
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
spec:
  serviceName: redis-headless
  replicas: 3
  selector:
    matchLabels:
      app: redis
  template:
    spec:
      containers:
      - name: redis
        image: redis:7.2
        command: ["redis-server"]
        args: ["/etc/redis/redis.conf"]
        ports:
        - containerPort: 6379
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 50Gi

# 查看集群 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.conf
cluster-enabled yes
cluster-config-file /data/nodes.conf
cluster-node-timeout 15000
cluster-require-full-coverage no
cluster-announce-ip $(hostname).redis-cluster-headless.redis.svc.cluster.local
cluster-announce-port 6379
cluster-announce-bus-port 16379

apiVersion: databases.spotahome.com/v1
kind: RedisFailover
metadata:
  name: redisfailover
spec:
  sentinel:
    replicas: 3
  redis:
    replicas: 3
    storage:
      persistentVolumeClaim:
        metadata:
          name: redis-data
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 50Gi

save 900 1       # 900 秒内至少 1 个键变更
save 300 10      # 300 秒内至少 10 个键变更
save 60 10000    # 60 秒内至少 10000 个键变更
dbfilename dump.rdb
dir /data

appendonly yes
appendfsync everysec    # 每秒同步一次（推荐）
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

volumeClaimTemplates:
- metadata:
    name: data
  spec:
    accessModes: ["ReadWriteOnce"]
    storageClassName: "ssd-storage"
    resources:
      requests:
        storage: 100Gi

# Headless Service
apiVersion: v1
kind: Service
metadata:
  name: redis-headless
spec:
  clusterIP: None
  selector:
    app: redis
  ports:
  - name: redis
    port: 6379
  - name: cluster-bus
    port: 16379
# StatefulSet
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
spec:
  serviceName: redis-headless
  replicas: 6
  podManagementPolicy: Parallel
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values: ["redis"]
            topologyKey: kubernetes.io/hostname
      containers:
      - name: redis
        image: redis:7.2
        command: ["redis-server"]
        args: ["/etc/redis/redis.conf"]
        ports:
        - containerPort: 6379
          name: redis
        - containerPort: 16379
          name: cluster-bus
        resources:
          requests:
            cpu: "2"
            memory: 4Gi
          limits:
            cpu: "4"
            memory: 8Gi
        volumeMounts:
        - name: data
          mountPath: /data
        - name: config
          mountPath: /etc/redis
        readinessProbe:
          exec:
            command: ["redis-cli", "ping"]
          initialDelaySeconds: 10
          periodSeconds: 5
        livenessProbe:
          exec:
            command: ["redis-cli", "ping"]
          initialDelaySeconds: 30
          periodSeconds: 10
      volumes:
      - name: config
        configMap:
          name: redis-config
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: "ssd-storage"
      resources:
        requests:
          storage: 100Gi

apiVersion: batch/v1
kind: CronJob
metadata:
  name: redis-backup
spec:
  schedule: "0 */4 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: redis:7.2
            env:
            - name: S3_BUCKET
              value: "redis-backups"
            command:
            - /bin/sh
            - -c
            - |
              redis-cli -h redis-0.redis-headless BGSAVE
              # 等待 BGSAVE 完成
              while [ $(redis-cli -h redis-0.redis-headless INFO persistence | grep rdb_bgsave_in_progress | cut -d: -f2) -eq 1 ]; do
                sleep 5
              done
              aws s3 cp /data/dump.rdb s3://$S3_BUCKET/redis-backup-$(date +%Y%m%d-%H%M).rdb              
            volumeMounts:
            - name: data
              mountPath: /data
          volumes:
          - name: data
            persistentVolumeClaim:
              claimName: data-redis-0
          restartPolicy: OnFailure

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 实例 XQOPEN $labels.instance XQCLOSE 不可达"

  - 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
}

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

# 灾备集群从节点
REPLICAOF <primary-cluster-master-ip> 6379

[sync_reader]
address = "primary-cluster-redis:6379"

[redis_writer]
address = "dr-cluster-redis:6379"

[advanced]
dir = /data
ncpu = 4

# K8s 侧
kubectl describe pod redis-0
kubectl logs redis-0 -c redis --tail=200
kubectl exec -it redis-0 -- redis-cli INFO
kubectl exec -it redis-0 -- redis-cli CLUSTER INFO
kubectl get events --field-selector involvedObject.name=redis-0

# Redis 侧
redis-cli INFO all
redis-cli CLUSTER NODES
redis-cli SLOWLOG GET 20
redis-cli CLIENT LIST
redis-cli MEMORY STATS
redis-cli --latency -h <host>