Redis上踩过的一些坑-美团

Redis系列之历史踩坑 本文大概记录了笔者在使用 Redis 过程中踩过的坑,以及相应的建议。 阅读详情

上上周和同事(龙哥)参加了360组织的互联网技术训练营第三期,美团网的DBA负责人侯军伟给大家介绍了美团网在redis上踩得一些坑,讲的都是干货和坑。

    分为5个部分:

一、周期性出现connect timeout

二、redis bgrewriteaof问题

三、redis内存占用飙升

四、redis内存使用优化 

五、redis cluster遇到的一些问题 

 

 一、周期性出现connect timeout

1. 背景:

 

大部分互联网公司都会有Mysql或者Oracle的DBA,但是在Nosql方面一般不会设置专门的DBA。不过对于一些知名的互联网公司来说,Nosql的使用量是巨大的,所以通常让Mysql的DBA或者单独聘请工程师来维护一些Nosql数据库,比如:

      Redis, Hbase, Memcache(其实严格讲不是nosql), Mongodb,

Cassandra。从讲座看美团网应该是有专职的Redis DBA。所以作为业务开发人员不需要自己安装、配置、运维Redis,只需要找Redis

DBA来申请就可以了。

      这里为了简化说明:Redis DBA提供的服务叫做Redis云,业务开发人员叫做业务端(redis的使用者)

   2. 现象:

       业务端在使用redis云提供的redis服务后,经常出现connect timeout:

Java代码 

redis.clients.jedis.exceptions.JedisConnectionException  

java.net.SocketException  

java.net.SocketTimeoutException:connect time out  

   3. 分析和怀疑:

   业务端一般认为redis出现问题,就是redis云有问题,人的“正常”思维:看别人错误容易,发现自己难,扯多了, 出现这个有很多原因:

   (1). 网络原因:比如是否存在跨机房、网络割接等等。

   (2). 慢查询,因为redis是单线程,如果有慢查询的话,会阻塞住之后的操作。 

   (3). value值过大?比如value几十兆,当然这种情况比较少,其实也可以看做是慢查询的一种

   (4). aof重写/rdb fork发生?瞬间会堵一下Redis服务器。

   (5). 其他..................

 

   4. 查询原因

   演讲者一开始怀疑是网络问题,但是并未发现问题,观察各种对比图表,tcp listenOverFlow和timeout经常周期出现。(赞一下这个监控,我们监控现在还没有这个层面的)

   有关listenOverFlow:

查看现有的连接数是否大于设置的backlog,如果大于就丢弃,并相应的参数值加1。其中backlog是由程序和系统参数net.core.somaxconn共同设置,当backlog的值大于系统设置的net.core.somaxconn时则取net.core.somaxconn的值,否则取程序设置的backlog值。这种出错的方式也被记录在TcpListenOverflows中(其只记录了连接个数不足而产生溢出错误的次数!)。

   觉得可能和TCP相关,于是分析了Tcp三次握手:最后一次握手客户端的请求会进入服务器端的一个队列(可以认为是下三图)中,如果这个队列满了,就会发生上面的异常。(accept)

  (1) TCP三次握手: 

  (2) redis客户端与redis服务器交互的过程(本质就是TCP请求)

  (3) I/O 多路复用程序通过队列向文件事件分派器传送套接字的过程

   (4) 和redis有什么关系呢?

        由于Redis的单线程模型(对命令的处理和连接的处理都是在一个线程中),如果存在慢查询的话,会出现上面的这种情况,造成新的accept的连接进不了队列。

    如果上面的图没法理解的话,看看这张图:

 

   5. 解决方法:

    (1) 对慢查询进行持久化,比如定时存放到mysql之类。(redis的慢查询只是一个list,超过list设置的最大值,会清除掉之前的数据,也就是看不到历史)

    (2) 对慢查询进行报警(频率、数量、时间)等等因素

    (3) 打屁股,哈哈:

     (4) 其实应该做的是:对业务端进行培训,告诉他们一下redis开发的坑,redis不是万金油,这个和Mysql DBA要培训Mysql使用者一样,否则防不胜防。

比如他执行了 monitor, keys *, flushall, drop table, update table set a=1; 这种也是防不胜防的(当然也可以做限制,利用rename-command一个随机数),但是提高工程师的水平才是关键。

参考文献:redis 如何处理客户端连接

 

 二、redis bgrewriteaof问题

一、背景

1. AOF:

    Redis的AOF机制有点类似于Mysql binlog,是Redis的提供的一种持久化方式(另一种是RDB),它会将所有的写命令按照一定频率(no, always, every seconds)写入到日志文件中,当Redis停机重启后恢复数据库。

 

2. AOF重写:

     (1) 随着AOF文件越来越大,里面会有大部分是重复命令或者可以合并的命令(100次incr = set key 100)

     (2) 重写的好处:减少AOF日志尺寸,减少内存占用,加快数据库恢复时间。

 

 

 

