redis部署与使用

redis部署与使用

redis基础

官网地址：https://redis.io/
Redis和Memcached是非关系型数据库也称为NoSQL数据库，MySQL、Mariadb、SQL Server、PostgreSQL、
Oracle 数据库属于关系型数据(RDBMS, Relational Database Management System)

redis简介

Redis(Remote Dictionary Server)在2009年发布，开发者Salvatore Sanfilippo是意大利开发者，他本想为自己的
公司开发一个用于替换MySQL的产品Redis，但是没有想到他把Redis开源后大受欢迎，短短几年，Redis就有了很
大的用户群体，目前国内外使用的公司有知乎网、新浪微博、GitHub等
redis是一个开源的、遵循BSD协议的、基于内存的而且目前比较流行的键值数据库(key-value database)，是一个
非关系型数据库，redis提供将内存通过网络远程共享的一种服务，提供类似功能的还有memcache，但相比
memcache，redis还提供了易扩展、高性能、具备数据持久性等功能。
Redis在高并发、低延迟环境要求比较高的环境使用量非常广泛，目前redis在DB-Engine月排行榜https://db-engines.com/en/ranking 中一直比较靠前，而且一直是键值型存储类的首位。

redis对比memcached

支持数据的持久化：可以将内存中的数据保持在磁盘中，重启redis服务或者服务器之后可以从备份文件中恢复数据到内存继续使用。

支持更多的数据类型：支持string(字符串)、hash(哈希数据)、list(列表)、set(集合)、zet(有序集合)

支持数据的备份：可以实现类似于数据的master-slave模式的数据备份，另外也支持使用快照+AOF。

支持更大的value数据：memcache单个key value最大只支持1MB，而redis最大支持512MB。

Redis 是单线程，而memcache是多线程，所以单机情况下没有memcache并发高，但redis 支持分布式集群以实现更高的并发，单Redis实例可以实现数万并发。

支持集群横向扩展：基于redis cluster的横向扩展，可以实现分布式集群，大幅提升性能和数据安全性。
都是基于C语言开发。

redis 典型应用场景

Session 共享：常见于web集群中的Tomcat或者PHP中多web服务器session共享

消息队列：ELK的日志缓存、部分业务的订阅发布系统

计数器：访问排行榜、商品浏览数等和次数相关的数值统计场景

缓存：数据库查询缓存、电商网站商品信息、新闻内容

微博/微信社交场合：共同好友、点赞评论等

Redis安装及使用

官方下载地址：http://download.redis.io/releases/

Windows版 Redis下载地址：https://github.com/MicrosoftArchive/redis/releases

yum安装redis

#在centos系统上需要安装epel源。
#wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
#yum install epel-7.repo

#查看yum仓库redis版本
#yum list redis
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
Available Packages
redis.x86_64                                          3.2.12-2.el7                                          Epe

#安装redis
#yum install redis -y
#systemctl enable --now redis 
Created symlink from /etc/systemd/system/multi-user.target.wants/redis.service to /usr/lib/systemd/system/redis.service.
##redis-cli
127.0.0.1:6379> info 
# Server
redis_version:3.2.12
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:7897e7d0e13773f
redis_mode:standalone
os:Linux 3.10.0-957.el7.x86_64 x86_64
arch_bits:64

编译安装redis

下载当前最新release版本redis 源码包：http://download.redis.io/releases/

编译安装命令:

官方的安装命令:

https://redis.io/download

# pwd 
/usr/local/src
#wget http://download.redis.io/releases/redis-4.0.14.tar.gz #下载redis4.0.14

#cd redis-4.0.14

#make PREFIX=/apps/redis install #编译redis到/apps/redis

#ll /apps/redis/    
total 4
drwxr-xr-x 2 root root 4096 Feb  8 15:38 bin

#mkdir /apps/redis/{etc,logs,data,run} #创建配置文件、日志、数据等目录

#cp redis.conf /apps/redis/etc/   #复制配置redis配置文件

# groupadd -g 1000 redis && useradd -u 1000 -g 1000 redis -s /sbin/nologin #创建redis用户

