简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

Ubuntu系统下Redis环境安装配置完全指南 从零开始搭建高效缓存数据库 解决常见问题提升系统性能 适合初学者和开发人员 快速掌握Redis部署技巧

威震华夏关云长

3万

主题

317

科技点

3万

积分

大区版主

木柜子打湿

积分
31893

财Doro三倍冰淇淋无人之境【一阶】立华奏小樱（小丑装）⑨的冰沙以外的星空【二阶】
发表于 2025-8-24 23:30:01 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
1. Redis简介与准备工作

1.1 什么是Redis

Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统，它可以用作数据库、缓存、消息中间件和队列。Redis支持多种类型的数据结构，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等，同时提供了丰富的操作命令。

Redis的主要特点包括：

• 高性能：基于内存操作，读写速度极快
• 持久化：支持数据持久化到磁盘
• 数据结构丰富：支持多种数据结构
• 原子性：所有操作都是原子性的
• 丰富的特性：支持发布/订阅、事务、Lua脚本等

1.2 安装前的准备工作

在开始安装Redis之前，我们需要确保系统环境满足要求并做好必要的准备工作。

• Ubuntu 18.04或更高版本（本指南以Ubuntu 20.04为例）
• 至少512MB的RAM（推荐2GB以上）
• 至少1GB的可用磁盘空间
• 具有sudo权限的用户账户

首先，我们需要更新系统的软件包列表和已安装的软件包，以确保系统是最新的：
  2. sudo apt update
  3. sudo apt upgrade -y
复制代码

Redis需要一些基本的依赖包，我们可以提前安装：
  2. sudo apt install -y build-essential tcl
复制代码

2. Redis安装方法

在Ubuntu系统下，有几种方法可以安装Redis。我们将介绍三种最常见的方法：使用APT包管理器安装、从源码编译安装和使用Docker安装。

2.1 使用APT包管理器安装

这是最简单、最快捷的安装方法，适合大多数用户。
  2. sudo apt install -y redis-server
复制代码

安装完成后，我们可以检查Redis服务的状态：
  2. sudo systemctl status redis-server
复制代码

如果Redis正在运行，你应该会看到类似以下的输出：
  2. ● redis-server.service - Advanced key-value store
  3.      Loaded: loaded (/lib/systemd/system/redis-server.service; enabled; vendor preset: enabled)
  4.      Active: active (running) since [日期时间]
  5.    Main PID: [PID号] (redis-server)
  6.      Status: "Ready to accept connections"
  7.       Tasks: 5 (limit: 4575)
  8.      Memory: 2.1M
  9.      CGroup: /system.slice/redis-server.service
  10.              └─[PID号] /usr/bin/redis-server 127.0.0.1:6379
复制代码

我们可以使用Redis CLI工具测试连接：
  2. redis-cli ping
复制代码

如果Redis正常工作，它会返回：
  2. PONG
复制代码

2.2 从源码编译安装

从源码编译安装可以让我们获得最新版本的Redis，并且可以根据需要自定义编译选项。

首先，我们需要从Redis官方网站下载最新的稳定版源码。你可以在Redis官网找到最新的下载链接。
  2. cd /tmp
  3. wget https://download.redis.io/redis-stable.tar.gz
  4. tar -xzvf redis-stable.tar.gz
  5. cd redis-stable
复制代码
  2. make
  3. sudo make install
复制代码

创建Redis配置目录和数据目录：
  2. sudo mkdir /etc/redis
  3. sudo mkdir /var/lib/redis
复制代码

复制配置文件模板：
  2. sudo cp redis.conf /etc/redis/redis.conf
复制代码

编辑配置文件：
  2. sudo nano /etc/redis/redis.conf
复制代码

找到并修改以下配置项：
  2. # 设置为守护进程模式
  3. daemonize yes
  5. # 设置PID文件位置
  6. pidfile /var/run/redis_6379.pid
  8. # 设置日志级别
  9. loglevel notice
  11. # 设置日志文件位置
  12. logfile /var/log/redis_6379.log
  14. # 设置工作目录
  15. dir /var/lib/redis
复制代码

创建systemd服务文件：
  2. sudo nano /etc/systemd/system/redis.service
复制代码

添加以下内容：
  2. [Unit]
  3. Description=Redis In-Memory Data Store
  4. After=network.target
  6. [Service]
  7. ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
  8. ExecStop=/usr/local/bin/redis-cli shutdown
  9. Restart=always
  10. Type=forking
  11. User=redis
  12. Group=redis
  13. RuntimeDirectory=redis
  14. RuntimeDirectoryMode=755
  16. [Install]
  17. WantedBy=multi-user.target
复制代码