二、单机多实例可能存在Swap和OOM的隐患:

    由于Redis的单线程模型,理论上每个redis实例只会用到一个CPU,

也就是说可以在一台多核的服务器上部署多个实例(实际就是这么做的)。但是Redis的AOF重写是通过fork出一个Redis进程来实现的,所以有经验的Redis开发和运维人员会告诉你,在一台服务器上要预留一半的内存(防止出现AOF重写集中发生,出现swap和OOM)。

 

 

 

三、最佳实践

1. meta信息:作为一个redis云系统,需要记录各个维度的数据,比如:业务组、机器、实例、应用、负责人多个维度的数据,相信每个Redis的运维人员都应该有这样的持久化数据(例如Mysql),一般来说还有一些运维界面,为自动化和运维提供依据

    例如如下:

 

 

 

 

2. AOF的管理方式:

 (1) 自动:让每个redis决定是否做AOF重写操作(根据auto-aof-rewrite-percentage和auto-aof-rewrite-min-size两个参数):

 

 (2) crontab: 定时任务,可能仍然会出现多个redis实例,属于一种折中方案。

 

 (3) remote集中式:

       最终目标是一台机器一个时刻,只有一个redis实例进行AOF重写。

       具体做法其实很简单,以机器为单位,轮询每个机器的实例,如果满足条件就运行(比如currentSize和baseSize满足什么关系)bgrewriteaof命令。

期间可以监控发生时间、耗时、频率、尺寸的前后变化            

 

策略优点缺点

自动无需开发1. 有可能出现(无法预知)上面提到的Swap和OOM

2. 出了问题,处理起来其实更费时间。

AOF控制中心(remote集中式)1. 防止上面提到Swap和OOM。

2. 能够收集更多的数据(aof重写的发生时间、耗时、频率、尺寸的前后变化),更加有利于运维和定位问题(是否有些机器的实例需要拆分)。

控制中心需要开发。

 

 

一台机器轮询执行bgRewriteAof代码示例:

 

Java代码 

package com.sohu.cache.inspect.impl;  

 

import com.sohu.cache.alert.impl.BaseAlertService;  

import com.sohu.cache.entity.InstanceInfo;  

import com.sohu.cache.inspect.InspectParamEnum;  

import com.sohu.cache.inspect.Inspector;  

import com.sohu.cache.util.IdempotentConfirmer;  

import com.sohu.cache.util.TypeUtil;  

import org.apache.commons.collections.MapUtils;  

import org.apache.commons.lang.StringUtils;  

import redis.clients.jedis.Jedis;  

 

import java.util.Collections;  

import java.util.LinkedHashMap;  

import java.util.List;  

import java.util.Map;  

import java.util.concurrent.TimeUnit;  

 

 

