ToB企服应用市场:ToB评测及商务社交产业平台

标题: 企业级NoSQL数据库Redis [打印本页]
作者: 勿忘初心做自己    时间: 2025-1-20 16:21
标题: 企业级NoSQL数据库Redis
1.欣赏器缓存过期机制

1.1 末了修改时间 last-modified

   欣赏器缓存机制是优化网页加载速率和淘汰服务器负载的重要本领。以下是关于欣赏器缓存过期机制、Last-Modified 和 ETag 的具体讲解：
  一、Last-Modified 头部

  
  1. Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT
复制代码
二、ETag 头部

  
  1. ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"
复制代码
五、Last-Modified vs ETag

  
  六、最佳实践

    
    七、总结

  欣赏器缓存机制通过多种HTTP头部字段控制资源的缓存和过期，Last-Modified 和 ETag 是此中重要的验证本领。合理配置这些头部字段，可以显著提升网页性能，优化用户体验，同时有效管理服务器资源。
  第一次访问

第二次访问

1.2 Etag 标志

但是假如访问的时间一样的,怎么办？If-Modefied精确到的是秒,要知道的是,计算机一秒中可以干很多多少事的,好比一秒中修改上千次的图片
  1. # 使用 touch 模拟访问时间是一样的(移走1.jpeg,在重新上传一张图片,重命名为1.jpeg)
  2. [root@Rocky9.4 html]#touch -t 202407020931.48 1.jpeg
复制代码
第一次访问
   第一次访问是由于我将时间设置成一样了,但是因为服务器返回的Etag是新的,而欣赏器生存的照旧旧的,所以Etag不一致,所以返回状态码是200
  

第二次访问
   第二次访问,Etag也同一了,所以返回了状态码304
  

1.3 过期时间 expires 和 Cache-Control

   一、欣赏器缓存机制概述

  欣赏器缓存通过在当地存储网页资源（如HTML、CSS、JavaScript、图片等），避免每次访问网页时都从服务器重新下载这些资源，从而加快页面加载速率，提高用户体验，同时淘汰服务器带宽的利用。
  明确了，你希望更具体地了解欣赏器缓存中的 Expires 和 Cache-Control 头部，以及它们之间的关系和具体应用。以下是更深入的讲解：
  二、Expires 头部

  1. 界说与作用

  
  2. 格式

  
  示例：
  1. Expires: Wed, 21 Oct 2025 07:28:00 GMT
复制代码
3. 利用场景

  
  4. 缺点

  
  三、Cache-Control 头部

  1. 界说与作用

  
  2. 常用指令

  
  示例：
  1. Cache-Control: max-age=3600
复制代码

  示例：
  1. Cache-Control: no-cache
复制代码

  示例：
  1. Cache-Control: no-store
复制代码

  示例：
  1. Cache-Control: public
复制代码

  示例：
  1. Cache-Control: private
复制代码

  示例：
  1. Cache-Control: must-revalidate
复制代码

  示例：
  1. Cache-Control: proxy-revalidate
复制代码
3. 利用场景

  
  4. 与 Expires 的关系

  
  四、Expires 与 Cache-Control 的对比

  特性ExpiresCache-Control类型绝对时间相对时间及其他缓存指令格式HTTP日期格式指令列表优先级低于 Cache-Control高于 Expires机动性较低，只有一个绝对过期时间高，可以组合多种指令控制缓存行为保举利用场景重要用于向后兼容旧欣赏器当代Web应用的首选缓存控制方式  五、实际应用示例

  1. 设置长时间缓存（适用于不经常变化的静态资源）

  1. Cache-Control: public
  2. , max-age=31536000Expires: Wed, 21 Oct 2025 07:28:00 GMT
复制代码

  2. 设置短时间缓存，需重新验证（适用于可能会频仍更新的资源）

  1. Cache-Control: no-cache
复制代码

  3. 禁止缓存（适用于敏感数据）

  1. Cache-Control: no-store
复制代码

  六、结合 ETag 和 Last-Modified 利用缓存验证

  即使设置了 Cache-Control 或 Expires，欣赏器在某些环境下仍可能需要验证缓存资源的有效性。此时，ETag 和 Last-Modified 提供了有效的验证机制：
  
  示例：
  1. Cache-Control: max-age=3600
  2. , must-revalidateETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"
  3. Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT
复制代码
七、最佳实践

    
    
    
    
    
  八、总结

  
  1.4 CDN

   CDN（内容分发网络，Content Delivery Network）是一种通过将内容复制并缓存到全球多个地理位置的服务器上，从而加速用户访问速率的技术。它重要的目的是提高网站或应用的性能、稳定性、可扩展性，同时淘汰服务器负载和带宽消耗。
  一、CDN的工作原理

  CDN的核心思想是将网站的静态资源（如HTML文件、CSS文件、JavaScript、图片、视频等）缓存到分布在全球的边缘服务器（Edge Servers）上。当用户请求访问某个资源时，CDN会根据用户的地理位置，选择间隔用户最近的服务器提供资源，从而淘汰加载时间和提高访问速率。
  1. 资源分发与缓存

  
  2. 边缘服务器与原始服务器

  
  3. 缓存计谋

  CDN通常会利用一些缓存计谋来决定哪些内容需要缓存，以及缓存多久。常见的缓存计谋包括：
  
  4. 智能路由与负载均衡

  CDN通常会根据多个因素（如地理位置、网络负载、带宽等）选择最优的边缘服务器来响应用户请求。这一过程称为智能路由或负载均衡。通过此方式，CDN能够确保用户始终通过最快的路径获取到资源。
  二、CDN的优势

    三、CDN的类型

    四、CDN的工作流程

    五、CDN的服务提供商

  目前，全球有多个重要的CDN服务提供商，最着名的包括：
    六、CDN的优化计谋

    七、总结

  CDN是一种通过将网站内容分发到全球多个节点，淘汰延迟、提高加载速率、减轻服务器负载的技术。它不仅能加速资源的交付，还能提高网站的安全性、可用性和可扩展性。随着互联网应用的增长，CDN已成为优化网站性能和提供全球用户精良体验的重要工具。
  1.4.1 用户请求CDN流程

   用户请求CDN资源的流程可以分为几个步骤。这个流程涉及到用户如何向CDN发起请求，CDN如何决定从哪个服务器提供资源，以及缓存如何影响响应时间。以下是具体的用户请求CD能资源的流程：
  一、请求流程概述

    二、具体步骤

  1. 用户发起请求

  用户在欣赏器中输入网址或点击链接时，欣赏器会发起HTTP请求来请求某个资源。这些资源通常是静态文件，如HTML、CSS、JavaScript文件，大概图片、视频等媒体文件。
  比方，用户请求资源：https://www.example.com/images/logo.png。
  2. DNS解析

  用户请求的域名（如 www.example.com）会通过DNS解析，转化为一个IP地址。通常，这个域名已经指向CDN提供商的域名解析体系。
  
  CDN提供商通常会在多个地理位置部署多个边缘节点（edge node），当请求发起时，DNS会返回离用户最近的CDN边缘节点的IP地址，确保请求被路由到最近的服务器。
  3. 请求被路由到CDN边缘节点

  DNS解析完成后，欣赏器向CDN的边缘节点发送请求。CDN边缘节点是部署在全球各地的服务器，它们缓存了资源内容，能够快速响应用户请求。
  CDN边缘节点的选择通常由以下因素决定：
  
  4. 边缘节点缓存查抄

  边缘节点收到请求后，会查抄缓存中是否已有该资源。这一步称为缓存命中查抄。
  
  5. 缓存命中或未命中

  
  6. 从源服务器获取资源

  当缓存未命中时，CDN边缘节点会向原始服务器（origin server）请求该资源。此时，源服务器会根据请求返回最新的资源，而且将该资源缓存到边缘节点，以供下次请求利用。
  
  7. 返回资源给用户

  无论是缓存命中照旧从源服务器获取资源，终极，CDN的边缘节点会把响应数据返回给用户的欣赏器。用户的欣赏器从CDN边缘节点吸收到资源，并进行展示。
  8. 欣赏器缓存

  在资源返回给欣赏器后，欣赏器也会根据响应头（如 Cache-Control、Expires 等）进行当地缓存，以便在下一次访问时直接从当地缓存中获取资源，而不再发送请求到CDN或源服务器。
  三、缓存计谋与内容更新

  CDN中的缓存计谋非常关键，它决定了缓存内容的过期时间、更新方式以及缓存计谋的机动性。
    四、CDN的优势

    五、CDN请求流程示意图

  1. 用户请求 --> DNS解析 --> CDN边缘节点 --> 缓存检查 -->
  2.      |                          |                        |
  3.   缓存命中                     缓存未命中                  |
  4.      |                          |                        |
  5. 返回缓存的资源             从源服务器请求资源            |
  6.      |                          |                        |
  7. 返回给用户的资源             缓存资源并返回给用户        |
复制代码
六、总结

    CDN在提高网站性能、加强网站可用性、降低带宽消耗等方面发挥了重要作用，是当代Web应用不可或缺的构成部分。
  