创建Redis用户和组：
  2. sudo adduser --system --group --no-create-home redis
复制代码

设置正确的权限：
  2. sudo chown redis:redis /var/lib/redis
  3. sudo chmod 770 /var/lib/redis
复制代码

启动Redis服务：
  2. sudo systemctl start redis
  3. sudo systemctl enable redis
复制代码

验证Redis服务状态：
  2. sudo systemctl status redis
复制代码

2.3 使用Docker安装Redis

如果你熟悉Docker，这是一种快速部署Redis的方法。

如果你还没有安装Docker，可以按照以下步骤安装：
  2. sudo apt update
  3. sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
  4. curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
  5. sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
  6. sudo apt update
  7. sudo apt install -y docker-ce docker-ce-cli containerd.io
复制代码
  2. sudo docker run --name redis-server -d -p 6379:6379 redis:latest
复制代码
  2. sudo docker ps
复制代码

你应该能看到名为”redis-server”的容器正在运行。

连接到Redis容器：
  2. sudo docker exec -it redis-server redis-cli
复制代码

3. Redis基本配置

安装完成后，我们需要对Redis进行一些基本配置，以确保其安全性和性能。

3.1 Redis配置文件

Redis的主要配置文件是redis.conf，根据安装方法不同，它可能位于/etc/redis/redis.conf或/etc/redis/6379.conf。

3.2 基本配置项

默认情况下，Redis只绑定到本地回环地址（127.0.0.1），这意味着只有本地应用程序可以连接到Redis。如果你需要从其他机器访问Redis，可以修改此设置：
  2. sudo nano /etc/redis/redis.conf
复制代码

找到以下行：
  2. bind 127.0.0.1 ::1
复制代码

如果你想允许所有IP地址连接，可以将其修改为：
  2. bind 0.0.0.0
复制代码

或者，你可以指定特定的IP地址：
  2. bind 192.168.1.100
复制代码

注意：允许外部访问会增加安全风险，请确保你已经设置了密码验证或其他安全措施。

为了增强安全性，我们应该为Redis设置密码验证：
  2. sudo nano /etc/redis/redis.conf
复制代码

找到并取消注释以下行，并设置一个强密码：
  2. requirepass your_strong_password
复制代码

将your_strong_password替换为你自己的密码。

默认情况下，Redis使用6379端口。如果你想更改端口，可以修改以下设置：
  2. port 6380
复制代码

Redis提供了两种持久化机制：RDB（Redis Database）和AOF（Append Only File）。

RDB配置：

RDB是通过创建数据集的时间点快照来工作的。你可以配置以下参数：
  2. # 900秒内至少有1个key发生变化时保存
  3. save 900 1
  4. # 300秒内至少有10个key发生变化时保存
  5. save 300 10
  6. # 60秒内至少有10000个key发生变化时保存
  7. save 60 10000
  9. # 启用RDB压缩
  10. rdbcompression yes
  12. # RDB文件名
  13. dbfilename dump.rdb
  15. # RDB文件保存路径
  16. dir /var/lib/redis
复制代码

AOF配置：

AOF是通过记录所有写操作命令来工作的。要启用AOF，可以修改以下设置：
  2. appendonly yes
  4. # AOF文件名
  5. appendfilename "appendonly.aof"
  7. # AOF同步策略
  8. # always: 每个写操作都同步
  9. # everysec: 每秒同步一次
  10. # no: 由操作系统决定何时同步
  11. appendfsync everysec
  13. # 启用AOF重写
  14. auto-aof-rewrite-percentage 100
  15. auto-aof-rewrite-min-size 64mb
复制代码

Redis是基于内存的数据库，因此内存管理非常重要。你可以配置以下参数：
  2. # 最大内存限制（例如1GB）
  3. maxmemory 1gb
  5. # 内存达到上限时的淘汰策略
  6. # volatile-lru: 使用LRU算法淘汰设置了过期时间的key
  7. # allkeys-lru: 使用LRU算法淘汰所有key
  8. # volatile-lfu: 使用LFU算法淘汰设置了过期时间的key
  9. # allkeys-lfu: 使用LFU算法淘汰所有key
  10. # volatile-random: 随机淘汰设置了过期时间的key
  11. # allkeys-random: 随机淘汰所有key
  12. # volatile-ttl: 淘汰即将过期的key
  13. # noeviction: 不淘汰key，返回错误
  14. maxmemory-policy allkeys-lru
复制代码

3.3 应用配置更改

修改配置文件后，需要重启Redis服务以使更改生效：
  2. sudo systemctl restart redis-server
复制代码

或者，如果你使用的是源码编译安装的Redis：
  2. sudo systemctl restart redis
复制代码