public class RedisIsolationPersistenceInspector extends BaseAlertService implements Inspector {  

 

public static final int REDIS_DEFAULT_TIME = 5000;  

 

@Override  

public boolean inspect(Map paramMap) {  

// 某台机器和机器下所有redis实例  

final String host = MapUtils.getString(paramMap, InspectParamEnum.SPLIT_KEY);  

        List list = (List) paramMap.get(InspectParamEnum.INSTANCE_LIST);  

// 遍历所有的redis实例  

for (InstanceInfo info : list) {  

final int port = info.getPort();  

final int type = info.getType();  

int status = info.getStatus();  

// 非正常节点  

if (status != 1) {  

continue;  

            }  

if (TypeUtil.isRedisDataType(type)) {  

Jedis jedis =new Jedis(host, port, REDIS_DEFAULT_TIME);  

try {  

// 从redis info中索取持久化信息  

                    Map persistenceMap = parseMap(jedis);  

if (persistenceMap.isEmpty()) {  

logger.error("{}:{} get persistenceMap failed", host, port);  

continue;  

                    }  

// 如果正在进行aof就不做任何操作,理论上要等待它完毕,否则  

if (!isAofEnabled(persistenceMap)) {  

continue;  

                    }  

// 上一次aof重写后的尺寸和当前aof的尺寸  

long aofCurrentSize = MapUtils.getLongValue(persistenceMap, "aof_current_size");  

long aofBaseSize = MapUtils.getLongValue(persistenceMap, "aof_base_size");  

// 阀值大于60%  

long aofThresholdSize = (long) (aofBaseSize * 1.6);  

double percentage = getPercentage(aofCurrentSize, aofBaseSize);  

// 大于60%且超过60M  

if (aofCurrentSize >= aofThresholdSize && aofCurrentSize > (64 * 1024 * 1024)) {  

// bgRewriteAof 异步操作。  

boolean isInvoke = invokeBgRewriteAof(jedis);  

if (!isInvoke) {  

logger.error("{}:{} invokeBgRewriteAof failed", host, port);  

continue;  

}else {  

logger.warn("{}:{} invokeBgRewriteAof started percentage={}", host, port, percentage);  

                        }  

// 等待Aof重写成功(bgRewriteAof是异步操作)  

while (true) {  

try {  

// before wait 1s  

TimeUnit.SECONDS.sleep(1);  

                                Map loopMap = parseMap(jedis);  

Integer aofRewriteInProgress = MapUtils.getInteger(loopMap,"aof_rewrite_in_progress", null);  

if (aofRewriteInProgress == null) {  

logger.error("loop watch:{}:{} return failed", host, port);  

break;  

}else if (aofRewriteInProgress <= 0) {  

// bgrewriteaof Done  

logger.warn("{}:{} bgrewriteaof Done lastSize:{}Mb,currentSize:{}Mb", host, port,  

                                            getMb(aofCurrentSize),  

getMb(MapUtils.getLongValue(loopMap,"aof_current_size")));  

break;  

}else {  

// wait 1s  

TimeUnit.SECONDS.sleep(1);  

                                }  

}catch (Exception e) {  

                                logger.error(e.getMessage(), e);  

                            }  

                        }  

}else {  

if (percentage > 50D) {  

long currentSize = getMb(aofCurrentSize);  

logger.info("checked {}:{} aof increase percentage:{}% currentSize:{}Mb", host, port,  

percentage, currentSize >0 ? currentSize : "<1");  

                        }  

                    }  

}finally {  

                    jedis.close();  

                }  

            }  

        }  

return true;  

    }  

 

private long getMb(long bytes) {  

return (long) (bytes / 1024 / 1024);  

    }  

 

private boolean isAofEnabled(Map infoMap) {  

Integer aofEnabled = MapUtils.getInteger(infoMap,"aof_enabled", null);  

return aofEnabled != null && aofEnabled == 1;  

    }  

 

private double getPercentage(long aofCurrentSize, long aofBaseSize) {  

if (aofBaseSize == 0) {  

return 0.0D;  

        }  

String format = String.format("%.2f", (Double.valueOf(aofCurrentSize - aofBaseSize) * 100 / aofBaseSize));  

return Double.parseDouble(format);  

    }  

 

private Map parseMap(final Jedis jedis) {  

final StringBuilder builder = new StringBuilder();  

boolean isInfo = new IdempotentConfirmer() {  

@Override  

public boolean execute() {  

String persistenceInfo =null;  

try {  

persistenceInfo = jedis.info("Persistence");  

}catch (Exception e) {  

logger.warn(e.getMessage() +"-{}:{}", jedis.getClient().getHost(), jedis.getClient().getPort(),  

                            e.getMessage());  

                }  

boolean isOk = StringUtils.isNotBlank(persistenceInfo);  

if (isOk) {  

                    builder.append(persistenceInfo);  

                }  

return isOk;  

            }  

        }.run();  

if (!isInfo) {  

logger.error("{}:{} info Persistence failed", jedis.getClient().getHost(), jedis.getClient().getPort());  

return Collections.emptyMap();  

        }  

        String persistenceInfo = builder.toString();  

if (StringUtils.isBlank(persistenceInfo)) {  

return Collections.emptyMap();  

        }  

Map map =new LinkedHashMap();  

String[] array = persistenceInfo.split("\r\n");  

for (String line : array) {  

String[] cells = line.split(":");  

if (cells.length > 1) {  

map.put(cells[0], cells[1]);  

            }  

        }  

 

return map;  

    }  

 

public boolean invokeBgRewriteAof(final Jedis jedis) {  

return new IdempotentConfirmer() {  

@Override  

public boolean execute() {  

try {  

                    String response = jedis.bgrewriteaof();  

if (response != null && response.contains("rewriting started")) {  

return true;  

                    }  

}catch (Exception e) {  

                    String message = e.getMessage();  

if (message.contains("rewriting already")) {  

return true;  

                    }  

                    logger.error(message, e);  

                }  

return false;  

            }  

        }.run();  

    }  

}  

 

 

 

 

 

附图一张:

 

 

 

 三、redis内存占用飙升

 一、现象:

    redis-cluster某个分片内存飙升,明显比其他分片高很多,而且持续增长。并且主从的内存使用量并不一致。

二、分析可能原因:

 1.  redis-cluster的bug (这个应该不存在)

 2. 客户端的hash(key)有问题,造成分配不均。(redis使用的是crc16, 不会出现这么不均的情况)

 3. 存在个别大的key-value: 例如一个包含了几百万数据set数据结构(这个有可能)

 4. 主从复制出现了问题。

 5. 其他原因

 

三、调查原因:

 1. 经查询,上述1-4都不存在

 2. 观察info信息,有一点引起了怀疑: client_longes_output_list有些异常。