# chown redis.redis -R /apps/redis/ #设置目录权限

#创建命令软连接
# ln -sv /apps/redis/bin/redis-* /usr/bin/
‘/usr/bin/redis-benchmark’ -> ‘/apps/redis/bin/redis-benchmark’
‘/usr/bin/redis-check-aof’ -> ‘/apps/redis/bin/redis-check-aof’
‘/usr/bin/redis-check-rdb’ -> ‘/apps/redis/bin/redis-check-rdb’
‘/usr/bin/redis-cli’ -> ‘/apps/redis/bin/redis-cli’
‘/usr/bin/redis-sentinel’ -> ‘/apps/redis/bin/redis-sentinel’
‘/usr/bin/redis-server’ -> ‘/apps/redis/bin/redis-server’

前台启动redis

#/apps/redis/bin/redis-server /apps/redis/etc/redis.conf 
61317:C 08 Feb 15:46:38.907 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
61317:C 08 Feb 15:46:38.907 # Redis version=4.0.14, bits=64, commit=00000000, modified=0, pid=61317, just started
61317:C 08 Feb 15:46:38.907 # Configuration loaded
61317:M 08 Feb 15:46:38.908 * Increased maximum number of open files to 10032 (it was originally set to 1024).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 61317
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

61317:M 08 Feb 15:46:38.917 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
61317:M 08 Feb 15:46:38.917 # Server initialized
61317:M 08 Feb 15:46:38.917 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
61317:M 08 Feb 15:46:38.917 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
61317:M 08 Feb 15:46:38.917 * Ready to accept connections

解决当前的警告提示

1.tcp-backlog

The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.

backlog参数控制的是三次握手的时候sever段收到client ack确认号之后的队列号

#设置队列长度为512

#永久设置
#echo 'net.core.somaxconn = 512' >> /etc/sysctl.conf
#sysctl -p
net.core.somaxconn = 512

#临时设置
#echo 512 >> /proc/sys/net/core/somaxconn

2.vm.overcommit_memory

0、表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存
申请失败，并把错误返回给应用进程。

1、表示内核允许分配所有的物理内存，而不管当前的内存状态如何。

2、表示内核允许分配超过所有物理内存和交换空间总和的内存

vm.overcommit_memory = 1

3.transparent hugepage

大页内存动态分配,需要关闭让redis负责内存管理

#cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never
#默认级别为always

#echo never > /sys/kernel/mm/transparent_hugepage/enabled
#cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]
#修改为never

#永久追加never到/sys/kernel…/文件中
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.d/rc.local

再次启动redis

#/apps/redis/bin/redis-server /apps/redis/etc/redis.conf 
62396:C 08 Feb 16:04:01.705 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
62396:C 08 Feb 16:04:01.705 # Redis version=4.0.14, bits=64, commit=00000000, modified=0, pid=62396, just started
62396:C 08 Feb 16:04:01.705 # Configuration loaded
62396:M 08 Feb 16:04:01.705 * Increased maximum number of open files to 10032 (it was originally set to 1024).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 62396
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

62396:M 08 Feb 16:04:01.707 # Server initialized
62396:M 08 Feb 16:04:01.707 * DB loaded from disk: 0.000 seconds
62396:M 08 Feb 16:04:01.707 * Ready to accept connections

编辑redis服务启动脚本

#vim /usr/lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
#ExecStart=/usr/bin/redis-server /etc/redis.conf --supervised systemd
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd
#ExecStop=/usr/libexec/redis-shutdown
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target


#重读配置文件
#systemctl daemon-reload

验证redis启动

#systemctl start redis
#ss -tnl 
State      Recv-Q Send-Q           Local Address:Port                          Peer Address:Port              
LISTEN     0      511                  127.0.0.1:6379                                     *:*                  

#redis-cli -h IP/HOSTNAME -p PORT -a PASSWORD
#redis-cli 
127.0.0.1:6379> info
# Server
redis_version:4.0.14
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:2cb7c66593b8efb3
redis_mode:standalone
os:Linux 3.10.0-957.el7.x86_64 x86_64
arch_bits:64