4. Redis性能优化

为了充分发挥Redis的性能，我们需要进行一些优化配置。

4.1 内存优化

选择合适的数据结构可以显著减少内存使用：

• Hashes：当存储对象时，使用Hashes而不是多个String键可以节省内存。
• Lists：对于列表数据，使用Lists而不是多个String键。
• Sets：对于唯一值集合，使用Sets。
• Sorted Sets：对于需要排序的集合，使用Sorted Sets。

在配置文件中启用以下选项：
  2. # 启用Hashes的ziplist编码
  3. hash-max-ziplist-entries 512
  4. hash-max-ziplist-value 64
  6. # 启用Lists的ziplist编码
  7. list-max-ziplist-size -2
  8. list-compress-depth 0
  10. # 启用Sets的intset编码
  11. set-max-intset-entries 512
  13. # 启用Sorted Sets的ziplist编码
  14. zset-max-ziplist-entries 128
  15. zset-max-ziplist-value 64
复制代码

4.2 持久化优化
  2. # 禁用RDB快照保存（如果你只使用AOF）
  3. save ""
  5. # 启用RDB压缩
  6. rdbcompression yes
  8. # 启用RDB校验和
  9. rdbchecksum yes
复制代码
  2. # 启用AOF
  3. appendonly yes
  5. # 设置AOF同步策略为everysec（平衡性能和数据安全性）
  6. appendfsync everysec
  8. # 启用AOF重写
  9. auto-aof-rewrite-percentage 100
  10. auto-aof-rewrite-min-size 64mb
  12. # 启用AOF重写期间的增量同步
  13. no-appendfsync-on-rewrite no
复制代码

4.3 网络优化
  2. # 禁用TCP_NODELAY
  3. tcp-nodelay no
  5. # 设置TCP keepalive
  6. tcp-keepalive 300
  8. # 设置客户端超时时间（秒）
  9. timeout 0
  11. # 设置最大客户端连接数
  12. maxclients 10000
复制代码

4.4 使用Redis集群

对于大规模应用，单个Redis实例可能无法满足需求。在这种情况下，可以考虑使用Redis集群。

Redis集群是Redis提供的分布式数据库解决方案，它可以将数据自动分片到多个Redis节点。

搭建Redis集群需要至少6个节点（3个主节点和3个从节点）。以下是搭建Redis集群的基本步骤：

1. 创建6个Redis配置文件，每个文件使用不同的端口：
  2. # 创建配置目录
  3. mkdir -p /etc/redis/cluster
  5. # 创建6个配置文件
  6. for port in 7000 7001 7002 7003 7004 7005; do
  7.   mkdir -p /etc/redis/cluster/node-${port}
  8.   cat > /etc/redis/cluster/node-${port}/redis.conf << EOF
  9. port ${port}
  10. cluster-enabled yes
  11. cluster-config-file nodes-${port}.conf
  12. cluster-node-timeout 5000
  13. appendonly yes
  14. appendfilename appendonly-${port}.aof
  15. dbfilename dump-${port}.rdb
  16. dir /etc/redis/cluster/node-${port}
  17. EOF
  18. done
复制代码

1. 启动6个Redis实例：
  2. for port in 7000 7001 7002 7003 7004 7005; do
  3.   redis-server /etc/redis/cluster/node-${port}/redis.conf
  4. done
复制代码

1. 安装Ruby和Redis集群工具：
  2. sudo apt install -y ruby ruby-dev
  3. sudo gem install redis
复制代码

1. 创建Redis集群：
  2. 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
复制代码

1. 验证集群状态：
  2. redis-cli -p 7000 cluster nodes
复制代码

5. Redis安全配置

安全是任何数据库系统的重要考虑因素，Redis也不例外。

5.1 网络安全

如前所述，你可以通过修改bind参数来限制Redis监听的IP地址：
  2. bind 192.168.1.100
复制代码

使用UFW（Uncomplicated Firewall）限制对Redis端口的访问：
  2. # 启用UFW
  3. sudo ufw enable
  5. # 允许特定IP访问Redis端口
  6. sudo ufw allow from 192.168.1.50 to any port 6379
  8. # 或者，允许特定子网访问Redis端口
  9. sudo ufw allow from 192.168.1.0/24 to any port 6379
复制代码

5.2 认证安全

我们已经讨论了如何设置密码验证：
  2. requirepass your_strong_password
复制代码

确保使用强密码，包括大小写字母、数字和特殊字符。

为了增加安全性，你可以重命名或禁用一些危险的Redis命令：
  2. # 重命名命令
  3. rename-command FLUSHDB ""
  4. rename-command FLUSHALL ""
  5. rename-command DEBUG ""
  6. rename-command CONFIG ""
  7. rename-command SHUTDOWN ""