3. 于是理解想到服务端和客户端交互时,分别为每个客户端设置了输入缓冲区和输出缓冲区,这部分如果很大的话也会占用Redis服务器的内存。

从上面的client_longest_output_list看,应该是输出缓冲区占用内存较大,也就是有大量的数据从Redis服务器向某些客户端输出。

于是使用client list命令(类似于mysql processlist) redis-cli -h host

-p port client list | grep -v

"omem=0",来查询输出缓冲区不为0的客户端连接,于是查询到祸首monitor,于是豁然开朗.

monitor的模型是这样的,它会将所有在Redis服务器执行的命令进行输出,通常来讲Redis服务器的QPS是很高的,也就是如果执行了monitor命令,Redis服务器在Monitor这个客户端的输出缓冲区又会有大量“存货”,也就占用了大量Redis内存。

 

四、紧急处理和解决方法

进行主从切换(主从内存使用量不一致),也就是redis-cluster的fail-over操作,继续观察新的Master是否有异常,通过观察未出现异常。

查找到真正的原因后,也就是monitor,关闭掉monitor命令的进程后,内存很快就降下来了。

 

五、 预防办法:

1. 为什么会有monitor这个命令发生,我想原因有两个:

(1). 工程师想看看究竟有哪些命令在执行,就用了monitor

(2). 工程师对于redis学习的目的,因为进行了redis的托管,工程师只要会用redis就可以了,但是作为技术人员都有学习的好奇心和欲望。

2. 预防方法:

(1) 对工程师培训,讲一讲redis使用过程中的坑和禁忌

(2) 对redis云进行介绍,甚至可以让有兴趣的同学参与进来

(3) 针对client做限制,但是官方也不建议这么做,官方的默认配置中对于输出缓冲区没有限制。

Java代码 

client-output-buffer-limit normal 0 0 0  

(4) 密码:redis的密码功能较弱,同时多了一次IO

(5) 修改客户端源代码,禁止掉一些危险的命令(shutdown,flushall, monitor, keys *),当然还是可以通过redis-cli来完成

(6) 添加command-rename配置,将一些危险的命令(flushall, monitor, keys * , flushdb)做rename,如果有需要的话,找到redis的运维人员处理

Java代码 

rename-command FLUSHALL "随机数"  

rename-command FLUSHDB"随机数"  

rename-command KEYS"随机数"  

 

六、模拟实验:

1.  开启一个空的Redis(最简,直接redis-server)

Java代码 

redis-server  

初始化内存使用量如下:

Java代码 

# Memory  

used_memory:815072  

used_memory_human:795.97K  

used_memory_rss:7946240  

used_memory_peak:815912  

used_memory_peak_human:796.79K  

used_memory_lua:36864  

mem_fragmentation_ratio:9.75  

mem_allocator:jemalloc-3.6.0  

    client缓冲区:

Java代码 

# Clients  

connected_clients:1  

client_longest_output_list:0  

client_biggest_input_buf:0  

blocked_clients:0  

2. 开启一个monitor:

Java代码 

redis-cli -h 127.0.0.1 -p 6379 monitor  

3. 使用redis-benchmark:

Java代码 

redis-benchmark -h 127.0.0.1 -p 6379 -c 500 -n 200000  

4. 观察

(1) info memory:内存一直增加,直到benchmark结束,monitor输出完毕,但是used_memory_peak_human(历史峰值)依然很高--观察附件中日志

(2)info clients: client_longest_output_list: 一直在增加,直到benchmark结束,monitor输出完毕,才变为0--观察附件中日志

(3)redis-cli -h host -p port client list | grep "monitor" omem一直很高,直到benchmark结束,monitor输出完毕,才变为0--观察附件中日志

监控脚本:

Java代码 

while [ 1 == 1 ]  

do  

now=$(date"+%Y-%m-%d_%H:%M:%S")  

echo"=========================${now}==============================="  

echo" #Client-Monitor"  

redis-cli -h127.0.0.1 -p 6379 client list | grep monitor  

redis-cli -h127.0.0.1 -p 6379 info clients  

redis-cli -h127.0.0.1 -p 6379 info memory  

#休息100毫秒  

usleep100000  

done  

完整的日志文件:

http://dl.iteye.com/topics/download/096f5da0-4318-332e-914f-6f7c7298ddc9

四、redis内存使用优化 

一、背景: 选择合适的使用场景

   很多时候Redis被误解并乱用了,造成的Redis印象:耗内存、价格成本很高:

   1. 为了“赶时髦”或者对于Mysql的“误解”在一个并发量很低的系统使用Redis,将原来放在Mysql数据全部放在Redis中。

     ----(Redis比较适用于高并发系统,如果是一些复杂Mis系统,用Redis反而麻烦,因为单从功能讲Mysql要更为强大,而且Mysql的性能其实已经足够了。)

   2. 觉得Redis就是个KV缓存

     -----(Redis支持多数据结构,并且具有很多其他丰富的功能)

   3. 喜欢做各种对比,比如Mysql, Hbase, Redis等等

    -----(每种数据库都有自己的使用场景,比如Hbase吧,我们系统的个性化数据有1T,此时放在Redis根本就不合适,而是将一些热点数据放在Redis)

    总之就是在合适的场景,选择合适的数据库产品。

  附赠两个名言:

Evan Weaver, Twitter, March 2009 写道

Everything runs from memory in Web 2.0!

Tim Gray 写道

Tape is Dead, Disk is Tape, Flash is Disk, RAM Locality is king.

(磁带已死,磁盘是新磁带,闪存是新磁盘,随机存储器局部性是为王道)

 

二、一次string转化为hash的优化

1. 场景:

    用户id: userId,

    用户微博数量:weiboCount    

userId(用户id)weiboCount(微博数)

12000

210

3288

.......

10000001000

 

2. 实现方法:

(1) 使用Redis字符串数据结构, userId为key, weiboCount作为Value

(2) 使用Redis哈希结构,hashkey只有一个, key="allUserWeiboCount",field=userId,fieldValue= weiboCount

(3) 使用Redis哈希结构,  hashkey为多个, key=userId/100, field=userId%100, fieldValue= weiboCount

前两种比较容易理解,第三种方案解释一下:每个hashKey存放100个hash-kv,field=userId%100,也就是

userIdhashKeyfield

101

202

303

..........

99099

10010

10111

..........

99999999

10000010000

 

3. 获取方法:

 

Java代码 

#获取userId=5003用户的微博数  

(1) get 5003  

(2) hget allUserWeiboCount 5003  

(3) hget 50 3  

 

 

4. 内存占用量对比(100万用户 userId:1~1000000) 

 

Java代码 

#方法一 Memory  

used_memory:85999592  

used_memory_human:82.02M  

used_memory_rss:96043008  

used_memory_peak:85999592  

used_memory_peak_human:82.02M  

used_memory_lua:36864  

mem_fragmentation_ratio:1.12  

mem_allocator:jemalloc-3.6.0  

 

#方法二 Memory  

used_memory:101665632  

used_memory_human:96.96M  

used_memory_rss:110702592  

used_memory_peak:101665632  

used_memory_peak_human:96.96M  

used_memory_lua:36864  

mem_fragmentation_ratio:1.09  

mem_allocator:jemalloc-3.6.0  

 

 

#方法三 Memory  

used_memory:9574136  

used_memory_human:9.13M  

used_memory_rss:17285120  

used_memory_peak:101665632  

used_memory_peak_human:96.96M  

used_memory_lua:36864  

mem_fragmentation_ratio:1.81  

mem_allocator:jemalloc-3.6.0  

 

  内存使用量:

5. 导入数据代码(不考虑代码优雅性,单纯为了测试,勿喷)

 

Java代码 

package com.carlosfu.redis;  

 

import java.util.ArrayList;  

import java.util.HashMap;  

import java.util.List;  

import java.util.Map;  

import java.util.Random;  

 

import org.junit.Test;  

 

import redis.clients.jedis.Jedis;  

 

/**

 * 一次string-hash优化

 * @author carlosfu

 * @Date 2015-11-8

 * @Time 下午7:27:45

 */  

public class TestRedisMemoryOptimize {  

 

private final static int TOTAL_USER_COUNT = 1000000;  

 

/**

     * 纯字符串

     */  

@Test  

public void testString() {  

Jedis jedis =null;  

try {  

jedis =new Jedis("127.0.0.1", 6379);  

List kvsList =new ArrayList(200);  

for (int i = 1; i <= TOTAL_USER_COUNT; i++) {  

                String userId = String.valueOf(i);  

                kvsList.add(userId);  

String weiboCount = String.valueOf(new Random().nextInt(100000));  

                kvsList.add(weiboCount);  

if (i % 2000 == 0) {  

                    System.out.println(i);  

jedis.mset(kvsList.toArray(new String[kvsList.size()]));  

kvsList =new ArrayList(200);  

                }  

            }  

}catch (Exception e) {  

            e.printStackTrace();  

}finally {  

if (jedis != null) {  

                jedis.close();  

            }  

        }  

    }  

 

 

 

/**

     * 纯hash

     */  

@Test  

public void testHash() {  

String hashKey ="allUserWeiboCount";  

 

Jedis jedis =null;  

try {  

jedis =new Jedis("127.0.0.1", 6379);  

Map kvMap =new HashMap();  

for (int i = 1; i <= TOTAL_USER_COUNT; i++) {  

                String userId = String.valueOf(i);  

String weiboCount = String.valueOf(new Random().nextInt(100000));  

                kvMap.put(userId, weiboCount);  

if (i % 2000 == 0) {  

                    System.out.println(i);  

                    jedis.hmset(hashKey, kvMap);  

kvMap =new HashMap();  

                }  

            }  

}catch (Exception e) {  

            e.printStackTrace();  

}finally {  

if (jedis != null) {  

                jedis.close();  

            }  

        }  

    }  

 

/**

     * segment hash

     */  

@Test  

public void testSegmentHash() {  

int segment = 100;  

Jedis jedis =null;  

try {  

jedis =new Jedis("127.0.0.1", 6379);  

Map kvMap =new HashMap();  

for (int i = 1; i <= TOTAL_USER_COUNT; i++) {  

                String userId = String.valueOf(i % segment);  

String weiboCount = String.valueOf(new Random().nextInt(100000));  

                kvMap.put(userId, weiboCount);  

if (i % segment == 0) {  

                    System.out.println(i);  

int hash = (i-1) / segment;  

                    jedis.hmset(String.valueOf(hash), kvMap);  

kvMap =new HashMap();  

                }  

            }  

}catch (Exception e) {  

            e.printStackTrace();  

}finally {  

if (jedis != null) {  

                jedis.close();  

            }  

        }  

    }  

 

}  

 

 