1.4.2 CDN分层缓存

   CDN（Content Delivery Network，内容分发网络）的分层缓存（Layered Caching）是指通过多级缓存架构有效提升内容分发服从的一种计谋。在CDN中，请求的内容通常会经过多个层级的缓存节点，以实现更佳的性能和资源利用率。整个流程通常可以分为以下几个条理：
    分层缓存的工作原理
  以下是一个范例的用户请求过程：
    分层缓存的优势
  
  分片缓存（Chunked Caching）
  在某些环境下，CDN还会利用分片缓存技术，将大文件（比方视频文件）分割成多个小片段（chunks），然后分别缓存这些片段。当用户请求文件时，CDN只需传输用户需要的片段，而不是整个文件。这对于提高大文件传输服从和支持流媒体播放非常有用。
  总结
  CDN分层缓存是一种有效的提高网站性能和用户体验的技术。通过合理地构造和管理多层缓存节点，CDN可以更好地分配资源，提高缓存命中率，并减轻源站的压力。
  2.Redis 安装及连接

   Redis简介：
Redis（Remote Dictionary Server）是一个开源的内存数据结构存储体系，可以用作数据库、缓存和消息队列中间件。它以Key-Value形式存储数据，提供多种数据结构和丰富的功能特性。Redis的核心代价在于高速访问、简朴的数据操作模型以及丰富的数据结构支持，使其在需要快速读写、实时计算和高并发的场景中体现突出。
  Redis的重要特性：
    
  总结：