复制代码

将命令重命名为空字符串可以禁用该命令。

5.3 数据加密

Redis支持SSL/TLS加密，可以保护数据在传输过程中的安全。要启用SSL/TLS，你需要：

1. 生成SSL证书和私钥：
  2. # 生成私钥
  3. openssl genrsa -out redis.key 2048
  5. # 生成证书签名请求
  6. openssl req -new -key redis.key -out redis.csr
  8. # 生成自签名证书
  9. openssl x509 -req -days 365 -in redis.csr -signkey redis.key -out redis.crt
复制代码

1. 配置Redis使用SSL/TLS：
  2. # 启用TLS
  3. tls-cert-file /path/to/redis.crt
  4. tls-key-file /path/to/redis.key
  5. tls-ca-cert-file /path/to/ca.crt
  7. # 强制客户端使用TLS
  8. tls-auth-clients yes
复制代码

1. 使用SSL/TLS连接Redis：
  2. redis-cli --tls --cert /path/to/redis.crt --key /path/to/redis.key --cacert /path/to/ca.crt
复制代码

6. Redis监控与维护

6.1 Redis监控工具

Redis CLI提供了多个命令用于监控Redis状态：
  2. # 查看Redis信息和统计
  3. redis-cli info
  5. # 查看内存使用情况
  6. redis-cli info memory
  8. # 查看持久化信息
  9. redis-cli info persistence
  11. # 查看客户端连接
  12. redis-cli client list
  14. # 查看慢查询日志
  15. redis-cli slowlog get
复制代码

Redis-stat是一个简单的Redis监控工具，可以实时显示Redis的统计信息。

安装Redis-stat：
  2. sudo gem install redis-stat
复制代码

运行Redis-stat：
  2. redis-stat --server
复制代码

然后，你可以在浏览器中访问http://localhost:63790查看监控信息。

Redis Commander是一个基于Web的Redis管理工具。

安装Redis Commander：
  2. sudo npm install -g redis-commander
复制代码

运行Redis Commander：
  2. redis-commander
复制代码

然后，你可以在浏览器中访问http://localhost:8081管理Redis。

6.2 Redis维护

RDB备份：
  2. # 创建RDB快照
  3. redis-cli BGSAVE
  5. # 复制RDB文件
  6. cp /var/lib/redis/dump.rdb /path/to/backup/dump-$(date +%Y%m%d).rdb
复制代码

AOF备份：
  2. # 复制AOF文件
  3. cp /var/lib/redis/appendonly.aof /path/to/backup/appendonly-$(date +%Y%m%d).aof
复制代码

从RDB恢复：

1. 停止Redis服务：
  2. sudo systemctl stop redis-server
复制代码

1. 替换RDB文件：
  2. cp /path/to/backup/dump.rdb /var/lib/redis/dump.rdb
复制代码

1. 启动Redis服务：
  2. sudo systemctl start redis-server
复制代码

从AOF恢复：

1. 停止Redis服务：
  2. sudo systemctl stop redis-server
复制代码

1. 替换AOF文件：
  2. cp /path/to/backup/appendonly.aof /var/lib/redis/appendonly.aof
复制代码

1. 启动Redis服务：
  2. sudo systemctl start redis-server
复制代码

你可以创建一个cron作业来定期执行Redis维护任务：
  2. # 编辑cron表
  3. crontab -e
复制代码

添加以下内容以每天凌晨2点执行Redis备份：
  2. 0 2 * * * redis-cli BGSAVE && cp /var/lib/redis/dump.rdb /path/to/backup/dump-$(date +\%Y\%m\%d).rdb
复制代码

7. 常见问题及解决方案

7.1 连接问题

可能原因：

• Redis服务未运行
• 防火墙阻止了连接
• Redis配置了绑定特定IP地址

解决方案：

1. 检查Redis服务状态：
  2. sudo systemctl status redis-server
复制代码

如果Redis未运行，启动它：
  2. sudo systemctl start redis-server
复制代码

1. 检查防火墙设置：
  2. sudo ufw status
复制代码

如果需要，允许Redis端口：
  2. sudo ufw allow 6379
复制代码

1. 检查Redis配置：
  2. sudo nano /etc/redis/redis.conf
复制代码

确保bind参数配置正确。

可能原因：

• Redis服务未运行
• Redis监听错误的端口或IP地址

解决方案：

1. 检查Redis服务状态并启动：
  2. sudo systemctl status redis-server
  3. sudo systemctl start redis-server
复制代码

1. 检查Redis配置中的端口和绑定地址：
  2. sudo nano /etc/redis/redis.conf
复制代码