连接到Redis

#本机非密码连接
# redis-cli

#跨主机非密码连接
# redis-cli -h HOSTNAME/IP -p PORT

#跨主机密码连接
# redis-cli -h HOSTNAME/IP -p PORT -a PASSWORD

脚本写入数据到Redis

shell脚本写入数据到redis

#!/bin/bash
NUM=`seq 1 100000`
for i in ${NUM};do
	redis-cli -h 127.0.0.1 set key-${i} value-${i}
	echo "key-${i} value-${i} 写入完成"
done
echo "十万个key写入到Redis完成"

python脚本写入数据到redis

#yum install python2-redis
#pip install redis

#!/bin/env python
import redis #此处python需调用redis库,需要安装redis库,pip install redis
import time
pool = redis.ConnectionPool(host="127.0.0.1", port=6379,password="")
r = redis.Redis(connection_pool=pool)
for i in range(100):
	r.set("k%d" % i,"v%d" % i)
	time.sleep(1)
	data=r.get("k%d" % i)
	print(data)

redis配置文件

redis主要配置项

bind 0.0.0.0 #监听地址，可以用空格隔开后多个监听IP
protected-mode yes #redis3.2 之后加入的新特性，在没有设置bind IP和密码的时候,redis只允许访问127.0.0.1:6379，远程访问将提示警告信息并拒绝远程访问
port 6379 #监听端口
tcp-backlog 511 #三次握手的时候server端收到client ack确认号之后的队列值。
timeout 0 #客户端和Redis服务端的连接超时时间，默认是0，表示永不超时。
tcp-keepalive 300 #tcp 会话保持时间

daemonize no #认情况下 redis 不是作为守护进程运行的，如果你想让它在后台运行，你就把它改成 yes,当redis作为守护进程运行的时候，它会写一个 pid 到 /var/run/redis.pid 文件里面
supervised no #和操作系统相关参数，可以设置通过upstart和systemd管理Redis守护进程，centos 7以后都使用systemd
pidfile /var/run/redis_6379.pid #pid文件路径
loglevel notice#日志级别
logfile "" #日志路径
databases 16 #设置db 库数量，默认16个库
always-show-logo yes #在启动redis时是否显示log

save 900 1 #在900秒内有一个键内容发生更改就出就快照机制
save 300 10
save 60 10000 #三个save是或的关系,满足一个就触发快照机制

stop-writes-on-bgsave-error no #快照出错时是否禁止redis写入操作
rdbcompression yes #持久化到RDB文件时，是否压缩，"yes"为压缩，"no"则反之
rdbchecksum yes #是否开启RC64校验，默认是开启
dbfilename dump.rdb #快照文件名
dir ./ #快照文件保存路径

replica-serve-stale-data yes #当从库同主库失去连接或者复制正在进行，从机库有两种运行方式：
#1、如果replica-serve-stale-data设置为yes(默认设置)，从库会继续响应客户端的读请求。
#2、如果replica-serve-stale-data设置为no，除去指定的命令之外的任何请求都会返回一个错误"SYNC withmaster in progress"。
replica-read-only yes #是否设置从库只读

repl-diskless-sync no #是否使用socket方式复制数据(无盘同步)，新slave连接连接时候需要做数据的全量同步，redis server就要从内存dump出新的RDB文件，然后从master传到slave，有两种方式把RDB文件传输给客户端：
#1、基于硬盘（disk-backed）：master创建一个新进程dump RDB，RDB完成之后由父进程（即主进程）传给slaves。
#2、基于socket（diskless）：master创建一个新进程直接dump RDB到slave的socket，不经过主进程，不经过硬盘。
#基于硬盘的话，RDB文件创建后，一旦创建完毕，可以同时服务更多的slave，但是基于socket的话， 新slave连接到master之后得逐个同步数据。
#在较慢并且网络较快的时候，可以用diskless(yes),否则使用磁盘(no)