Redis作为一个内存数据存储体系，具有高性能、丰富的数据类型、机动的持久化计谋以及高可用性架构支持。它在高并发、低延迟与实时处理场景中得到广泛应用，已成为构建当代互联网应用的重要基础组件。
  
  2.1 dnf 安装 Redis

  1. # Rocky 9.4 由系统源提供
  2. [root@redis1.xyy.org ~]#dnf info redis
  3. Name         : redis
  4. Version      : 6.2.7
  5. Release      : 1.el9
  6. Architecture : x86_64
  7. Size         : 1.3 M
  8. Source       : redis-6.2.7-1.el9.src.rpm
  9. Repository   : appstream
  10. Summary      : A persistent key-value database
  11. URL          : https://redis.io
  12. License      : BSD and MIT
  13. Description  : Redis is an advanced key-value store. It is often referred to as a data
  14.              : structure server since keys can contain strings, hashes, lists, sets and
  15.              : sorted sets.
  16.              :
  17.              : You can run atomic operations on these types, like appending to a string;
  18.              : incrementing the value in a hash; pushing to a list; computing set
  19.              : intersection, union and difference; or getting the member with highest
  20.              : ranking in a sorted set.
  21.              :
  22.              : In order to achieve its outstanding performance, Redis works with an
  23.              : in-memory dataset. Depending on your use case, you can persist it either
  24.              : by dumping the dataset to disk every once in a while, or by appending
  25.              : each command to a log.
  26.              :
  27.              : Redis also supports trivial-to-setup master-slave replication, with very
  28.              : fast non-blocking first synchronization, auto-reconnection on net split
  29.              : and so forth.
  30.              :
  31.              : Other features include Transactions, Pub/Sub, Lua scripting, Keys with a
  32.              : limited time-to-live, and configuration settings to make Redis behave like
  33.              : a cache.
  34.              :
  35.              : You can use Redis from most programming languages also.
  37. [root@Rocky9.4 ~]#
  39. # CentOS 7由 epel 源提供
  40. [root@CentOS7 ~]#yum info redis
  41. Name        : redis
  42. Arch        : x86_64
  43. Version     : 3.2.12
  44. Release     : 2.el7
  45. Size        : 1.4 M
  46. Repo        : installed
  47. From repo   : epel
  48. Summary     : A persistent key-value database
  49. URL         : http://redis.io
  50. License     : BSD
  52. [root@redis1.xyy.org ~]#dnf install redis
  53. [root@redis1.xyy.org ~]#systemctl enable --now redis
  54. [root@redis1.xyy.org ~]#pstree -p | grep redis
  55.            |-redis-server(4237)-+-{redis-server}(4238)
  56.            |                    |-{redis-server}(4239)
  57.            |                    |-{redis-server}(4240)
  58.            |                    `-{redis-server}(4241)
  59. [root@redis1.xyy.org ~]#
  60. [root@redis1.xyy.org ~]#redis-cl
  61. 127.0.0.1:6379> ping
  62. PONG
  63. 127.0.0.1:6379> INFO Server
  64. # Server
  65. redis_version:6.2.7
  66. redis_git_sha1:00000000
  67. redis_git_dirty:0
  68. redis_build_id:ec192bdd77ecd321
  69. redis_mode:standalone
  70. os:Linux 5.14.0-427.13.1.el9_4.x86_64 x86_64
  71. arch_bits:64
  72. monotonic_clock:POSIX clock_gettime
  73. multiplexing_api:epoll
  74. atomicvar_api:c11-builtin
  75. gcc_version:11.3.1
  76. process_id:4237
  77. process_supervised:systemd
  78. run_id:37144e0c3a2930dac6148605d26afae8ee4d38ba
  79. tcp_port:6379
  80. server_time_usec:1734486571682241
  81. uptime_in_seconds:37314
  82. uptime_in_days:0
  83. hz:10
  84. configured_hz:10
  85. lru_clock:6433323
  86. executable:/usr/bin/redis-server
  87. config_file:/etc/redis/redis.conf
  88. io_threads_active:0
  89. 127.0.0.1:6379>
复制代码
2.2 编译安装 Redis

从 Redis 官方下载地址 获取稳定版压缩包，如 redis-7.4.0.tar.gz。
  1. # 1.创建 Redis 用户(不需要登录权限,只是用于运行 Redis 服务以提高安全性)
  2. useradd -r -s /sbin/nologin redis
  4. # 2.获取源码包
  5. wget https://download.redis.io/releases/redis-7.4.0.tar.gz
  7. # 3.解压并进入源码目录
  8. tar xf redis-7.4.0.tar.gz
  9. cd redis-7.4.0
  11. # 4.开始编译(在某些发行版下可开启 USE_SYSTEMD=yes 选项，以生成可与 systemd 交互的可执行文件。)
  12. make -j $(nproc) USE_SYSTEMD=yes
  14. # 5.安装到指定位置
  15. make PREFIX=/apps/redis install
  17. # 6.建立软链接(方便在命令行中使用redis-server、redis-cli
  18. )
  19. ln -s /apps/redis/bin/redis-* /usr/bin/
  21. # 7.创建所需目录
  22. mkdir -p /apps/redis/{etc,log,data,run}
  24. # 8.拷贝源码目录中自带redis.conf,拷贝到配置目录:
  25. cp redis.conf /apps/redis/etc/
  27. # 9.redis.conf:修改关键配置
  28. #bind：改为 0.0.0.0 或保留默认看实际需要；
  29. #requirepass：设置 Redis 密码，如 requirepass 123456；
  30. #dir：RDB/快照文件存放目录，一般设为 /apps/redis/data；
  31. #logfile：日志文件路径，如 /apps/redis/log/redis-6379.log；
  32. #pidfile：pid 文件路径，如 /apps/redis/run/redis-6379.pid；
  33. sed -i -e 's/bind 127.0.0.1/bind 0.0.0.0/' \
  34.        -e "/# requirepass/a requirepass 123456" \
  35.        -e "/^dir .*/c dir /apps/redis/data/" \
  36.        -e "/^logfile .*/c logfile /apps/redis/log/redis-6379.log" \
  37.        -e "/^pidfile .*/c pidfile /apps/redis/run/redis-6379.pid" \
  38.        /apps/redis/etc/redis.conf
  40. # 10.设置文件权限
  41. chown -R redis:redis /apps/redis
  43. # 11.内核与系统参数优化(不优化会有告警)
  44.         # 11.1 调整内核参数
  45. vim /etc/sysctl.conf
  46. net.core.somaxconn = 1024
  47. vm.overcommit_memory = 1
  49. sysctl -p
  51.         # 11.2 禁用透明大页(THP)
  52. echo never > /sys/kernel/mm/transparent_hugepage/enabled
  53. # 可以写入启动脚本（如 /etc/rc.local 或 /etc/rc.d/rc.local）以在重启后继续生效。
  55. # 12.创建Systemd服务并启动
  56. # CentOS/Rocky:/usr/lib/systemd/system/redis.service
  57. # Ubuntu:/lib/systemd/system/redis.service（或 /etc/systemd/system/redis.service）
  58. [Unit]
  59. Description=Redis persistent key-value database
  60. After=network.target
  62. [Service]
  63. ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd
  64. ExecStop=/bin/kill -s QUIT $MAINPID
  65. # 启动notify一定要编译了 USE_SYSTEMD=yes,否则启动服务有问题
  66. Type=notify
  67. User=redis
  68. Group=redis
  69. RuntimeDirectory=redis
  70. RuntimeDirectoryMode=0755
  72. [Install]
  73. WantedBy=multi-user.target
  75. # 13.刷新并启动服务
  76. systemctl daemon-reload
  77. systemctl enable --now redis
  78. systemctl status redis
  80. # 14.查看Redis版本或者信息
  81. redis-server -v
  82. # 查看服务信息
  83. redis-cli
  84. -a 123456 INFO Server
  85. # 测试插入和查询数据
  86. redis-cli
  87. -a 123456 set mykey "Hello World"
  88. redis-cli
  89. -a 123456 get mykey
复制代码
  1. #! /bin/bash
  2. #-----------------------------------------------------
  3. #Author:            XingYuyu
  4. #Date:              2024-08-12
  5. #Blog:              http://8.141.4.74
  6. #Filename:          install_redis.sh
  7. #Description:       [Online Install Redis for Rocky Linux ,Ubuntu,CentOS ]
  8. #-----------------------------------------------------
  9. VERSION=redis-7.4.0
  10. PASSWORD=123456
  11. INSTALL_DIR=/apps/redis
  13. os_type() {
  14.   awk -F'[ "]' '/^NAME/{print $2}' /etc/os-release
  15. }
  17. color() {
  18.   RES_COL=80
  19.   MOVE_TO_COL="echo -en \e[${RES_COL}G"
  20.   SETCOLOR_SUCCESS="echo -en \e[1;32m"
  21.   SETCOLOR_FAILURE="echo -en \e[1;31m"
  22.   SETCOLOR_WARNING="echo -en \e[1;33m"
  23.   SETCOLOR_NORMAL="echo -en \e[0m"
  24.   echo -n "$1" && $MOVE_TO_COL
  25.   echo -n "["
  26.   if [ $2 = "success" -o $2 = "0" ]; then
  27.     ${SETCOLOR_SUCCESS}
  28.     echo -n $"  OK  "
  29.   elif [ $2 = "failure" -o $2 = "1" ]; then
  30.     ${SETCOLOR_FAILURE}
  31.     echo -n $"FAILED"
  32.   else
  33.     ${SETCOLOR_WARNING}
  34.     echo -n $"WARNING"
  35.   fi
  36.   ${SETCOLOR_NORMAL}
  37.   echo -n $"]"
  38.   echo
  39. }
  41. install_redis() {
  42.   wget https://download.redis.io/releases/${VERSION}.tar.gz || {
  43.     color "Redis 源码下载失败" 1
  44.     exit
  45.   }
  46.   tar xf ${VERSION}.tar.gz
  47.   cd ${VERSION}
  48.   CPUS=lscpu | awk '/^CPU\(s\)/{print $2}'
  49.   make -j $CPUS USE_SYSTEMD=yes PREFIX=${INSTALL_DIR} install && color "Redis 编译安装完成" 0 || {
  50.     color "Redis 编译安装失败" 1
  51.     exit
  52.   }
  53.   ln -s ${INSTALL_DIR}/bin/redis-* /usr/bin/
  54.   mkdir -p ${INSTALL_DIR}/{etc,log,data,run}
  55.   cp redis.conf ${INSTALL_DIR}/etc/
  56.   sed -i -e 's/bind 127.0.0.1/bind 0.0.0.0/' -e "/# requirepass/a requirepass $PASSWORD" -e "/^dir .*/c dir ${INSTALL_DIR}/data/" -e "/^logfile .*/c logfile ${INSTALL_DIR}/log/redis-6379.log" -e "/^pidfile .*/c pidfile ${INSTALL_DIR}/run/redis-6379.pid" ${INSTALL_DIR}/etc/redis.conf
  57.   if id redis &>/dev/null; then
  58.     color "Redis 用户已经存在,无需创建" 0
  59.   else
  60.     useradd -r -s /sbin/nologin redis
  61.     color "Redis 用户创建成功" 0
  62.   fi
  63.   chown -R redis.redis ${INSTALL_DIR}
  64.   cat >>/etc/sysctl.conf <<EOF
  65. net.core.somaxconn = 1024
  66. vm.overcommit_memory = 1
  67. EOF
  68.   sysctl -p
  69.   if [ `os_type` == "Ubuntu" ];then
  70.       cat >> /lib/systemd/system/rc-local.service <<EOF
  71. [Install]
  72. WantedBy=multi-user.target
  73. EOF
  74.       echo '#!/bin/bash' > /etc/rc.local
  75.       echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >>/etc/rc.local
  76.       chmod +x /etc/rc.local
  77.       /etc/rc.local
  78.       # Ubuntu 的service文件放在/lib/systemd/system/下或者/etc/systemd/system/下不能放在/usr/lib/下
  79.       cat > /lib/systemd/system/redis.service <<EOF
  80. [Unit]
  81. Description=Redis persistent key-value database
  82. After=network.target
  84. [Service]
  85. ExecStart=${INSTALL_DIR}/bin/redis-server ${INSTALL_DIR}/etc/redis.conf --supervised systemd
  86. ExecStop=/bin/kill -s QUIT \$MAINPID
  87. Type=notify
  88. User=redis
  89. Group=redis
  90. RuntimeDirectory=redis
  91. RuntimeDirectoryMode=0755
  93. [Install]
  94. WantedBy=multi-user.target
  95. EOF
  96.   else
  97.       echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >>/etc/rc.d/rc.local
  98.       chmod +x /etc/rc.d/rc.local
  99.       /etc/rc.d/rc.local
  100.       cat > /usr/lib/systemd/system/redis.service <<EOF
  101. [Unit]
  102. Description=Redis persistent key-value database
  103. After=network.target
  105. [Service]
  106. ExecStart=${INSTALL_DIR}/bin/redis-server ${INSTALL_DIR}/etc/redis.conf --supervised systemd
  107. ExecStop=/bin/kill -s QUIT \$MAINPID
  108. Type=notify
  109. User=redis
  110. Group=redis
  111. RuntimeDirectory=redis
  112. RuntimeDirectoryMode=0755
  114. [Install]
  115. WantedBy=multi-user.target
  117. EOF
  118.   fi
  120.   systemctl daemon-reload
  121.   systemctl enable --now redis &>/dev/null
  122.   systemctl is-active redis &> /dev/null && color "Redis 服务启动成功,Redis信息如下:" 3 || { color "Redis 启动失败" 1 ;exit; }
  123.   #sleep 5
  124.   redis-cli
  125. -a $PASSWORD INFO Server 2>/dev/null
  126. }
  128. install_CentOS7() {
  129.   . /etc/init.d/functions
  130.   # jemalloc-devel依赖于epel源
  131.   yum -y install epel-release && yum -y install gcc jemalloc-devel systemd-devel || {
  132.     color "安装软件包失败,请检查网络配置" 1
  133.     exit
  134.   }
  135.   rpm -q wget &>/dev/null || yum -y install wget &>/dev/null
  136.   wget https://download.redis.io/releases/${VERSION}.tar.gz || {
  137.     action "Redis 源码下载失败" false
  138.     exit
  139.   }
  140.   tar xf ${VERSION}.tar.gz
  141.   cd ${VERSION}
  142.   CPUS=lscpu | awk '/^CPU\(s\)/{print $2}'
  143.   make -j $CPUS USE_SYSTEMD=yes PREFIX=${INSTALL_DIR} install && action "Redis 编译安装完成" || {
  144.     action "Redis 编译安装失败" false
  145.     exit
  146.   }
  147.   ln -s ${INSTALL_DIR}/bin/redis-* /usr/bin/
  148.   mkdir -p ${INSTALL_DIR}/{etc,log,data,run}
  149.   cp redis.conf ${INSTALL_DIR}/etc/
  150.   sed -i -e 's/bind 127.0.0.1/bind 0.0.0.0/' -e "/# requirepass/a requirepass $PASSWORD" -e "/^dir .*/c dir ${INSTALL_DIR}/data/" -e "/^logfile .*/c logfile ${INSTALL_DIR}/log/redis-6379.log" -e "/^pidfile .*/c pidfile ${INSTALL_DIR}/run/redis-6379.pid" ${INSTALL_DIR}/etc/redis.conf
  151.   if id redis &>/dev/null; then
  152.     action "Redis 用户已经存在" false
  153.   else
  154.     useradd -r -s /sbin/nologin redis
  155.   fi
  156.   chown -R redis.redis ${INSTALL_DIR}
  157.   cat >>/etc/sysctl.conf <<EOF
  158. net.core.somaxconn = 1024
  159. vm.overcommit_memory = 1
  160. EOF
  161.   sysctl -p
  162.   echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >>/etc/rc.d/rc.local
  163.   chmod +x /etc/rc.d/rc.local
  164.   /etc/rc.d/rc.local
  166.   cat >/usr/lib/systemd/system/redis.service <<EOF
  167. [Unit]
  168. Description=Redis persistent key-value database
  169. After=network.target
  171. [Service]
  172. ExecStart=${INSTALL_DIR}/bin/redis-server ${INSTALL_DIR}/etc/redis.conf --supervised systemd
  173. ExecReload=/bin/kill -s HUP \$MAINPID
  174. ExecStop=/bin/kill -s QUIT \$MAINPID
  175. Type=notify
  176. User=redis
  177. Group=redis
  178. RuntimeDirectory=redis
  179. RuntimeDirectoryMode=0755
  181. [Install]
  182. WantedBy=multi-user.target
  184. EOF
  185.   systemctl daemon-reload
  186.   systemctl enable --now redis &>/dev/null
  187.   systemctl is-active redis &> /dev/null && ${COLOR}"Redis 服务启动成功,Redis信息如下:"${END} || { ${COLOR}"Redis 启动失败"${END};exit; }
  188.   #sleep 5
  189.   redis-cli
  190. -a $PASSWORD INFO Server 2>/dev/null
  191. }
  193. install_Ubuntu() {
  194. apt -y install make gcc libjemalloc-dev libsystemd-dev || {
  195.     color "安装软件包失败,请检查网络配置" 1
  196.     exit
  197.   }
  198.   install_redis
  199. }
  201. install_Rocky() {
  202.   # jemalloc-devel依赖于epel源
  203.   yum -y install epel-release && yum -y install gcc jemalloc-devel systemd-devel || {
  204.     color "安装软件包失败,请检查网络配置" 1
  205.     exit
  206.   }
  207.   rpm -q wget &>/dev/null || yum -y install wget &>/dev/null
  208.   install_redis
  209. }
  211. if [ $(os_type) == 'CentOS' ]; then
  212.   install_CentOS7
  213. elif [ $(os_type) == 'Rocky' ]; then
  214.   install_Rocky
  215. elif [ $(os_type) == 'Ubuntu' ]; then
  216.   install_Ubuntu
  217. else
  218.   color "未识别的操作系统" 1
  219. fi
复制代码
2.3 连接到 Redis

2.3.1 客户端连接到 Redis

1.本机无密码连接
  1. redis-cli
复制代码
2.跨主机无密码连接
  1. redis-cli
  2. -h HOSTNAME/IP -p PORT
复制代码
3.跨主机密码连接
  1. redis-cli
  2. -h HOSTNAME/IP -p PORT -a PASSWORD
复制代码
2.3.2 步伐连接 Redis

redis 支持多种开发语言访问
  1. https://redis.io/docs/latest/develop/clients/
复制代码

shell 脚本写入数据到 Redis
  1. #!/bin/bashNUM=100PASS=123456for i in `seq $NUM`; do    redis-cli
  2. -h 127.0.0.1 -a "$PASS" --no-auth-warning set key${i} value${i}    echo "key${i} value${i} 写入完成"doneecho "$NUM 个key写入到Redis完成"
复制代码
3.Redis 的多实例

   在生产环境中，为了更好地利用资源、实现多租户隔离或分离不同业务的数据与配置，运维职员往往会在一台服务器上运行多个 Redis 实例。Redis 的多实例部署并非Redis内建的特性，而是通过为每个实例指定独立的配置文件、独立的运行端口与数据目次来实现的。以下是关于Redis多实例的具体讲解：
  为什么需要多实例

    配置多实例的关键点

    举例：多实例文件构造形式

  1. /etc/redis/
  2. ├─ redis-6379.conf
  3. ├─ redis-6380.conf
  4. └─ redis-6381.conf
  6. /var/lib/redis/
  7. ├─ 6379/
  8. │  ├─ dump.rdb
  9. │  └─ appendonly.aof
  10. ├─ 6380/
  11. │  ├─ dump.rdb
  12. │  └─ appendonly.aof
  13. └─ 6381/
  14.    ├─ dump.rdb
  15.    └─ appendonly.aof
  17. /var/log/
  18. ├─ redis_6379.log
  19. ├─ redis_6380.log
  20. └─ redis_6381.log
复制代码
总结

  Redis多实例部署是通过为每个实例提供独立的端口、独立的配置文件以及数据和日志目次来实现的。这种方式在同一台服务器上实现了机动的资源分配和多租户支持。通过经心配置和管理，运维职员能够同时运行多个Redis实例，为不同应用提供高效、独立而又经济实惠的内存数据存储服务。
  案例:以编译安装为例实现 Redis 多实例
  1. # 天生的文件列表[root@Rocky9.4 ~]#ll /apps/redis/total 0drwxr-xr-x 2 redis redis 134 Dec 17 23:22 bindrwxr-xr-x 2 redis redis  22 Dec 18 20:04 datadrwxr-xr-x 2 redis redis  24 Dec 18 20:04 etcdrwxr-xr-x 2 redis redis  28 Dec 17 23:22 logdrwxr-xr-x 2 redis redis  28 Dec 18 20:04 run[root@Rocky9.4 redis]#tree /apps/redis//apps/redis/├── bin│   ├── redis-benchmark│   ├── redis-check-aof -> redis-server│   ├── redis-check-rdb -> redis-server│   ├── redis-cli
  2. │   ├── redis-sentinel -> redis-server│   └── redis-server├── data│   ├── dump-6379.rdb│   ├── dump-6380.rdb│   └── dump-6381.rdb├── etc│   ├── redis_6379.conf│   ├── redis_6380.conf│   ├── redis_6381.conf│   └── redis.conf├── log│   ├── redis-6379.log│   ├── redis-6380.log│   └── redis-6381.log└── run    ├── redis-6379.pid    ├── redis-6380.pid    └── redis-6381.pid5 directories, 19 files# 配置文件需要修改的地方vim /apps/redis/etc/redis_6379.confbind 0.0.0.0 -::1port 6379daemonize nopidfile /apps/redis/run/redis-6379.pidlogfile /apps/redis/log/redis-6379.log# 写入数据的时候,而且满意save才会生产dump-6379.rdb这个文件dbfilename dump-6379.rdbdir /apps/redis/data/# 3600秒,写一次数据 300秒,100次数据,60秒,10000次数据 满意就会备份,为了更快的看到结果可以更改,比方:save 60 1save 3600 1 300 100 60 10000appendfilename "appendonly-6379.aof"vim /apps/redis/etc/redis_6380.confbind 0.0.0.0 -::1port 6380daemonize nopidfile /apps/redis/run/redis-6380.pidlogfile /apps/redis/log/redis-6380.logdbfilename dump-6380.rdbdir /apps/redis/data/save 3600 1 300 100 60 10000appendfilename "appendonly-6380.aof"vim /apps/redis/etc/redis_6381.confbind 0.0.0.0 -::1port 6381daemonize nopidfile /apps/redis/run/redis-6381.pidlogfile /apps/redis/log/redis-6381.logdbfilename dump-6381.rdbdir /apps/redis/data/save 3600 1 300 100 60 10000appendfilename "appendonly-6381.aof"# 创建service文件# 1./usr/lib/systemd/system/redis6379.service[Unit]Description=Redis persistent key-value databaseAfter=network.target[Service]ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6379.conf --supervised systemdExecStop=/bin/kill -s QUIT $MAINPIDType=notifyUser=redisGroup=redisRuntimeDirectory=redisRuntimeDirectoryMode=0755[Install]WantedBy=multi-user.target[root@Rocky9.4 ~]## 2./usr/lib/systemd/system/redis6380.service[Unit]Description=Redis persistent key-value databaseAfter=network.target[Service]ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6380.conf --supervised systemdExecStop=/bin/kill -s QUIT $MAINPID#Type=notifyUser=redisGroup=redisRuntimeDirectory=redisRuntimeDirectoryMode=0755[Install]WantedBy=multi-user.target[root@Rocky9.4 ~]## 3./usr/lib/systemd/system/redis6381.service[Unit]Description=Redis persistent key-value databaseAfter=network.target[Service]ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6381.conf --supervised systemdExecStop=/bin/kill -s QUIT $MAINPID#Type=notifyUser=redisGroup=redisRuntimeDirectory=redisRuntimeDirectoryMode=0755[Install]WantedBy=multi-user.target[root@Rocky9.4 ~]#systemctl daemon-reloadsystemctl enable --now redis6379.service redis6380.service redis6381.service# 这里有个问题,通过二进制安装好的Redis,start的时候用tab键无法补全
复制代码
4.Redis 持久化

Redis 是一个基于内存的数据结构存储体系，但它提供了多种持久化机制，可以将内存中的数据生存到磁盘中，从而在 Redis 重启或服务器宕机后依然能够规复数据。Redis 重要提供了两种持久化方式：RDB（Redis Database） 和 AOF（Append Only File）。这两种方式可以单独利用，也可以共同利用，具体选择取决于业务需求（对数据一致性、写入性能、磁盘空间等的不同要求）。
4.1 RDB(Redis Database)

RDB 方式是 Redis 最早的持久化模式，即在某个时间点对内存数据做快照，并生存到一个 .rdb 文件中
4.1.1 RDB 的工作机制

   方法1:
  SAVE 命令是“壅闭式”生存，Redis 不会创建子历程，而是直接由主历程把内存数据写到 RDB 文件里。
  1. [root@Rocky9.4 redis]#( redis-cli
  2. -a 123456 save & );pstree -p | grep redis-server;ls /apps/redis/data/ -lhWarning: Using a password with '-a' or '-u' option on the command line interface may not be safe.           |-redis-server(28847)-+-{redis-server}(28854)           |                     |-{redis-server}(28855)           |                     |-{redis-server}(28856)           |                     |-{redis-server}(28857)           |                     `-{redis-server}(28858)total 180M-rw-r--r-- 1 redis redis 180M Dec 23 18:48 dump_6379.rdb-rw-r--r-- 1 redis redis  48K Dec 23 21:45 temp-28847.rdb