确保port和bind参数配置正确。

7.2 内存问题

可能原因：

• 数据量过大
• 内存泄漏
• 未设置最大内存限制

解决方案：

1. 检查内存使用情况：
  2. redis-cli info memory
复制代码

1. 设置最大内存限制：
  2. sudo nano /etc/redis/redis.conf
复制代码

添加或修改以下行：
  2. maxmemory 1gb
复制代码

1. 配置内存淘汰策略：
  2. maxmemory-policy allkeys-lru
复制代码

1. 分析并优化数据结构：
  2. # 查看大键
  3. redis-cli --bigkeys
  5. # 查看内存使用情况
  6. redis-cli info memory
复制代码

可能原因：

• 达到了最大内存限制
• 没有配置合适的内存淘汰策略

解决方案：

1. 增加最大内存限制：
  2. sudo nano /etc/redis/redis.conf
复制代码

修改maxmemory参数：
  2. maxmemory 2gb
复制代码

1. 配置内存淘汰策略：
  2. maxmemory-policy allkeys-lru
复制代码

1. 清理不必要的数据：
  2. # 查看所有键
  3. redis-cli KEYS "*"
  5. # 删除特定键
  6. redis-cli DEL keyname
复制代码

7.3 性能问题

可能原因：

• 持久化配置不当
• 网络延迟
• 内存不足
• 慢查询

解决方案：

1. 检查慢查询日志：
  2. redis-cli slowlog get
复制代码

1. 优化持久化配置：
  2. sudo nano /etc/redis/redis.conf
复制代码

调整以下参数：
  2. # 对于AOF
  3. appendfsync everysec
  5. # 对于RDB
  6. save 900 1
  7. save 300 10
  8. save 60 10000
复制代码

1. 检查网络延迟：
  2. # 使用ping命令测试延迟
  3. redis-cli --latency
复制代码

1. 检查内存使用情况：
  2. redis-cli info memory
复制代码

7.4 持久化问题

可能原因：

• 磁盘空间不足
• 权限问题
• 内存不足

解决方案：

1. 检查磁盘空间：
  2. df -h
复制代码

1. 检查目录权限：
  2. ls -la /var/lib/redis
复制代码

确保Redis用户有写入权限：
  2. sudo chown -R redis:redis /var/lib/redis
复制代码

1. 检查内存使用情况：
  2. redis-cli info memory
复制代码

可能原因：

• AOF重写未配置或失败
• 大量写操作

解决方案：

1. 手动触发AOF重写：
  2. redis-cli BGREWRITEAOF
复制代码

1. 配置AOF自动重写：
  2. sudo nano /etc/redis/redis.conf
复制代码

确保以下参数已配置：
  2. auto-aof-rewrite-percentage 100
  3. auto-aof-rewrite-min-size 64mb
复制代码

1. 检查AOF文件：
  2. # 检查AOF文件大小
  3. ls -lh /var/lib/redis/appendonly.aof
  5. # 修复AOF文件
  6. redis-check-aof --fix /var/lib/redis/appendonly.aof
复制代码

8. Redis高级应用

8.1 Redis数据类型与使用场景

Strings是Redis最基本的数据类型，可以存储文本、二进制数据等。

基本操作：
  2. # 设置键值
  3. SET key value
  5. # 获取键值
  6. GET key
  8. # 自增
  9. INCR key
  11. # 自减
  12. DECR key
  14. # 设置过期时间（秒）
  15. SETEX key seconds value
复制代码

使用场景：

• 缓存
• 计数器
• 会话存储

Hashes是一个键值对集合，适合存储对象。

基本操作：
  2. # 设置字段值
  3. HSET key field value
  5. # 获取字段值
  6. HGET key field
  8. # 获取所有字段和值
  9. HGETALL key
  11. # 删除字段
  12. HDEL key field
复制代码

使用场景：

• 存储对象
• 用户信息
• 配置信息

Lists是一个字符串元素的有序集合，按插入顺序排序。

基本操作：
  2. # 左侧插入
  3. LPUSH key value1 value2
  5. # 右侧插入
  6. RPUSH key value1 value2
  8. # 左侧弹出
  9. LPOP key
  11. # 右侧弹出
  12. RPOP key
  14. # 获取范围内的元素
  15. LRANGE key start stop
复制代码

使用场景：

• 消息队列
• 最新文章列表
• 时间线

Sets是一个无序、唯一的字符串元素集合。

基本操作：
  2. # 添加元素
  3. SADD key member1 member2
  5. # 获取所有元素
  6. SMEMBERS key
  8. # 删除元素
  9. SREM key member
  11. # 检查元素是否存在
  12. SISMEMBER key member
复制代码

使用场景：