三、结果对比

 redis核心对象 数据类型 + 编码方式 + ptr  分段hash也不会造成drift

方案优点缺点

string直观、容易理解内存占用较大

key值分散、不变于计算整体

hash直观、容易理解、整合整体内存占用大

一个key占用过大内存,如果是redis-cluster会出 现data drift

 

segment-hash内存占用量小,虽然理解不够直观,但是总体上是最优的。理解不够直观。

 

四、结论:

   在使用Redis时,要选择合理的数据结构解决实际问题,那样既可以提高效率又可以节省内存。所以此次优化方案三为最佳。

 

附图一张:redis其实是一把瑞士军刀:

 

 

 

五、redis cluster遇到的一些问题 

 

由于演讲时间有限,有关Redis-Cluster,演讲者没做太多介绍,简单的介绍了一些Redis-Cluster概念作用和遇到的两个问题,我们在Redis-Cluster也有很多运维经验,将来的文章会介绍。

 

但是讲演者反复强调,不要听信网上对于Redis-Cluster的毁谤(实践出真知),对于这一点我很赞同,我们从Redis-Cluster beta版 RC1~4 到现在的3.0-release均没有遇到什么大问题(线上维护600个实例)。

 

一、Redis-Cluster

有关Redis-Cluster的详细介绍有很多这里就不多说了,可以参考:

1.redis-cluster研究和使用

2. Redis

Cluster 3.0.5集群实践

3. 本博客的一些Redis-Cluster的介绍(未更新完毕)

4. Redis设计与实现那本书(作者:黄建宏):非常的推荐看这本书。

总之Redis-Cluster是一个无中心的分布式Redis存储架构,解决了Redis高可用、可扩展等问题。

 

 

 

二、两个问题:

 

1. Redis-Cluster主从节点不要在同一个机器部署

   (1) 以我们的经验看redis实例本身基本不会挂掉,通常是机器出了问题(断电、机器故障)、甚至是机架、机柜出了问题,造成Redis挂掉。

   (2) 如果Redis-Cluster的主从都在一个机器上,那么如果这台机器挂了,主从全部挂掉,高可用就无法实现。(如果full converage=true,也就意味着整个集群挂掉)

   (3) 通常来讲一对主从所在机器:不跨机房、要跨机架、可以在一个机柜。

 

2. Redis-Cluster误判节点fail进行切换

   (1) Redis-Cluster是无中心的架构,判断节点失败是通过仲裁的方式来进行(gossip和raft),也就是大部分节点认为一个节点挂掉了,就会做fail判定。

   (2) 如果某个节点在执行比较重的操作(flushall, slaveof等等)(可能短时间redis客户端连接会阻塞(redis单线程))或者由于网络原因,造成其他节点认为它挂掉了,会做fail判定。

(3) Redis-Cluster提供了cluster-node-timeout这个参数(默认15秒),作为fail依据(如果超过15秒还是没反应,就认为是挂掉了),具体可以参考这篇文章:Redis-Cluster的FailOver失败案例分析

        以我们的经验看15秒完全够用。

 

三、未来要介绍的问题:

 

1. Redis-Cluster客户端实现Mget操作。

2.Redis-Cluster--Too many Cluster redirections异常。

3. Redis-Cluster无底洞问题解析。

4. 两个Redis-Cluster集群,meet操作问题后的恶果。

5. Redis-Cluster配置之full converage问题。

6.Redis-Cluster故障转移测试。

7. Redis-Cluster常用运维技巧。

8. Redis-Cluster一键开通。

9. Redis-Cluster客户端jedis详解。

 

四、附赠一些不错的资料:

Redis-Cluster的FailOver失败案例分析

Redis

Cluster 迁移遇到的各种坑及解决方案

Redis Cluster架构优化