复制代码
利用 python 脚本存入一万万条数据,再进行备份看到下面的现象
  1. # 这个需要使用pip install redis来安装redis包
  2. import redis
  4. pool=redis.ConnectionPool(host="10.0.0.41",port=6379,password="123456")
  5. r=redis.Redis(connection_pool=pool)
  6. for i in range(10000000):
  7.     r.set("k%d" % i,"v%d" % i)
  8.     data=r.get("k%d" % i)
  9.     print(data)
复制代码

   方法2:
  BGSAVE 才是“后台”生存，Redis 会 fork 一个子历程来完成 RDB 持久化，主历程继承对外提供服务。
  1. [root@Rocky9.4 data]#redis-cli
  2. -a 123456Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.127.0.0.1:6379> bgsaveBackground saving started127.0.0.1:6379># 生产临时文件,fork 子历程 pid是920,从temp-920.rdb也可以看出是历程920在备份[root@Rocky9.4 data]#pstree -p | grep redis-server;ls /apps/redis/data/ -lh           |-redis-server(638)-+-redis-server(920)           |                   |-{redis-server}(666)           |                   |-{redis-server}(667)           |                   |-{redis-server}(668)           |                   |-{redis-server}(669)           |                   `-{redis-server}(671)total 128M-rw-r--r-- 1 redis redis 67M Dec 24 14:43 temp-920.rdb# 备份竣事以后,将文件重命名[root@Rocky9.4 data]#pstree -p | grep redis-server;ls /apps/redis/data/ -lh           |-redis-server(638)-+-{redis-server}(666)           |                   |-{redis-server}(667)           |                   |-{redis-server}(668)           |                   |-{redis-server}(669)           |                   `-{redis-server}(671)total 180M-rw-r--r-- 1 redis redis 180M Dec 24 14:43 dump_6379.rdb# 也可以查察日志[root@Rocky9.4 data]#tail -f ../log/redis-6379.log# bgsave的日志,会显示出具体的子历程编号638:M 24 Dec 2024 15:15:14.746 * Background saving started by pid 10371037:C 24 Dec 2024 15:15:22.016 * DB saved on disk1037:C 24 Dec 2024 15:15:22.026 * Fork CoW for RDB: current 0 MB, peak 0 MB, average 0 MB638:M 24 Dec 2024 15:15:22.095 * Background saving terminated with success# save的日志638:M 24 Dec 2024 15:20:09.364 * DB saved on disk