• 标签系统
• 共同好友
• 去重

Sorted Sets是一个有序、唯一的字符串元素集合，每个元素关联一个分数。

基本操作：
  2. # 添加元素
  3. ZADD key score1 member1 score2 member2
  5. # 获取范围内的元素
  6. ZRANGE key start stop
  8. # 按分数获取范围内的元素
  9. ZRANGEBYSCORE key min max
  11. # 获取元素分数
  12. ZSCORE key member
复制代码

使用场景：

• 排行榜
• 优先级队列
• 范围查询

8.2 Redis事务

Redis事务可以一次执行多个命令，保证这些命令不会被其他命令打断。
  2. # 开始事务
  3. MULTI
  5. # 添加命令到队列
  6. SET key1 value1
  7. SET key2 value2
  8. GET key1
  10. # 执行事务
  11. EXEC
复制代码

如果不想执行事务中的命令，可以使用DISCARD：
  2. # 开始事务
  3. MULTI
  5. # 添加命令到队列
  6. SET key1 value1
  7. SET key2 value2
  9. # 放弃事务
  10. DISCARD
复制代码

Redis事务中的错误有两种类型：

1. 入队错误：语法错误或命令不存在，整个事务会被拒绝执行。
2. 执行错误：运行时错误，其他命令仍会执行。

例如：
  2. # 开始事务
  3. MULTI
  5. # 添加命令到队列
  6. SET key1 value1
  7. INCR key1  # 这里会出错，因为key1是字符串类型
  8. SET key2 value2
  10. # 执行事务
  11. EXEC
复制代码

在这种情况下，INCR key1会失败，但SET key1 value1和SET key2 value2会成功执行。

8.3 Redis发布/订阅

Redis发布/订阅是一种消息通信模式，发送者（发布者）发送消息，订阅者接收消息。

订阅频道：
  2. SUBSCRIBE channel1 channel2
复制代码

发布消息：
  2. PUBLISH channel1 "Hello, Redis!"
复制代码

模式订阅：
  2. PSUBSCRIBE news.*
复制代码

在一个简单的聊天应用中，可以使用Redis发布/订阅实现消息广播：

订阅者代码（Python示例）：
  2. import redis
  4. r = redis.Redis(host='localhost', port=6379, db=0)
  6. pubsub = r.pubsub()
  7. pubsub.subscribe('chat_room')
  9. for message in pubsub.listen():
  10.     if message['type'] == 'message':
  11.         print(f"Received: {message['data'].decode('utf-8')}")
复制代码

发布者代码（Python示例）：
  2. import redis
  4. r = redis.Redis(host='localhost', port=6379, db=0)
  6. while True:
  7.     msg = input("Enter message: ")
  8.     r.publish('chat_room', msg)
复制代码

8.4 Redis Lua脚本

Redis支持使用Lua脚本执行复杂的操作，这些脚本是原子性的，不会被其他命令打断。

简单Lua脚本：
  2. EVAL "return 'Hello, '" 0
复制代码

带参数的Lua脚本：
  2. EVAL "return ARGV[1] .. ARGV[2]" 0 "Hello, " "Redis!"
复制代码

访问Redis键的Lua脚本：
  2. EVAL "return redis.call('GET', KEYS[1])" 1 mykey
复制代码

使用Lua脚本实现原子性的计数器操作：
  2. EVAL "
  3. local current = redis.call('GET', KEYS[1])
  4. if current then
  5.     current = tonumber(current) + tonumber(ARGV[1])
  6. else
  7.     current = tonumber(ARGV[1])
  8. end
  9. redis.call('SET', KEYS[1], current)
  10. return current
  11. " 1 counter 5
复制代码

这个脚本会原子性地增加计数器的值，并返回新的值。

8.5 Redis管道

Redis管道是一种批量执行命令的方式，可以减少网络往返时间，提高性能。

Python示例：
  2. import redis
  4. r = redis.Redis(host='localhost', port=6379, db=0)
  6. # 创建管道
  7. pipe = r.pipeline()
  9. # 添加命令到管道
  10. pipe.set('key1', 'value1')
  11. pipe.set('key2', 'value2')
  12. pipe.get('key1')
  13. pipe.get('key2')
  15. # 执行管道
  16. results = pipe.execute()
  18. print(results)  # 输出: [True, True, b'value1', b'value2']
复制代码

Python示例：
  2. import redis
  4. r = redis.Redis(host='localhost', port=6379, db=0)
  6. # 创建事务性管道
  7. pipe = r.pipeline(transaction=True)
  9. # 添加命令到管道
  10. pipe.set('key1', 'value1')
  11. pipe.set('key2', 'value2')
  12. pipe.get('key1')
  13. pipe.get('key2')
  15. # 执行管道
  16. results = pipe.execute()
  18. print(results)  # 输出: [True, True, b'value1', b'value2']