Redis常见集群方案、Codis实践及与Twemproxy比较

Redis

Cluster架构优化

【运维实践】鱼与熊掌:使用redis-cluster需要注意些什么?

Docker及和Redis

Cluster的化学反应(上)By 芒果TV

Docker及和Redis

Cluster的化学反应(下)By 芒果TV

Redis

cluster使用经验——网易有道

Redis

Cluster浅析和Bada对比

互联网Redis应用场景探讨

Redis集群技术及Codis实践

谈Twitter的百TB级Redis缓存实践

Hadoop、Spark、HBase与Redis的适用性讨论

Codis作者黄东旭细说分布式Redis架构设计和踩过的那些坑们



作者:HwangZHen7
链接:https://www.jianshu.com/p/7edb3e4e13e8

STM32F103单片机驱动TM1637数码管显示模块 最近项目中需要用到数码管显示,于是买了一个TM1637芯片驱动的四位数码显示模块,现将调试过程记录一下,方便以后参考。 使用的单片机是STM32F103C8T6最小系统 使用的数码管模块是TM1637四位数码管显示模块 实际运行效果 下面先看一下TM1637和数码管连接的具体线路图 实际使用的模块没有带按键,只用了4个数码管,模块和单片机连接只需要4根线VCC、GND、CLK、DIO。芯片和单片机通信使用的是I2C总线,下面就来说一下如何... 阅读详情

相关推荐

【速通版!语义通信基础与前沿学习计划】

🧠语义通信基础与前沿学习计划

dally2的博客 1415

redis cluster 使用过程中遇见的坑

近期单位项目上了redis 集群(3主3群)。在使用遇见了一些坑。 集群中,明明有某个key(test_key),但是在调用 keys test_key 中返回的是(empty list or set),当使用 获取命令 gettest_key后,在使用 keys test_key 就能正确返回 原因: keys 返回的是当前节点 db的结果。不会去匹配其他节点的 db的数据. 当使用 get key 后,会进行重定向,转到 key 所在的节点。再次使用keys 命令时...

For_That的博客 937

【数据分析与挖掘实战】金融风控之贷款违约预测详解1(有代码和数据集)

金融风控一.题目理解1.1.题目概况1.2数据概况1.3预测指标二.数据来源三.查看数据四.分类指标计算示例4.1混淆矩阵4.2准确度4.3precision(精确度),recall(召回率),f1-score4.4P-R曲线4.5ROC曲线4.6AUC曲线4.7KS值五.数据分析5.1基本信息5.2查看数据集中特征缺失值,唯一值等5.3查看特征的数值类型有哪些,对象类型有哪些5.3.1数值连续型变量分析5.3.2非数值类别型变量分析5.3.3总结:5.4变量分布可视化5.4.1单一变量分布可视化 更新中~

m0_49263811的博客 1万+

Redis集群都有哪些坑

集群完整性检查 默认情况下,如果redis的虚拟slot没有全部分配完,那么集群不可提供服务。那么在集群故障转移期间,redis集群没法提供服务,这在有些业务场景下是没法接受的。为此我们一般将参数cluster-require-full-coverage设置为no。这样只有故障的节点负责的slot不可用。 pubsub广播 Redis集群为了实现所有的订阅的客户端都可以接收到发布的消息,但是不同的客户端可能连接的是不同的主节点,为此redis会广播所有的发布的消息到所有的节点,如果发布的消息较大,网络开销将

qq_32680371的博客 1014

ESP32IDF 通过 PCA9685控制舵机的程序bug处理

esp32 PCA9685 bug 舵机

ztvzbj的博客 728

利用Python爬虫采集京东商品评论情感分析案例(含完整代码)

在电商蓬勃发展的今天,商品评论蕴含着巨大的商业价值。本文以京东商品评论为研究对象,系统介绍如何使用Python构建一个完整的评论采集与情感分析系统。文章涵盖京东反爬机制分析、动态请求模拟、评论数据解析、中文文本预处理、基于SnowNLP和深度学习的情感极性分类、以及可视化展示等完整技术链路。所有代码均基于2025-2026年最新可用接口编写,并提供可直接运行的完整源码。全文力求详实,总字数逾八千字,适合Python数据分析从业者、电商运营人员及自然语言处理初学者参考实践。目录摘要第一章 引言。

2201_76125261的博客 88

redis cli命令

redis安装后,在src和/usr/local/bin下有几个以redis开头的可执行文件,称为redis shell,这些可执行文件可做很多事情。 可执行文件 作用 redis-server  启动redis redis-cli redis命令行工具 redis-benchmark 基准测试工具 redis-check-aof AOF持久化文件检测工具和修复工具 re...

weixin_33720956的博客 2816

【PostgreSQL教程】PostgreSQL 特别篇之 语言接口Java