复制代码

   方法3:
  Redis 会在配置文件中设置触发 RDB 天生快照的条件，范例配置示例：
  1. save 900 1   # 在900秒内(15分钟)至少有1个键发生变动，则触发保存快照
  2. save 300 10  # 在300秒内(5分钟)至少有10个键发生变动，则触发保存快照
  3. save 60 10000# 在60秒内(1分钟)至少有10000个键发生变动，则触发保存快照
  5. # 上面是之前老版本的写法,写在新版本的写法:
  6. save 3600 1 300 100 60 10000
复制代码
触发快照后，Redis 通过fork 出一个子历程，子历程负责将内存数据写入临时的 RDB 文件；父历程继承处理客户端请求，因此在快照天生的过程中，Redis 仍旧能够服务读写请求。
  当子历程将数据写完后，会原子性地用临时文件替换原先的 RDB 文件，以确保在替换前的 RDB 文件依然可用。这个和bgsave的模式是一样的.
  4.1.2 RDB 的优点

4.1.3 RDB 的缺点

4.2 AOF（Append Only File）

   从 Redis 7.0.0开始以及之后的版本中，AOF（Append Only File）机制经过优化，引入了基础 RDB 文件和增量 AOF 文件的组合方式。这种设计有助于提高 AOF 的管理服从和数据规复的速率。().
  AOF 是另一种持久化方式，它会将每次写操作以命令的形式追加到一个文件中（默认叫 appendonly.aof），从而实现数据的生存。
4.2.1 AOF 的工作机制


4.2.2 AOF 的优点

4.2.3 AOF 的缺点

4.3 如何选择 RDB 和 AOF

4.4 AOF相关配置

  1. [root@Rocky9.4 etc]#vim /apps/redis/etc/redis_6379.conf
  2. # 启用 AOF 持久化,通过config命令开启,防止数据清空 config set appendonly yes
  3. appendonly yes
  4. # AOF 文件的名称
  5. appendfilename "appendonly-6379.aof"
  6. # 新版本专门为aof增加了一个目录,这个目录是在$dir下创建的
  7. appenddirname "appendonlydir"
  9. # AOF 同步策略
  10. # always: 每个写命令都同步到磁盘
  11. # everysec: 每秒同步一次
  12. # no: 让操作系统决定何时同步
  13. appendfsync everysec
  15. # 数据目录
  16. dir /apps/redis/data/
  18. # AOF 重写的策略
  19. # 例如，当 AOF 文件大小增长到上一个重写后的大小的 100% 时触发重写
  20. auto-aof-rewrite-percentage 100
  21. auto-aof-rewrite-min-size 64mb
  23. # 查看备份的目录
  24. [root@Rocky9.4 data]#tree
  25. .
  26. ├── appendonlydir
  27. │   ├── appendonly-6379.aof.1.base.rdb
  28. │   ├── appendonly-6379.aof.1.incr.aof
  29. │   └── appendonly-6379.aof.manifest
  30. ├── dump-6379.rdb
  31. ├── dump-6380.rdb
  32. └── dump-6381.rdb
  34. 1 directory, 6 files
  35. [root@Rocky9.4 data]#pwd
  36. /apps/redis/data
  37. [root@Rocky9.4 data]#
复制代码
根据业务需求选择合适的同步计谋：

   在 Redis 7.4 中，AOF（Append Only File）持久化机制引入了更为复杂和高效的文件结构，以提高数据持久性和规复速率。您在 appendonlydir 目次下看到的以下几个文件：
  1. 基础 RDB 文件: appendonly-6379.aof.1.base.rdb      180M
  2. 增量 AOF 文件: appendonly-6379.aof.1.incr.aof      56
  3. 清单文件:            appendonly-6379.aof.manifest        98
复制代码
这些文件分别代表了 Redis 7.4 中 AOF 持久化机制的新特性和结构。下面将具体解释每个文件的含义及其作用。
  1. appendonly-6379.aof.1.base.rdb（180M）

  作用：
  
  优点：
  
  2. appendonly-6379.aof.1.incr.aof（56）

  作用：
  
  优点：
  
  3. appendonly-6379.aof.manifest（98）

  作用：
  
  优点：
  
  二、Redis 7.4 AOF 持久化机制的改进

  Redis 7.4 引入了 混合持久化（Hybrid Persistence） 机制，将 RDB 和 AOF 结合起来，以充实利用两者的优势：
    三、如何管理这些文件

  1. 主动管理

  Redis 7.4 会主动天生和管理这些文件，包括：
  
  2. 手动管理

  虽然 Redis 会主动管理这些文件，但您仍可以进行一些手动操作以优化或排盘问题：
  
  四、配置示例

  在 Redis 配置文件 (redis.conf) 中，相关配置可能如下：
  1. # 启用 AOF 持久化
  2. appendonly yes
  4. # AOF 文件的名称
  5. appendfilename "appendonly.aof"
  7. # AOF 同步策略
  8. appendfsync everysec
  10. # 混合持久化配置
  11. # 具体配置项可能因 Redis 版本而异，请参考官方文档
复制代码
注意：Redis 7.4 的混合持久化机制可能引入了新的配置选项，请务必参考 Redis 官方文档 以获取最新和具体的配置分析。
  五、总结

  Redis 7.4 在 AOF 持久化机制上引入了基础 RDB 文件、增量 AOF 文件和清单文件的结构，通过混合持久化机制，结合了 RDB 和 AOF 的优势，实现了高效、可靠的数据持久化和快速规复。这些文件的存在确保了 Redis 在高负载和大数据量的场景下，能够保持数据的完备性和体系的高可用性。
  理解和精确管理这些持久化文件，对于保障 Redis 数据的安全性和体系的稳定性至关重要。建议定期备份持久化文件，并监控文件的巨细和体系性能，以确保 Redis 实例的健康运行。
  4.5 AOF rewrite 重写

appendonly-6379.aof.1.base.rdb：基础 RDB 快照文件。
appendonly-6379.aof.1.incr.aof：增量 AOF 文件，记录自基础快照以来的所有写命令。
appendonly-6379.aof.manifest：清单文件，管理基础 RDB 文件与增量 AOF 文件的关系。
4.5.1 基础 RDB 文件与增量 AOF 文件的工作机制




4.5.2 增量备份的工作原理与配置

增量备份重要依赖于基础 RDB 文件和增量 AOF 文件的组合。通过这种方式，你可以在保持高效的同时，实现数据的连续备份。
增量备份的工作流程
4.5.3 参数配置

  1. [root@redis.xyy.org ~]#vim /apps/redis/etc/redis.conf
  2. appendonly yes
  3. appendfilename "appendonly.aof"
  4. appendfsync everysec
  5. no-appendfsync-on-rewrite no
  6. auto-aof-rewrite-percentage 100
  7. auto-aof-rewrite-min-size 64mb
  8. aof-load-truncated yes
  9. aof-use-rdb-preamble yes
  10. aof-timestamp-enabled no