repl-diskless-sync-delay 30 #diskless**复制的延迟时间**，设置0为关闭，在延迟时间内连接的新客户端，会一起通过disk方式同步数据，但是一旦复制开始还没有结束之前，master节点不会再接收新slave的复制请求，直到下一次同步开始。
repl-ping-slave-period 10 #slave根据master指定的时间进行周期性的PING 监测
repl-timeout 60 #复制连接的超时时间，需要大于repl-ping-slave-period，否则会经常报超时
repl-disable-tcp-nodelay no #在socket模式下是否在slave套接字发送SYNC之后禁用 TCP_NODELAY，如果选择“yesRedis将使用更少的TCP包和带宽来向slaves发送数据，但是这将使数据传输到slave上有延迟，Linux内核的默认配置会达到40毫秒，如果你选择了 "no"** 数据传输到salve**的延迟将会减少但要使用更多的带宽。
repl-backlog-size 512mb #复制缓冲区内存大小，只有在slave连接之后才分配内存。
repl-backlog-ttl 3600 #多次时间master没有slave连接，就清空backlog缓冲区。
replica-priority 100 #当master不可用，Sentinel会根据slave的优先级选举一个master，最低的优先级的slave，当选master，而配置成0，永远不会被选举。
requirepass foobared #设置redis 连接密码
rename-command #重命名一些高危命令
maxclients 10000 #Redis最大连接客户端
maxmemory #最大内存，单位为bytes字节，8G内存的计算方式8(G)1024(MB)1024(KB)*1024(Kbyte)，需要注意的是slave的输出缓冲区是不计算在maxmemory内。


appendonly no #是否开启AOF日志记录，默认redis使用的是rdb方式持久化，这种方式在许多应用中已经足够用了，但是redis如果中途宕机，会导致可能有几分钟的数据丢失(取决于dumpd数据的间隔时间)，根据save来策略进行持久化，Append Only File是另一种持久化方式，可以提供更好的持久化特性，Redis会把每次写入的数据在接收后都写入 appendonly.aof 文件，每次启动时Redis都会先把这个文件的数据读入内存里，先忽略RDB文件。

appendfilename "appendonly.aof" #AOF文件名
appendfsync everysec #aof持久化策略的配置,no表示不执行fsync，由操作系统保证数据同步到磁盘,always表示每次写入都执行fsync，以保证数据同步到磁盘,everysec表示每秒执行一次fsync，可能会导致丢失这1s数据。

no-appendfsync-on-rewrite no #在aof rewrite期间,是否对aof新记录的append暂缓使用文件同步策略,主要考虑磁盘IO开支和请求阻塞时间。默认为no,表示"不暂缓",新的aof记录仍然会被立即同步，Linux的默认fsync策略是30秒，如果为yes 可能丢失30秒数据，但由于yes性能较好而且会避免出现阻塞因此比较推荐。

auto-aof-rewrite-percentage 100 # 当Aof log增长超过指定百分比例时，重写AOF文件， 设置为0表示不自动重写Aof 日志，重写是为了使aof体积保持最小，但是还可以确保保存最完整的数据，

auto-aof-rewrite-min-size 64mb #触发aof rewrite的最小文件大小
aof-load-truncated yes #是否加载由于其他原因导致的末尾异常的AOF文件(主进程被kill/断电等)

aof-use-rdb-preamble no #redis4.0新增RDB-AOF混合持久化格式，在开启了这个功能之后，AOF重写产生的文件将同时包含RDB格式的内容和AOF格式的内容，其中RDB格式的内容用于记录已有的数据，而AOF格式的内存则用于记录最近发生了变化的数据，这样Redis就可以同时兼有RDB持久化和AOF持久化的优点（既能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）。

lua-time-limit 5000 #lua脚本的最大执行时间，单位为毫秒
cluster-enabled yes #是否开启集群模式，默认是单机模式
cluster-config-file nodes-6379.conf #由node节点自动生成的集群配置文件

cluster-node-timeout 15000 #集群中node节点连接超时时间
cluster-replica-validity-factor 10 #在执行故障转移的时候可能有些节点和master断开一段时间数据比较旧，这些节点就不适用于选举为master，超过这个时间的就不会被进行故障转移