复制代码

9. Redis与编程语言集成

Redis提供了多种编程语言的客户端库，下面我们介绍几种常用语言的集成方法。

9.1 Python与Redis
  2. pip install redis
复制代码
  2. import redis
  4. # 连接到Redis
  5. r = redis.Redis(host='localhost', port=6379, db=0)
  7. # 字符串操作
  8. r.set('key', 'value')
  9. value = r.get('key')
  10. print(value)  # 输出: b'value'
  12. # 哈希操作
  13. r.hset('user:1', 'name', 'Alice')
  14. r.hset('user:1', 'age', '30')
  15. user = r.hgetall('user:1')
  16. print(user)  # 输出: {b'name': b'Alice', b'age': b'30'}
  18. # 列表操作
  19. r.lpush('messages', 'Hello')
  20. r.lpush('messages', 'World')
  21. messages = r.lrange('messages', 0, -1)
  22. print(messages)  # 输出: [b'World', b'Hello']
  24. # 集合操作
  25. r.sadd('tags', 'python', 'redis', 'database')
  26. tags = r.smembers('tags')
  27. print(tags)  # 输出: {b'python', b'redis', b'database'}
  29. # 有序集合操作
  30. r.zadd('ranking', {'Alice': 90, 'Bob': 85, 'Charlie': 95})
  31. ranking = r.zrange('ranking', 0, -1, withscores=True)
  32. print(ranking)  # 输出: [(b'Bob', 85.0), (b'Alice', 90.0), (b'Charlie', 95.0)]
复制代码

9.2 Node.js与Redis
  2. npm install redis
复制代码
  2. const redis = require('redis');
  4. // 创建客户端
  5. const client = redis.createClient({
  6.   host: 'localhost',
  7.   port: 6379
  8. });
  10. // 连接错误处理
  11. client.on('error', (err) => {
  12.   console.error('Redis Client Error', err);
  13. });
  15. // 字符串操作
  16. client.set('key', 'value', (err, reply) => {
  17.   if (err) throw err;
  18.   console.log(reply);  // 输出: OK
  19. });
  21. client.get('key', (err, reply) => {
  22.   if (err) throw err;
  23.   console.log(reply);  // 输出: value
  24. });
  26. // 哈希操作
  27. client.hset('user:1', 'name', 'Alice', redis.print);
  28. client.hset('user:1', 'age', '30', redis.print);
  30. client.hgetall('user:1', (err, reply) => {
  31.   if (err) throw err;
  32.   console.log(reply);  // 输出: { name: 'Alice', age: '30' }
  33. });
  35. // 列表操作
  36. client.lpush('messages', 'Hello', redis.print);
  37. client.lpush('messages', 'World', redis.print);
  39. client.lrange('messages', 0, -1, (err, reply) => {
  40.   if (err) throw err;
  41.   console.log(reply);  // 输出: [ 'World', 'Hello' ]
  42. });
  44. // 集合操作
  45. client.sadd('tags', 'python', 'redis', 'database', redis.print);
  47. client.smembers('tags', (err, reply) => {
  48.   if (err) throw err;
  49.   console.log(reply);  // 输出: [ 'python', 'redis', 'database' ]
  50. });
  52. // 有序集合操作
  53. client.zadd('ranking', [
  54.   { score: 90, value: 'Alice' },
  55.   { score: 85, value: 'Bob' },
  56.   { score: 95, value: 'Charlie' }
  57. ], redis.print);
  59. client.zrange('ranking', 0, -1, 'WITHSCORES', (err, reply) => {
  60.   if (err) throw err;
  61.   console.log(reply);  // 输出: [ 'Bob', '85', 'Alice', '90', 'Charlie', '95' ]
  62. });
  64. // 关闭连接
  65. client.quit();
复制代码

9.3 Java与Redis

如果你使用Maven，添加以下依赖到pom.xml：
  2. <dependency>
  3.     <groupId>redis.clients</groupId>
  4.     <artifactId>jedis</artifactId>
  5.     <version>4.3.1</version>
  6. </dependency>
