全部笔记All notes

Redis 内存数据库完整指南

阅读 8m 54s8m 54s read

概述

Redis（Remote Dictionary Server）是一个开源的内存数据结构存储系统，可以用作数据库、缓存和消息代理。具有以下特点：

  • 高性能：基于内存存储，读写速度极快
  • 丰富数据类型：支持字符串、哈希、列表、集合、有序集合等
  • 持久化：支持 RDB 和 AOF 两种持久化方式
  • 高可用：支持主从复制、哨兵模式和集群
  • 原子操作：所有操作都是原子性的

💡 提示: Redis 特别适合缓存、会话存储、排行榜、计数器、消息队列等场景。

环境准备

系统要求

  • Docker 20.10+
  • 内存：至少 512MB RAM
  • 存储：SSD 推荐
  • 网络：稳定的网络连接

依赖检查

# 检查 Docker 版本
docker --version

# 检查可用内存
free -h

# 检查磁盘空间
df -h

Docker 安装部署

1. 查看可用的 Redis 版本

访问 Redis 镜像库地址：https://hub.docker.com/_/redis

也可以用命令来查看：

docker search redis

2. 拉取指定版本的 Redis 镜像

# 拉取最新版本
docker pull redis:latest

# 拉取指定版本
docker pull redis:7.2

3. 查看本地镜像

docker images | grep redis

4. 单节点部署

基本部署

# 简单部署
docker run -d \
  --name redis \
  -p 6379:6379 \
  redis:latest

# 带持久化的部署
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v redis_data:/data \
  redis:latest redis-server --appendonly yes

自定义配置部署

# 创建配置文件目录
mkdir -p /opt/redis/conf

# 创建 Redis 配置文件
cat > /opt/redis/conf/redis.conf << 'EOF'
# 网络配置
bind 0.0.0.0
port 6379
timeout 300
tcp-keepalive 60

# 内存配置
maxmemory 512mb
maxmemory-policy allkeys-lru

# 持久化配置
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec

# 安全配置
requirepass your_password_here

# 日志配置
loglevel notice
logfile ""
EOF

# 启动带自定义配置的 Redis
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /opt/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v redis_data:/data \
  redis:latest redis-server /usr/local/etc/redis/redis.conf

5. 使用 Docker Compose 部署

创建 docker-compose.yml 文件：

version: '3.8'

services:
  redis:
    image: redis:7.2
    container_name: redis
    restart: unless-stopped
    command: redis-server --requirepass yourpassword --appendonly yes
    environment:
      - REDIS_PASSWORD=yourpassword
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf
    networks:
      - redis_network
    sysctls:
      - net.core.somaxconn=65535
    ulimits:
      memlock: -1

  redis-commander:
    image: rediscommander/redis-commander:latest
    container_name: redis-commander
    restart: unless-stopped
    environment:
      - REDIS_HOSTS=redis:redis:6379:0:yourpassword
    ports:
      - "8081:8081"
    depends_on:
      - redis
    networks:
      - redis_network

volumes:
  redis_data:

networks:
  redis_network:
    driver: bridge

启动服务：

docker-compose up -d

6. 验证安装

# 查看容器运行状态
docker ps

# 查看日志
docker logs redis

# 测试连接
docker exec -it redis redis-cli ping

基本配置

连接 Redis

# 连接本地 Redis
redis-cli

# 连接带密码的 Redis
redis-cli -a yourpassword

# 连接远程 Redis
redis-cli -h host -p 6379 -a password

# 使用 Docker 连接
docker exec -it redis redis-cli

基本命令

# 测试连接
PING

# 设置密码
CONFIG SET requirepass yourpassword

# 验证密码
AUTH yourpassword

# 查看配置
CONFIG GET *

# 查看信息
INFO

# 选择数据库
SELECT 0

数据类型与操作

字符串（String）

# 设置值
SET key value
SET name "John Doe"

# 获取值
GET key
GET name

# 设置过期时间（秒）
SETEX key 3600 value
SETEX session:user1 3600 "user_data"

# 批量操作
MSET key1 value1 key2 value2
MGET key1 key2

# 数值操作
INCR counter
DECR counter
INCRBY counter 5

哈希（Hash）

# 设置哈希字段
HSET user:1 name "John" age 30 email "john@example.com"

# 获取哈希字段
HGET user:1 name
HGETALL user:1

# 批量操作
HMSET user:2 name "Alice" age 25 email "alice@example.com"
HMGET user:1 name age

# 字段操作
HEXISTS user:1 name
HDEL user:1 email
HKEYS user:1
HVALS user:1

列表（List）

# 左侧推入
LPUSH mylist "first" "second"

# 右侧推入
RPUSH mylist "third" "fourth"

# 获取列表
LRANGE mylist 0 -1