cluster-migration-barrier 1 #集群迁移屏障，一个主节点拥有的至少正常工作的从节点，即如果主节点的slave节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。

cluster-require-full-coverage no #集群请求槽位全部覆盖，如果一个主库宕机且没有备库就会出现集群槽位不全，那么yes情况下redis集群槽位验证不全就不再对外提供服务，而no则可以继续使用但是会出现查询数据查不到的情况(因为有数据丢失)。
#Slow log 是 Redis 用来记录查询执行时间的日志系统，slow log 保存在内存里面，读写速度非常快，因此你可以放心地使用它，不必担心因为开启 slow log 而损害 Redis 的速度。

slowlog-log-slower-than 10000 #以微秒为单位的慢日志记录，为负数会禁用慢日志，为0会记录每个命令操作。
slowlog-max-len 128 #记录多少条慢日志保存在队列，超出后会删除最早的，以此滚动删除
127.0.0.1:6379> slowlog len
(integer) 14
127.0.0.1:6379> slowlog get
1) 1) (integer) 14
2) (integer) 1544690617
3) (integer) 4
4) 1) "slowlog"
127.0.0.1:6379> SLOWLOG reset
OK

redis持久化

Redis 虽然是一个内存级别的缓存程序，也就是redis 是使用内存进行数据的缓存的，但是其可以将内存的数据按
照一定的策略保存到硬盘上，从而实现数据持久保存的目的，目前redis支持两种不同方式的数据持久化保存机
制，分别是RDB和AOF

RDB模式

RDB(Redis DataBase)：基于时间的快照，其默认只保留当前最新的一次快照，特点是执行速度比较快，缺点是可
能会丢失从上次快照到当前时间点之间未做快照的数据。
RDB实现的具体过程Redis从主进程先fork出一个子进程，使用写时复制机制，子进程将内存的数据保存为一个临
时文件，比如dump.rdb.temp，当数据保存完成之后再将上一次保存的RDB文件替换掉，然后关闭子进程，这样
可以保存每一次做RDB快照的时候保存的数据都是完整的，因为直接替换RDB文件的时候可能会出现突然断电等问
题而导致RDB文件还没有保存完整就突然关机停止保存而导致数据丢失的情况，可以手动将每次生成的RDB文件进
程备份，这样可以最大化保存历史数据。

RDB模式的优缺点

优点： RDB快照保存了某个时间点的数据，可以通过脚本执行bgsave(非阻塞)或者save(阻塞)命令自定义时间点备
份，可以保留多个备份，当出现问题可以恢复到不同时间点的版本。 可以最大化IO 的性能，因为父进程在保存
RDB 文件的时候唯一要做的是fork出一个子进程，然后的-操作都会有这个子进程操作，父进程无需任何的IO操作
RDB在大量数据比如几个G的数据，恢复的速度比AOF的快

缺点： 不能实时的保存数据，会丢失自上一次执行RDB备份到当前的内存数据 -数据量非常大的时候，从父进程
fork的时候需要一点时间，可能是毫秒或者秒或者分钟，取决于磁盘IO性能。

AOF模式

AOF：按照操作顺序依次将操作添加到指定的日志文件当中，特点是数据安全性相对较高，缺点是即使有些操作是
重复的也会全部记录。
AOF和RDB一样使用了写时复制机制，AOF默认为每秒钟fsync一次，即将执行的命令保存到AOF文件当中，这样即使redis服务器发生故障的话顶多也就丢失1秒钟之内的数据，也可以设置不同的fsync策略，或者设置每次执行命令的时候执行fsync，fsync会在后台执行线程，所以主线程可以继续处理用户的正常请求而不受到写入AOF文件的IO影响。

AOF模式优缺点：
AOF的文件大小要大于RDB格式的文件
根据所使用的fsync策略(fsync是同步内存中redis所有已经修改的文件到存储设备)，默认是appendfsync everysec
即每秒执行一次fsync。

redis基于bgsave备份脚本