复制代码
以下是这些参数的具体解释及其在增量备份中的作用：
appendonly yes：启用 AOF 持久化。
appendfilename "appendonly.aof"：指定 AOF 文件名。
appendfsync everysec：每秒实行一次 FSYNC 操作，平衡性能与持久性。
  1. # 通过 bgrewriteaof 手动触发重写机制[root@Rocky9.4 data]#redis-cli
  2. -a 123456 bgrewriteaof;pstree -p | grep redis ;ll appendonlydir/ -hWarning: Using a password with '-a' or '-u' option on the command line interface may not be safe.Background append only file rewriting started           |-redis-server(22944)-+-redis-server(23325)           |                     |-{redis-server}(22946)           |                     |-{redis-server}(22947)           |                     |-{redis-server}(22948)           |                     |-{redis-server}(22949)           |                     `-{redis-server}(22950)total 180M-rw-r--r-- 1 redis redis 180M Dec 28 23:25 appendonly.aof.1.base.rdb-rw-r--r-- 1 redis redis 719K Dec 29 23:04 appendonly.aof.1.incr.aof-rw-r--r-- 1 redis redis    0 Dec 29 23:08 appendonly.aof.2.incr.aof-rw-r--r-- 1 redis redis  132 Dec 29 23:08 appendonly.aof.manifest[root@Rocky9.4 data]#ll appendonlydir/total 183420-rw-r--r-- 1 redis redis 187817903 Dec 29 23:08 appendonly.aof.2.base.rdb-rw-r--r-- 1 redis redis         0 Dec 29 23:08 appendonly.aof.2.incr.aof-rw-r--r-- 1 redis redis        88 Dec 29 23:08 appendonly.aof.manifest[root@Rocky9.4 data]#
复制代码
5.Redis 常用命令

5.1 ACL 控制

  1. user <username> [on|off] [>password] [~pattern] [+permissions] [-permissions]
复制代码
命令权限（+ / - / ~ / allcommands / nocommands）

on 或 off：启用或禁用用户。
>password：设置用户的密码，可以有多个密码。
~pattern：指定用户可以访问的键的模式（可选）。
+permissions 和 -permissions：授予或打消用户的权限，可以利用命令类别或具体命令。
  1. # 假设您希望创建一个名为 alice 的用户，设置密码为 123456，而且授予她所有权限但禁用 FLUSHALL 命令。可以按照以下方式配置：[root@Rocky9.4 etc]#vim redis_6379.confuser alice on >123456 ~* +@all -FLUSHALL -FLUSHDBuser default on >123456 ~* +@all +get +set -FLUSHALL -FLUSHDB -keys -config# 重启服务systemctl restart redis# 连接到Redis[root@Rocky9.4 etc]#redis-cli
  2. -u redis://alice:123456@127.0.0.1:6379Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.127.0.0.1:6379> FLUSHALL(error) NOPERM User alice has no permissions to run the 'flushall' command127.0.0.1:6379> exit
复制代码
Key 权限（~ / %）

解释：

  1. # 默认用户去掉flushall 和 flushdbuser default on >123456 &logs:* ~* +@all -FLUSHALL -FLUSHDB# 动态管理 ACL# 1.ACL List(查察当前所有用户配置的具体信息，包括用户名称、密码哈希、权限列表、key patterns 等。)[root@Rocky9.4 etc]#redis-cli
  2. -a 123456Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.127.0.0.1:6379> acl list1) "user alice on sanitize-payload #87b9b7660e9fe77503b14eb6da0277151e031aad3a88a1673b798d8443af242b resetchannels -@all"2) "user default on sanitize-payload #8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92 ~* resetchannels &logs:* +@all -flushall -flushdb"127.0.0.1:6379># 2.ACL GETUSER <username>(获取指定用户的ACL信息)127.0.0.1:6379> ACL GETUSER alice 1) "flags" 2) 1) "on"    2) "sanitize-payload" 3) "passwords" 4) 1) "87b9b7660e9fe77503b14eb6da0277151e031aad3a88a1673b798d8443af242b" 5) "commands" 6) "-@all" 7) "keys" 8) "" 9) "channels"10) ""11) "selectors"12) (empty array)127.0.0.1:6379># 3.ACL SETUSER <username> [规则 ...](更新（创建或修改）用户的权限规则)ACL SETUSER bob on >bob_password +get +set -FLUSHALL -FLUSHDB  ~bob:*ACL SETUSER bob on：启用 bob>bob_password：设置 bob 的密码+get +set：允许 bob 实行 get、set 命令~bob:*：只允许 bob 访问前缀为 bob: 的 key# 4.ACL DELUSER <username> [<username> ...](删除用户及其权限配置)ACL DELUSER aliceACL DELUSER bob# 5.ACL SAVE(将内存中的 ACL 配置写回到 aclfile（假如在配置文件中指定了 aclfile 路径的话）中。默认不写入 redis.conf，假如希望生存到文件，需要先在 redis.conf 中指定：)注意:在redis.conf中配置aclfile,就不能同时配置user alice...,必须要将配置写入到aclfile,而且还要将这个文件手动创建出来,服务才会重启成功aclfile /path/to/aclfile.conf
复制代码
5.2 INFO

作用：查察 Redis 服务器的各种统计信息和状态，比方内存利用环境、复制状态、连接数、持久化信息、keyspace 信息等。
利用示例：
  1. 127.0.0.1:6379> INFO keyspace
  2. # Keyspace
  3. db0:keys=10000001,expires=0,avg_ttl=0,subexpiry=0
  4. 127.0.0.1:6379>
  6. 127.0.0.1:6379> info server
  7. # Server
  8. redis_version:7.4.1
  9. redis_git_sha1:00000000
  10. redis_git_dirty:0
  11. redis_build_id:a9a1c6875521b0ad
  12. redis_mode:standalone
  13. os:Linux 5.14.0-427.13.1.el9_4.x86_64 x86_64
  14. arch_bits:64
  15. monotonic_clock:POSIX clock_gettime
  16. multiplexing_api:epoll
  17. atomicvar_api:c11-builtin
  18. gcc_version:11.5.0
  19. process_id:9692
  20. process_supervised:no
  21. run_id:83d8b9655623d6edaf809f8a7456e68179e9de91
  22. tcp_port:6379
  23. server_time_usec:1735883510494144
  24. uptime_in_seconds:6113
  25. uptime_in_days:0
  26. hz:10
  27. configured_hz:10
  28. lru_clock:7830262
  29. executable:/apps/redis/bin/redis-server
  30. config_file:/apps/redis/etc/redis_6379.conf
  31. io_threads_active:0
  32. listener0:name=tcp,bind=0.0.0.0,bind=-::1,port=6379
  33. 127.0.0.1:6379>
复制代码
Redis 会返回一个多段文本，包罗大量信息，可按模块划分（server、clients、memory、persistence、stats、replication、cpu、cluster、keyspace 等）。
常用操作：

5.3 SELECT

作用：切换 Redis 的逻辑数据库（DB）。Redis 默认有 16 个逻辑数据库，编号 0 到 15（可通过 databases 配置修改）。
利用示例：
  1. 127.0.0.1:6379> SELECT 1
  2. OK
  3. 127.0.0.1:6379[1]>    # 命令提示符会显示当前已在 DB1
复制代码
注意点：

5.4 KEYS

作用：列出匹配给定模式（pattern）的所有 Key。常用模式如 KEYS user:*。
利用示例：
  1. 127.0.0.1:6379> KEYS *
  2. 1) "foo"
  3. 2) "bar"
  4. 3) "user:1001"
复制代码
注意点：

5.5 BGSAVE

作用：在后台（异步）实行一次 RDB 快照，将当前数据集生存到磁盘（默认文件名 dump.rdb，可在 redis.conf 中配置）。
利用示例：
  1. 127.0.0.1:6379> BGSAVE
  2. Background saving started
复制代码
实行后会立即返回，Redis 会在后台完成 RDB 持久化。
常用场景：

5.6 DBSIZE

作用：返回当前所选数据库（DB）中 key 的数量。
利用示例：
  1. 127.0.0.1:6379> DBSIZE
  2. (integer) 10000001
  3. 127.0.0.1:6379>
复制代码
表示当前 DB 里有 一万万 个 key。
注意点：

5.7 FLUSHDB

作用：清空当前数据库（DB）的所有 Key（只影响您当前选择的 DB）。
利用示例：
  1. 127.0.0.1:6379> FLUSHDB
  2. OK
复制代码
假如在 DB0 实行，会清空 DB0；在 DB1 实行会清空 DB1。
风险与注意：

5.8 FLUSHALL

作用：清空 所有 DB 的所有 Key（默认 16 个数据库都会被清空）。
利用示例：
  1. 127.0.0.1:6379> FLUSHALL
  2. OK
复制代码
风险与注意：

5.9 SHUTDOWN

作用：关闭 Redis 服务器。实行后，会尝试做一次持久化（若配置了 RDB/AOF），然后退出历程。
利用示例：
  1. 127.0.0.1:6379> SHUTDOWN
复制代码
连接会立即断开，Redis 服务停止。
注意点：

5.10 SCAN

在 Redis 中，SCAN 命令是一种基于游标（cursor）**的迭代查询方式，能够**分批且非壅闭地遍历数据库中的 Key（或集合、哈希、ZSet 等），避免像 KEYS * 这样一次性扫描全部 Key 导致大规模壅闭的问题。下面先容一下 SCAN 的核心概念、利用方法以及与 KEYS 的区别。
一、为什么要用 SCAN？
二、SCAN 的根本用法
2.1 命令格式
  1. SCAN cursor [MATCH pattern] [COUNT count]
复制代码

初次调用：
  1. 127.0.0.1:6379> SCAN 0 COUNT 10
  2. 1) "13107200"
  3. 2)  1) "k4533779"
  4.     2) "k252114"
  5.     3) "k933235"
  6.     4) "k3676789"
  7.     5) "k2576537"
  8.     6) "k7573677"
  9.     7) "k5285770"
  10.     8) "k2267950"
  11.     9) "k2473601"
  12.    10) "k4433328"
复制代码

后续调用：
  1. 127.0.0.1:6379> SCAN 13107200 COUNT 10
  2. 1) "4456448"
  3. 2)  1) "k1450912"
  4.     2) "k9102989"
  5.     3) "k6829708"
  6.     4) "k3410677"
  7.     5) "k2513869"
  8.     6) "k9564207"
  9.     7) "k7683296"
  10.     8) "k2951179"
  11.     9) "k6113726"
  12.    10) "k8041825"
  13. 127.0.0.1:6379>
复制代码

三、SCAN 与其他相关命令
SCAN：遍历数据库中的 Key。
SSCAN：遍历 Set 中的元素。
HSCAN：遍历 Hash 中的 field-value 对。
ZSCAN：遍历 Sorted Set 中的 member-score 对。
它们用法相似，都是 SCAN cursor [MATCH pattern] [COUNT count]
的形式，只是操作的数据结构不同。比方：
  1. HSCAN myhash 0 MATCH field:* COUNT 10
复制代码
四、SCAN vs. KEYS

6.Redis 数据类型

6.1 字符串(string)类

6.1.1 String 的存储特点


6.1.2 常见的操作命令

6.1.2.1 设置与获取

6.1.2.1.1 SET


6.2.2.1.2 GET


6.2.2.1.3 MSET / MGET


6.2.2.1.4 SETNX / SETXX（或结合 SET 命令的 NX / XX 参数）


6.1.2.2 数值操作

Redis 支持对字符串值进行数字自增自减操作（前提是该字符串能被解析为整数或浮点数）。
6.1.2.2.1 INCR / DECR


6.1.2.2.2 INCRBY / DECRBY


6.1.2.2.3 INCRBYFLOAT


6.1.2.3 部分字符串操作

6.1.2.3.1 APPEND


6.1.2.3.2 GETRANGE (旧命令：SUBSTR)


6.1.2.3.3 SETRANGE


6.1.2.3.4 STRLEN


6.1.2.4 过期与生命周期管理

只管不是 String 专有命令，但实际中常和 String 共同利用：

也可在 SET 命令时直接附带 EX 或 PX 参数来设置过期时间。
6.1.2.5 高级应用：Bit 操作

Redis 还提供了对 String 值实行位操作（bitwise）的命令，如 SETBIT, GETBIT, BITCOUNT, BITOP 等，能在每个位上进行读写、计数或逻辑运算。

这些命令常用于**实现位图（bitmap）**功能，好比用户签到、活跃状态等布尔属性的存储。
6.1.2.6 小结 & Best Practices

  1. # 设置值,并设置有效期(s)--10秒过期,也可以通过SETEX来直接设置
  2. set title study ex 10
  4. # 存在title,不变,不存在设置成ceo
  5. 127.0.0.1:6379> SETNX title ceo
  6. (integer) 1
  8. # 批量设置--mset/mget
  9. 127.0.0.1:6379> mset name xingyuyu age 18 gender femal title cto
  10. OK
  11. 127.0.0.1:6379> mget name age
  12. 1) "xingyuyu"
  13. 2) "18"
  14. 127.0.0.1:6379>
复制代码
6.2 哈希（Hash）

在 Redis 中，Hash（哈希） 是一种将多个字段（field）映射到同一个 key 下的数据结构。换句话说，Redis 的 Hash 类似一个小型的 key-value 表，表里的 “行” 只有一条，但这条“行”有许多字段（field）。它非常适适用来存储和读取类似对象、用户资料、配置项等场景。下面将按照前面类似的步骤，讲解 Hash 的根本概念、常用操作以及利用场景与注意事项。
6.2.1 Redis Hash 的存储与特点

6.2.2 Hash 的常见操作命令

6.2.2.1 基础增删改查

6.2.2.1.1 HSET / HGET


6.2.2.1.2 HMSET / HMGET


6.2.2.1.3 HGETALL / HKEYS / HVALS


6.2.2.1.4 HDEL


6.2.2.1.5 HEXISTS


6.2.2.2 数值操作（原子自增自减）

假如哈希字段的值可以解析为数字（整数或浮点数），Redis 提供了原子增量命令：
6.2.2.2.1 HINCRBY


6.2.2.2.2 HINCRBYFLOAT


6.2.2.3 Hash 扫描（HSCAN）


6.2.3 Hash 的利用场景

6.2.4 常见注意事项 & Best Practices

6.2.5 小结

Redis Hash 提供了紧凑且机动的 “字段-值” 结构，适合存储类似对象、配置、多字段记录等。它的核心命令可总结为：
合理利用 Hash，可以有效淘汰 key 数量，提升空间利用率，且让数据结构更加接近业务对象形态。结合其他 Redis 数据类型（如 List、Set、ZSet）能够构建出更丰富的业务逻辑与功能。

6.3 列表（List）

在 Redis 中，List（列表） 是一个非经常用的数据类型，用来存储一个按插入顺序排序的字符串列表。它本质上可被视作一个双端队列，允许在队列头（left）或队列尾（right）进行插入、弹出等操作。
6.3.1 List 的存储与特点

6.3.2 List 的常见操作命令

Redis 提供了多种与 List 交互的命令，下面分门别类先容。
6.3.2.1 插入与弹出

6.3.2.1.1 LPUSH / RPUSH


示例：
  1. LPUSH mylist "world"
  2. LPUSH mylist "hello"
  3. # mylist = ["hello", "world"]
  5. RPUSH mylist "!"
  6. # mylist = ["hello", "world", "!"]
复制代码
当 mylist 不存在时，会先创建一个空列表再插入。
6.3.2.1.2 LPOP / RPOP


示例：
  1. LPOP mylist    # 返回 "hello"，mylist 变为 ["world", "!"]
  2. RPOP mylist    # 返回 "!", mylist 变为 ["world"]
复制代码
6.3.2.1.3 LINSERT


示例：
  1. # mylist = ["hello", "world"]
  2. LINSERT mylist BEFORE "world" "there"
  3. # mylist = ["hello", "there", "world"]
复制代码
6.3.2.2 获取与查察列表内容

6.3.2.2.1 LRANGE


6.3.2.2.2 LINDEX


6.3.2.2.3 LLEN


6.3.2.3 修改与截取

6.3.2.3.1 LSET


6.3.2.3.2 LTRIM


6.3.2.3.3 LREM


6.3.2.4 队列 & 壅闭操作

6.3.2.4.1 RPOPLPUSH


6.3.2.4.2 BLPOP / BRPOP


6.3.3 List 的利用场景

6.3.4 常见注意事项 & Best Practices

6.3.5 小结

List 在 Redis 中是一个强盛且机动的数据结构，可满意多种顺序场景需求，包括消息队列、最新列表、双端队列等。其核心操作可以概括为：
在实际业务中，通过合理地选用这些操作并结合过期计谋或其他结构（比方存储 ID 在 List 中、实际数据放在 Hash 或 String 里），可以构建高效的队列模型、实时日志体系或其他顺序相关的功能。
6.4 集合（Set）

在 Redis 中，Set（集合） 类型用于存储一组不重复的字符串元素，和我们熟悉的数学集合很类似。Redis 提供了丰富的命令来操作集合，包括添加、删除、判断成员以及集合之间的交并差运算等。下面将按照类似前面先容的风格，具体讲解 Set 的根本概念、常用命令以及利用场景和最佳实践。
6.4.1 Redis Set 的存储与特点

6.4.2 Set 的常见操作命令

6.4.2.1 添加、删除、判断成员

6.4.2.1.1 SADD


6.4.2.1.2 SREM


6.4.2.1.3 SISMEMBER


6.4.2.2 获取、查察和随机操作

6.4.2.2.1 SMEMBERS


6.4.2.2.2 SCARD


6.4.2.2.3 SPOP


6.4.2.2.4 SRANDMEMBER


6.4.2.3 集合运算（交集、并集、差集）

Redis 提供了三个重要的集合运算命令：SINTER、SUNION、SDIFF。共同这些命令，能快速做聚合分析，如“共同好友”、“共同爱好标签”等场景。
6.4.2.3.1 SINTER / SINTERSTORE


6.4.2.3.2 SUNION / SUNIONSTORE


6.4.2.3.3 SDIFF / SDIFFSTORE


6.4.2.4 其他常用或补充命令

6.4.3 利用场景

6.4.4 常见注意事项 & Best Practices

6.4.5 小结

Set 在 Redis 中是一个非常基础且强盛的数据结构，最显著的特点是：

其核心命令可以简要归纳为：
只要掌握这些命令和组合应用，就能应对大部分业务中需要“去重、随机、集合运算”的需求。在实际开发中，还要结合 Redis 的内存管理、过期计谋及安全控制，来告竣高性能又可靠的 Set 利用方案。
6.5 有序集合（ZSet）

在 Redis 中，有序集合（Sorted Set）是一种在集合基础上，为每个成员额外关联一个分数（score）的数据结构，常被缩写为 ZSet。它的特点是：元素不允许重复，但可以按照分数进行排序。Redis 提供了一系列针对有序集合的操作命令，方便我们在排行榜、排名查询、区间筛选、限时排序等场景中利用。
6.5.1 ZSet 的存储与特点

6.5.2 有序集合 ZSet 的常见命令

6.5.2.1 添加、更新、删除元素

6.5.2.1.1 ZADD


6.5.2.1.2 ZREM


6.5.2.1.3 ZINCRBY


6.5.2.2 按序查询、获取排名

6.5.2.2.1 ZRANGE / ZREVRANGE


6.5.2.2.2 ZRANGEBYSCORE / ZREVRANGEBYSCORE


6.5.2.2.3 ZRANGEBYLEX / ZRANGEBYDICT（Redis 6.2+ 支持），与按 Member 字典序相关


6.5.2.2.4 ZRANK / ZREVRANK


6.5.2.2.5 ZCARD / ZCOUNT


6.5.2.3 删除和范围操作

6.5.2.3.1 ZREM、ZREM_RANGE_BY_SCORE、ZREM_RANGE_BY_RANK


6.5.2.3.2 ZINTERSTORE / ZUNIONSTORE / ZDIFFSTORE (Redis 6.2+)

和普通 Set 类似，Redis 也提供了对 ZSet 的交集、并集、差集运算，但是会对 score 做相应的合并或计算。常见的是 ZINTERSTORE 和 ZUNIONSTORE。

示例：
  1. ZADD zset1 1 "a" 2 "b"
  2. ZADD zset2 2 "a" 3 "c"
  4. ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3
  5. # 这里 2 表示有 2 个集合，WEIGHTS 2 3 分别表示 zset1 的 score 乘以2, zset2 的 score 乘以3
  6. # "a" 在 zset1 score=1, zset2 score=2
  7. # 计算交集则 "a" 存在于两个集合中，score = 1*2 + 2*3 = 2 + 6 = 8
  8. # "b" 只在 zset1, "c" 只在 zset2，故它们不在交集里
  9. # out = {"a":8}
复制代码
  注意：Redis 7.0+ 也引入了 ZDIFFSTORE（差集），不过在实际中用得相对少一些。
  
6.5.3 常见利用场景

6.5.4 注意事项 & Best Practices

6.5.5 小结

有序集合（ZSet）是 Redis 中一个非常重要的高级数据结构，结合了“集合去重”与“分数排序”的优势，能在很多排行榜、调理、排序场景下大显身手。
其核心命令可简要概括为：
掌握了这些命令及应用思绪，就能机动地在Redis中构建实时排行榜、延时队列、时间序列、计分体系等功能。共同其他类型（String、Hash、Set 等）的混合利用，可以构建出更丰富、更高效的 Redis 数据模型来满意不同业务需求。
6.7 时间复杂度

在 Redis 中（以及更多计算机科学领域），我们常用 Big-O 表示法（如 O(1)、O(log N)、O(N) 等）来权衡算法或操作的时间复杂度，它代表了输入规模增大时，操作耗时的增长趋势。下面我们分几个层面来理解：
6.7.1 什么是 O(1) 和 O(log N)？

6.7.2 为何跳表的有序操作是 O(log N)？

跳表（Skiplist） 是一种随机化的数据结构，结构上类似多层链表，每一层都跳过一些节点，以加速查找、插入和删除。

举个形象的例子：

6.7.3 为何哈希表的操作是 O(1)（平均环境）？

哈希表（Hash Table） 通过哈希函数把键（Key）映射到一个桶（bucket）或槽（slot）里，理论上可以直接通过哈希函数一次定位到存储位置。

6.7.4 Redis 中具体体现

6.7.5 如何理解这些复杂度？


6.7.6 小结


这些就是常见的时间复杂度概念和在 Redis 内部的具体落地。当在应用层设计数据结构或分析 Redis 性能时，理解这些复杂度有助于我们选择合适的操作并提前预估可能的开销。
6.7 消息队列

在消息队列大概消息通报领域，一般会提到 两种常见的消息模式：
6.7.1 生产者-消费者（Producer-Consumer）

6.7.1.1 模式概念


常见的形态是“消息队列”：生产者把消息投递到队列，消费者从队列里取出并消费，终极队列中存储的是待处理的消息。
6.7.1.2 工作流程

6.7.1.3 重要特点

6.7.1.4 范例应用场景


6.7.2 发布-订阅（Pub/Sub, Publisher-Subscriber）

6.7.2.1 模式概念


可以把它理解为“广播”式：所有订阅了某个频道的订阅者，在发布者推送消息后，都会各自收到一份消息。
6.7.2.2 工作流程

6.7.2.3 重要特点

6.7.2.4 范例应用场景


6.7.3 对比与总结

维度生产者-消费者（消息队列）发布-订阅（Pub/Sub）消息通报关系一对一：队列中的一条消息只会被一个消费者处理一对多：一个消息可同时被多个订阅者吸收消息存储通常会存储在队列里，若消费者未实时消费，消息也不会丢取决于体系实现，传统 Pub/Sub 通常不存储历史消息消费模式消费者竞争消费同一个队列；可实现分布式工作池、并行处理所有订阅该主题的订阅者都能各自收到一份消息，并行处理适用场景异步处理、队列缓冲、削峰填谷、解耦分布式使命实时广播通知、事件订阅、多客户端同时吸收相同消息消息确认 & 重试通常具备ACK/重试机制，确保消息被精确处理传统简朴 Pub/Sub 一般无重试/确认，消息分发后即丢核心关注点可靠消费，队列实现排队、缓冲；包管单条消息只被处理一次消息广播，多消费者同时收到，不包管是否被落地存储
6.7.4 延伸与选择

6.7.5 小结


两种模式各有适用场景，在实际项目中往往结合利用，大概在同一个消息体系内利用不同的交换计谋实现不同结果。选择哪种模式取决于消息要给多少人吸收、是否需要队列缓冲、是否要落盘与确认、是否需要多对多的实时通讯等业务需求。
6.7.6 Redis 实现消息队列

在许多场景下，Redis 经常被用作轻量级的消息队列（Message Queue），实现简朴的生产者-消费者模型或发布订阅功能。根据 Redis 版本和需求的不同，常见的实现方式重要有：
下面依次先容各方案的特点与适用场景，并总结常见注意事项。
6.7.6.1 利用 List 构建简朴队列

6.7.6.1.1 根本原理


这样就构成了一个FIFO（先进先出）或类似队列的模型。比方：
  1. # 生产者往右端插入
  2. RPUSH task_queue "task1"
  3. RPUSH task_queue "task2"
  5. # 消费者阻塞等待
  6. BLPOP task_queue 0
  7. # 如果为空，则阻塞等待；有数据就立刻返回
复制代码

6.7.6.1.2 特点与适用场景


这种方式非常适合简朴使命队列或小规模异步处理：

6.7.6.2 利用 Redis Pub/Sub

6.7.6.2.1 根本原理


6.7.6.2.2 特点与应用场景


因此，Redis Pub/Sub 不大适合“传统队列”需求，更像实时广播，用来做直播谈天室、在线游戏通知、事件总线等。在需要可靠消费的场景中则不合适。
6.7.6.3 利用 Redis Streams（5.0+）

6.7.6.3.1 Streams 简介


6.7.6.3.2 关键概念

6.7.6.3.3 Streams 利用示例（简化）

  1. # 生产者
  2. XADD mystream * sensor-id 1 temperature 30.2
  4. # 消费者（若非消费者组）
  5. XREAD COUNT 10 STREAMS mystream 0
  6. # 读取 mystream 中的全部消息（从 id=0 开始）
  8. # 创建消费者组
  9. XGROUP CREATE mystream mygroup $ MKSTREAM
  10. # 消费者在该组内读取
  11. XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >
  12. # 读取从上次读取位置以后的新消息
  14. # 消费后，手动确认
  15. XACK mystream mygroup <message-id1> <message-id2> ...
  16. # 标记这些消息已成功处理
复制代码
6.7.6.3.4 优势与特点

6.7.6.3.5 适用场景


6.7.6.4 选择哪种方式？

6.7.6.5 常见注意事项

6.7.6.6 小结

Redis 作为内存数据库，本身并不是专业的消息中间件，但它速率快、命令简朴，对很多轻量级消息队列或实时通知场景来说很实用：
根据业务需求，选择合适的模式和实现方式，才华在性能与可靠性之间找到平衡。对简朴场景，List 队列最易上手；若需要相对专业的队列功能又想依赖 Redis生态，则 Streams 是更好的选择；若需要高可靠性和大规模分布式集群，可进一步研究专业MQ或结合 Redis 与其他体系。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4