复制代码
  2. import redis.clients.jedis.Jedis;
  3. import redis.clients.jedis.JedisPool;
  4. import redis.clients.jedis.JedisPoolConfig;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class RedisExample {
  9.     public static void main(String[] args) {
  10.         // 创建连接池
  11.         JedisPoolConfig poolConfig = new JedisPoolConfig();
  12.         JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);
  13.         
  14.         try (Jedis jedis = jedisPool.getResource()) {
  15.             // 字符串操作
  16.             jedis.set("key", "value");
  17.             String value = jedis.get("key");
  18.             System.out.println(value);  // 输出: value
  19.             
  20.             // 哈希操作
  21.             jedis.hset("user:1", "name", "Alice");
  22.             jedis.hset("user:1", "age", "30");
  23.             Map<String, String> user = jedis.hgetAll("user:1");
  24.             System.out.println(user);  // 输出: {name=Alice, age=30}
  25.             
  26.             // 列表操作
  27.             jedis.lpush("messages", "Hello");
  28.             jedis.lpush("messages", "World");
  29.             java.util.List<String> messages = jedis.lrange("messages", 0, -1);
  30.             System.out.println(messages);  // 输出: [World, Hello]
  31.             
  32.             // 集合操作
  33.             jedis.sadd("tags", "python", "redis", "database");
  34.             Set<String> tags = jedis.smembers("tags");
  35.             System.out.println(tags);  // 输出: [python, redis, database]
  36.             
  37.             // 有序集合操作
  38.             Map<String, Double> scores = new java.util.HashMap<>();
  39.             scores.put("Alice", 90.0);
  40.             scores.put("Bob", 85.0);
  41.             scores.put("Charlie", 95.0);
  42.             jedis.zadd("ranking", scores);
  43.             
  44.             java.util.Set<String> ranking = jedis.zrange("ranking", 0, -1);
  45.             System.out.println(ranking);  // 输出: [Bob, Alice, Charlie]
  46.         }
  47.         
  48.         // 关闭连接池
  49.         jedisPool.close();
  50.     }
  51. }
复制代码

10. 总结与最佳实践

10.1 Redis最佳实践

• 使用Hashes代替多个String键：当存储对象时，使用Hashes可以节省内存并提高效率。
• 合理使用Lists：对于列表数据，使用Lists而不是多个String键。
• 使用Sets进行去重：当需要存储唯一值时，使用Sets。
• 使用Sorted Sets进行排序：当需要排序的集合时，使用Sorted Sets。

• 设置maxmemory：始终设置最大内存限制，防止Redis耗尽系统内存。
• 选择合适的淘汰策略：根据应用场景选择合适的内存淘汰策略。
• 使用适当的数据结构编码：配置ziplist、intset等编码方式以节省内存。

• 根据数据重要性选择持久化方式：对于关键数据，使用AOF；对于可以容忍少量数据丢失的场景，可以使用RDB。
• 合理配置持久化参数：平衡性能和数据安全性。
• 定期备份：无论使用哪种持久化方式，都应定期备份数据。

• 设置强密码：始终为Redis设置强密码。
• 限制网络访问：使用防火墙和bind参数限制对Redis的访问。
• 重命名或禁用危险命令：重命名或禁用FLUSHALL、CONFIG等危险命令。
• 使用SSL/TLS：对于敏感数据，使用SSL/TLS加密连接。

• 使用管道：对于批量操作，使用管道减少网络往返时间。
• 避免使用KEYS命令：使用SCAN代替KEYS，避免阻塞Redis。
• 监控慢查询：定期检查慢查询日志，优化性能瓶颈。
• 合理使用Lua脚本：对于复杂操作，使用Lua脚本保证原子性并减少网络往返。

10.2 Redis部署建议

• 使用Docker：在开发环境中，使用Docker快速部署Redis。
• 使用默认配置：在开发环境中，可以使用默认配置，专注于应用开发。
• 启用持久化：为了避免数据丢失，建议在开发环境中也启用持久化。

• 使用专用服务器：为Redis分配专用服务器，避免与其他应用争抢资源。
• 配置合理的内存：根据数据量和访问模式配置合理的内存大小。
• 使用集群：对于大规模应用，考虑使用Redis集群提高可用性和扩展性。
• 监控和报警：设置监控和报警系统，及时发现和解决问题。

10.3 未来发展趋势

Redis作为一个高性能的内存数据库，其发展趋势包括：

• 更丰富的数据结构：Redis不断添加新的数据结构和功能，如Streams、Time Series等。
• 更好的多线程支持：Redis 6.0引入了I/O多线程，未来可能会进一步优化多线程支持。
• 更强的安全性：随着安全需求的增加，Redis将继续增强其安全功能。
• 更好的云原生支持：Redis将更好地适应云原生环境和容器化部署。

通过本指南，你应该已经掌握了在Ubuntu系统下安装、配置和使用Redis的基本技能，以及如何解决常见问题和优化性能。无论你是初学者还是有经验的开发人员，都可以将这些知识应用到实际项目中，充分发挥Redis的优势。
开发人员, 缓存, 初学者, 系统, 数据库
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.