# 弹出元素
LPOP mylist
RPOP mylist

# 列表长度
LLEN mylist

# 指定位置插入
LINSERT mylist BEFORE "second" "new"

集合（Set）

# 添加成员
SADD myset "member1" "member2" "member3"

# 获取所有成员
SMEMBERS myset

# 检查成员存在
SISMEMBER myset "member1"

# 集合运算
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"
SINTER set1 set2  # 交集
SUNION set1 set2  # 并集
SDIFF set1 set2   # 差集

有序集合（Sorted Set）

# 添加成员
ZADD leaderboard 100 "player1" 200 "player2" 150 "player3"

# 获取排名
ZRANGE leaderboard 0 -1 WITHSCORES

# 按分数范围获取
ZRANGEBYSCORE leaderboard 100 200

# 获取排名
ZRANK leaderboard "player1"

# 增加分数
ZINCRBY leaderboard 50 "player1"

持久化配置

RDB 持久化

# 配置保存策略
CONFIG SET save "900 1 300 10 60 10000"

# 手动保存
SAVE        # 阻塞保存
BGSAVE      # 后台保存

# 查看最后保存时间
LASTSAVE

# 配置文件中的设置
save 900 1      # 900秒内至少1个key变化
save 300 10     # 300秒内至少10个key变化
save 60 10000   # 60秒内至少10000个key变化

AOF 持久化

# 开启 AOF
CONFIG SET appendonly yes

# 设置同步策略
CONFIG SET appendfsync everysec

# 重写 AOF 文件
BGREWRITEAOF

# AOF 配置选项
appendonly yes
appendfsync everysec    # always, everysec, no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

主从复制

配置主从复制

主节点配置 (redis-master.conf)

# 基本配置
port 6379
bind 0.0.0.0

# 安全配置
requirepass master_password
masterauth master_password

# 持久化
save 900 1
appendonly yes

从节点配置 (redis-slave.conf)

# 基本配置
port 6380
bind 0.0.0.0

# 主从配置
replicaof 127.0.0.1 6379
masterauth master_password
requirepass slave_password

# 只读配置
replica-read-only yes

Docker Compose 主从部署

version: '3.8'

services:
  redis-master:
    image: redis:7.2
    container_name: redis-master
    command: redis-server --requirepass master_password --appendonly yes
    ports:
      - "6379:6379"
    volumes:
      - redis_master_data:/data

  redis-slave:
    image: redis:7.2
    container_name: redis-slave
    command: redis-server --replicaof redis-master 6379 --masterauth master_password --requirepass slave_password
    ports:
      - "6380:6379"
    volumes:
      - redis_slave_data:/data
    depends_on:
      - redis-master

volumes:
  redis_master_data:
  redis_slave_data:

哨兵模式

哨兵配置文件 (sentinel.conf)

# 哨兵端口
port 26379

# 监控主节点
sentinel monitor mymaster 127.0.0.1 6379 2

# 主节点密码
sentinel auth-pass mymaster master_password

# 故障转移超时时间
sentinel down-after-milliseconds mymaster 30000

# 故障转移时间限制
sentinel failover-timeout mymaster 180000

# 并行同步的从节点数量
sentinel parallel-syncs mymaster 1

Docker Compose 哨兵部署

version: '3.8'

services:
  redis-master:
    image: redis:7.2
    container_name: redis-master
    command: redis-server --requirepass master_password
    networks:
      - redis_network

  redis-slave:
    image: redis:7.2
    container_name: redis-slave
    command: redis-server --replicaof redis-master 6379 --masterauth master_password
    depends_on:
      - redis-master
    networks:
      - redis_network

  redis-sentinel:
    image: redis:7.2
    container_name: redis-sentinel
    command: redis-sentinel /etc/redis/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/redis/sentinel.conf
    ports:
      - "26379:26379"
    depends_on:
      - redis-master
      - redis-slave
    networks:
      - redis_network

networks:
  redis_network:
    driver: bridge

集群配置

集群节点配置

# 启用集群模式
cluster-enabled yes

# 集群配置文件
cluster-config-file nodes.conf

# 节点超时时间
cluster-node-timeout 15000

# 集群端口
port 7000

Docker Compose 集群部署

version: '3.8'

services:
  redis-node-1:
    image: redis:7.2
    container_name: redis-node-1
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --port 7000
    ports:
      - "7000:7000"
      - "17000:17000"
    networks:
      - redis_cluster

  redis-node-2:
    image: redis:7.2
    container_name: redis-node-2
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --port 7001
    ports:
      - "7001:7001"
      - "17001:17001"
    networks:
      - redis_cluster

  redis-node-3:
    image: redis:7.2
    container_name: redis-node-3
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --port 7002
    ports:
      - "7002:7002"
      - "17002:17002"
    networks:
      - redis_cluster