本篇教程的Java程序中开始使用PostgreSQL之前,需要确保在计算机上设置了PostgreSQL JDBC和Java。您可以检查Java教程以在计算机上安装Java。现在让本篇教程检查如何设置PostgreSQL JDBC驱动程序。

No8g攻城狮的博客 1769

美团在Redis上踩过的一些坑

上上周和同事参加了360组织的互联网技术训练营第三期,美团网的DBA负责人侯军伟给大家介绍了美团网在redis上踩得一些坑,讲的都是干货和坑。     我们在运维我们的redis私有云时,也遇到了一些类似的坑:     分为5个部分:    一、周期性出现connect timeout:    1. 背景:           大部分互联网公司都会有Mysql或者Oracle的DBA...

ronon77的专栏 258

EMI辐射发射超标案例

EMI辐射发射超标案例

让你爱上电路设计 8507

图文教程本地部署开源扣子Coze Studio工作流并接入 Gemini 大模型(windows亲测) Coze Studio 本地部署、Gemini 模型接入、开源 AI 工具平台、大模型工作流搭建

本文介绍了在Windows系统本地部署开源AI工具平台Coze Studio并接入Google Gemini大模型的完整教程。主要内容包括:1) 环境准备要求(Docker等);2) 获取源码和配置Gemini模型(需API密钥);3) 通过Docker Compose部署服务;4) 浏览器访问验证。文章指出该平台适合私有化部署,支持智能体和工作流搭建,但也存在插件系统不完善等局限。最后提供了相关资源链接,为开发者实现本地AI解决方案提供了实用指南。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 2785

美团在Redis上踩过的一些坑-5

由于演讲时间有限,有关Redis-Cluster,演讲者没做太多介绍,简单的介绍了一些Redis-Cluster概念作用和遇到的两个问题,我们在Redis-Cluster也有很多运维经验,将来的文章会介绍。   但是讲演者反复强调,不要听信网上对于Redis-Cluster的毁谤(实践出真知),对于这一点我很赞同,我们从Redis-Cluster beta版 RC1~4 到现在的3.0-rel...

jiangbb8686的博客 451

基于STM32设计的掌上游戏机(运行NES游戏模拟器)详细开发过程

利用STM32单片机移植NES游戏模拟器,完成NES游戏开发,可以玩标准的NES游戏,已测试超级玛丽、魂斗罗之类的都可以正常运行。

4万+

美团在Redis上踩过的一些坑-3

一、现象:     redis-cluster某个分片内存飙升,明显比其他分片高很多,而且持续增长。并且主从的内存使用量并不一致。   二、分析可能原因:  1.  redis-cluster的bug (这个应该不存在)  2. 客户端的hash(key)有问题,造成分配不均。(redis使用的是crc16, 不会出现这么不均的情况)  3. 存在个别大的key-value: 例如一个...

jiangbb8686的博客 409

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

美团在Redis上踩过的一些坑-4

一、背景: 选择合适的使用场景    很多时候Redis被误解并乱用了,造成的Redis印象:耗内存、价格成本很高:    1. 为了“赶时髦”或者对于Mysql的“误解”在一个并发量很低的系统使用Redis,将原来放在Mysql数据全部放在Redis中。      ----(Redis比较适用于高并发系统,如果是一些复杂Mis系统,用Redis反而麻烦,因为单从功能讲Mysql要更为强大,...

jiangbb8686的博客 252

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

美团在Redis上踩过的一些坑-2

一、背景 1. AOF:     Redis的AOF机制有点类似于Mysql binlog,是Redis的提供的一种持久化方式(另一种是RDB),它会将所有的写命令按照一定频率(no, always, every seconds)写入到日志文件中,当Redis停机重启后恢复数据库。         2. AOF重写:      (1) 随着AOF文件越来越大,里面会有大部分是重复命令或...

jiangbb8686的博客 330

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

美团在Redis上踩过的一些坑-目录(本人非美团)

   转载请注明出处哈:http://carlosfu.iteye.com/blog/2254154     上上周和同事(龙哥)参加了360组织的互联网技术训练营第三期,美团网的DBA负责人侯军伟给大家介绍了美团网在redis上踩得一些坑,讲的都是干货和坑。     分为5个部分:    一、周期性出现connect timeout    二、redis bgre...

carlosfu的专栏 278

美团在Redis上踩过的一些坑-目录(本人非美团)(转)

来自:http://carlosfu.iteye.com/blog/2254154 分为5个部分: 一、周期性出现connect timeout 二、redis bgrewriteaof问题 三、redis内存占用飙升 四、redis内存使用优化 五、redis cluster遇到的一些问题 附赠PPT: (1) 本次:美团在...

weixin_30809333的博客 107
上一篇: rsync
下一篇: 新版SQL授权用户时报错 near 'IDENTIFIED BY '密码' with grant option' at line 1
hxpjava1
博客等级 码龄19年 1365粉丝 511原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值