#!/bin/bash
echo "start..."
sdate=$(date "+ %Y-%m-%d %H:%M:%S")
msg=`redis-cli -p $1 -a $2 bgsave`
echo "start bgsave time:$sdate"  #info Persistence 监测服务器是否正在创建rdb文件一旦创建立即重名脚本
result=`redis-cli -p $1 -a $2 info Persistence | grep "rdb_bgsave_in_progress" | awk -F":" '{print $2}'`
while [ `echo ${result} | awk -v tem="0" '{print($1>tem)? "1":"0"}'` -eq "1" ] ; do
    sleep 1
    result=`redis-cli -p $1 -a $2 info Persistence | grep "rdb_bgsave_in_progress" | awk -F":" '{print $2}'`
done
edate=$(date "+ %Y-%m-%d %H:%M:%S")
echo "end bgsave time:$edate"
echo "renaming rdb file..."
date=$(date "+ %Y%m%d_%H:%M:%S")
mv "/apps/redis/data/dump.rdb" "/apps/redis/data/${date}.rdb"
echo "finish backup rdb file"
echo "end"

https://blog.csdn.net/still_fantasy/article/details/81087606

编译安装redis4.0.14脚本

#!/bin/bash

gecho() {
    echo -e "\e[1;32m $1 \e[0m"
    sleep 1
}
recho() {
    echo -e "\e[1;31m $1 \e[0m"
    sleep 1
}

############下载解压redis4.0.14################
gecho "下载解压redis4.0.14"
wget http://download.redis.io/releases/redis-4.0.14.tar.gz 
tar xf redis-4.0.14.tar.gz
cd redis-4.0.14
###############################################

#参数修改
#└---1.安装目录
install_dir="/apps/redis"

#环境安装
gecho "环境安装"
yum -y install gcc gcc-c++  || ( recho "安装环境失败" ; exit )

#编译redis
gecho "编译redis"
make PREFIX=${install_dir} install  || recho "编译失败"
gecho "拷贝配置文件"
mkdir -p ${install_dir}/{etc,log,data,run}
cp redis.conf ${install_dir}/etc/
cp sentinel.conf ${install_dir}/etc/

#配置环境
gecho "配置环境"
echo "net.core.somaxconn = 1024" >> /etc/sysctl.conf
echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
sysctl -p || recho "配置环境失败"
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local 
chmod +x /etc/rc.local 

#配置启动脚本
gecho "配置启动脚本"
cat > /usr/lib/systemd/system/redis.service << EOF
[Unit]
Description=Redis persistent key-value database
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
ExecStart=${install_dir}/bin/redis-server ${install_dir}/etc/redis.conf --supervised systemd
ExecReload=/bin/kill -s HUP \$MAINPID
ExecStop=/bin/kill -s QUIT \$MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
[Install]
WantedBy=multi-user.target
EOF

#启动服务
gecho "启动服务"
useradd -s /sbin/nologin redis  || recho "redis用户已存在"
chown redis.redis -R ${install_dir}
systemctl daemon-reload
systemctl restart redis
systemctl enable redis
ln -sv ${install_dir}/bin/redis* /usr/local/sbin

#修改配置文件
gecho "修改配置文件"
sed -i "s@^dir.*@dir \"${install_dir}/data\"@" ${install_dir}/etc/redis.conf
sed -i "s@^logfile.*@logfile \"${install_dir}/log/redis.log\"@" ${install_dir}/etc/redis.conf


in/kill -s QUIT \$MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
[Install]
WantedBy=multi-user.target
EOF

#启动服务
gecho "启动服务"
useradd -s /sbin/nologin redis  || recho "redis用户已存在"
chown redis.redis -R ${install_dir}
systemctl daemon-reload
systemctl restart redis
systemctl enable redis
ln -sv ${install_dir}/bin/redis* /usr/local/sbin

#修改配置文件
gecho "修改配置文件"
sed -i "s@^dir.*@dir \"${install_dir}/data\"@" ${install_dir}/etc/redis.conf
sed -i "s@^logfile.*@logfile \"${install_dir}/log/redis.log\"@" ${install_dir}/etc/redis.conf

https://www.studylinux.xyz/?p=290#redis7