networks:
  redis_cluster:
    driver: bridge

初始化集群

# 创建集群
redis-cli --cluster create \
  127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
  --cluster-replicas 1

# 检查集群状态
redis-cli -c -p 7000 cluster info
redis-cli -c -p 7000 cluster nodes

性能优化

内存优化

# 设置最大内存
CONFIG SET maxmemory 512mb

# 设置内存淘汰策略
CONFIG SET maxmemory-policy allkeys-lru

# 内存淘汰策略选项：
# noeviction       - 不淘汰任何key，内存满时报错
# allkeys-lru      - 在所有key中使用LRU算法删除
# volatile-lru     - 在设置了过期时间的key中使用LRU算法删除
# allkeys-random   - 在所有key中随机删除
# volatile-random  - 在设置了过期时间的key中随机删除
# volatile-ttl     - 删除即将过期的key

连接优化

# 连接配置
timeout 300
tcp-keepalive 60
tcp-backlog 511

# 客户端连接数
maxclients 10000

# 慢查询配置
slowlog-log-slower-than 10000
slowlog-max-len 128

管道操作

# Python 示例：使用管道批量操作
import redis

r = redis.Redis(host='localhost', port=6379, password='yourpassword')

# 使用管道
pipe = r.pipeline()
for i in range(1000):
    pipe.set(f'key_{i}', f'value_{i}')
pipe.execute()

安全配置

访问控制

# 设置密码
CONFIG SET requirepass your_strong_password

# 重命名危险命令
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG f85ac64b1b4747d0

# 绑定网络接口
bind 127.0.0.1 192.168.1.100

用户权限管理（Redis 6.0+）

# 创建用户
ACL SETUSER alice on >password ~cached:* +get +set

# 查看用户
ACL LIST

# 删除用户
ACL DELUSER alice

# 查看当前用户
ACL WHOAMI

监控与运维

监控命令

# 查看服务器信息
INFO
INFO memory
INFO replication
INFO persistence

# 监控执行的命令
MONITOR

# 查看慢查询
SLOWLOG GET 10

# 查看客户端连接
CLIENT LIST

# 查看键空间信息
INFO keyspace

性能分析

# 内存使用分析
MEMORY USAGE keyname
MEMORY STATS

# 延迟监控
LATENCY LATEST
LATENCY HISTORY command_name

# 键空间分析
SCAN 0 COUNT 1000

备份恢复

# RDB 备份
cp /data/dump.rdb /backup/dump-$(date +%Y%m%d).rdb

# AOF 备份
cp /data/appendonly.aof /backup/appendonly-$(date +%Y%m%d).aof

# 使用 redis-cli 备份
redis-cli --rdb backup.rdb

# 恢复数据
# 1. 停止 Redis 服务
# 2. 复制备份文件到数据目录
# 3. 重启 Redis 服务

客户端工具

命令行工具

# Redis CLI
redis-cli -h host -p port -a password

# Redis Benchmark
redis-benchmark -h host -p port -a password -n 100000 -c 50

# Redis RDB 工具
rdb --command json dump.rdb | head -10

可视化工具

  1. AnotherRedisDesktopManager

  2. Redis Commander

    • Web 界面管理工具
    • Docker 部署方便

  3. RedisInsight

    • Redis 官方可视化工具
    • 功能强大的分析工具

常见问题

问题1：内存使用过高

现象: Redis 内存占用持续增长 原因: 没有设置内存限制或淘汰策略 解决方案:

# 设置内存限制
CONFIG SET maxmemory 1gb

# 设置淘汰策略
CONFIG SET maxmemory-policy allkeys-lru

# 查看内存使用
INFO memory

问题2：连接超时

现象: 客户端连接 Redis 超时 原因: 网络问题或连接数限制 解决方案:

# 检查网络连接
telnet localhost 6379

# 检查连接数
redis-cli INFO clients

# 增加连接数限制
CONFIG SET maxclients 20000

问题3：持久化失败

现象: RDB 或 AOF 文件无法生成 原因: 磁盘空间不足或权限问题 解决方案:

# 检查磁盘空间
df -h

# 检查文件权限
ls -la /data/

# 手动触发保存
redis-cli BGSAVE

⚠️ 注意: 在生产环境中，建议同时启用 RDB 和 AOF 持久化，以确保数据安全。

相关文章

数据库相关

Redis 扩展功能

应用集成

运维部署

监控运维

大数据集成

相关阅读

  • Kafka 简明教程：./Kafka简明教程.md
  • RabbitMQ 入门：./RabbitMQ.md
  • MySQL 基础：../../../数据库/MySQL/MySQL.md
  • Flink CDC：../../../大数据/Flink/DataStream API/4. Flink CDC.md