使用sigar获取系统信息做降级熔断

序

最近在做压力测试，发现压力上来之后，服务器的cpu很容易就飙到将近100%了。这时服务器上的一些服务就有可能宕掉。虽然使用的微服务架构也使用了其他的一些降级手段，比如hystrix等，但是基于系统内存和cpu的降级措施没有。于是就想做一个基于系统内存和cpu实时信息的降级方案，一旦内存和cpu飚上来了，就走另外一套简单的业务逻辑。

引入sigar

之前从来没做过这块儿，上网查了一下，发现sigar可以获取服务器的信息。那就试试吧。
引入sigar的maven依赖。

       org.fusesource
       sigar
       1.6.4

除此之外，使用sigar还需要下载对应系统的库文件，也就是Windows系统的dll文件和linux系统的so文件。需要去官网下载。
sigar官网
下载下来解压后是这样的。

image.png

我们需要的文件在sigar-bin/lib路径下。

image.png

使用sigar

一开始想的是，在现有的微服务里面写一个定时任务，使用sigar实时获取系统的cpu和内存信息，一旦超过设定的阈值就启动降级方案。但是这样做有几个问题，一是sigar这块操作和业务逻辑毫无关系，只是单纯的获取服务器信息，把它放在现有的服务中不合适。二是每次启动服务时，cpu占用都会暂时的升高，等到服务发完就会自然降回平均值，如果因为发布导致cpu占用升高而去开启熔断降级，也不怎么合适。于是就想单独写一个jar包跑sigar程序，如果cpu或内存超过了设定的阈值，就在一个本地文件中记录一下，超出阈值时写入“over”，未超出时写入“below”。其他业务相关的服务写一个定时任务，实时读取这个本地文件。如果是over，则去开启降级方案。

编写sigar相关代码

SigarConfig

@Slf4j
@Configuration
public class SigarConfig {
    //静态代码块
    static {
        try {
            initSigar();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //初始化sigar的配置文件
    public static void initSigar() throws IOException {
        System.setProperty("org.hyperic.sigar.path", "/var/sigar/log");
    }
}

首先在lib里找到适合自己服务器系统的文件，然后上传到服务器的某个路径下。"/var/sigar/log"就是自定义的路径。文件和系统的对应关系如下图。

image.png

我这边用的是libsigar-amd64-linux.so。
网上有说，可以把所有库文件放到代码的路径下，然后在SigarConfig里写个方法去读取库文件然后通过IO输出到服务器的某个路径下。这样的好处是不用比对库文件和系统，代码中会自动选择符合当前系统的库文件。我试了下，本地Windows环境可以，但是换成linux环境，通过io操作之后，so文件会产生损坏，导致不能使用。所以还是自己上传一下吧。
然后写一个定时任务获取当前系统的CPU和内存情况的信息，我制定的是每秒执行一次。
SigarJob

@Slf4j
@Component
public class SigarJob {
    @Autowired
    BizRedisUtil bizRedisUtil;

    @Value("${addressIp.server1}")
    private String server_1;
    @Value("${addressIp.server2}")
    private String server_2;
    @Value("${addressIp.server3}")
    private String server_3;
    @Value("${addressIp.server4}")
    private String server_4;
    @Value("${addressIp.server5}")
    private String server_5;

    private static String OVER_KEY = "";
    private static final String OVER_KEY_1 = "overstep_system_1";
    private static final String OVER_KEY_2 = "overstep_system_2";
    private static final String OVER_KEY_3 = "overstep_system_3";
    private static final String OVER_KEY_4 = "overstep_system_4";
    private static final String OVER_KEY_5 = "overstep_system_5";
    private static final String PATH = "/var/sigar/flag.txt";

    @Scheduled(cron = "0/1 * * * * ?")
    public void querySystem() throws Exception {
        checkKey();
        boolean exists = bizRedisUtil.exists(OVER_KEY);
        if (!exists) {
            bizRedisUtil.set(OVER_KEY, "0");
        }
        String over = bizRedisUtil.get(OVER_KEY);
        // 1.查询当前服务器状态
        boolean flag = sigarSystem();
        if (flag) {
            // 超出设定的阈值
            overstep(over);
        } else {
            // 未超出设定的阈值
            below(over);
        }

    }

    private void checkKey() throws Exception {
        if (null == OVER_KEY || "".equals(OVER_KEY)) {
            InetAddress address = InetAddress.getLocalHost();
            String hostAddress = address.getHostAddress();
            if (hostAddress.equals(server_1)) {
                OVER_KEY = OVER_KEY_1;
            } else if (hostAddress.equals(server_2)) {
                OVER_KEY = OVER_KEY_2;
            } else if (hostAddress.equals(server_3)) {
                OVER_KEY = OVER_KEY_3;
            } else if (hostAddress.equals(server_4)) {
                OVER_KEY = OVER_KEY_4;
            } else if (hostAddress.equals(server_5)) {
                OVER_KEY = OVER_KEY_5;
            } else {
                throw new Exception("ip错误");
            }
        }
    }

    private boolean sigarSystem() throws Exception {
        Sigar sigar = new Sigar();
        Mem mem = sigar.getMem();
        double usedPercent = mem.getUsedPercent();
        CpuPerc cpuPerc = sigar.getCpuPerc();
        double combined = cpuPerc.getCombined();
//        log.info("usedPercent:" + usedPercent + ",combined:" + combined);
        if (usedPercent > 90.0 || combined > 0.5) {
            return true;
        } else {
            return false;
        }
    }

    private void overstep(String over) {
        if ("5".equals(over)) {
            // 发送通知
            write("over");
        } else {
            bizRedisUtil.incr(OVER_KEY);
        }
    }

    private void below(String over) {
        if ("0".equals(over)) {
            // 发送通知
            write("below");
        } else {
            bizRedisUtil.decr(OVER_KEY);
        }
    }

    private void write(String input) {
        FileWriter fw = null;
        try {
            File file = new File(PATH);
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdir();
            }
            file.createNewFile();
            delete(file);
//            String flag = read(PATH);
            if (input != null && !"".equals(input)) {
                fw = new FileWriter(file, true);
                fw.write(input);
                fw.flush();
            }
        } catch (Exception e) {
            log.error("SigarJob.write error", e);
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void delete(File file) {
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            fw.write("");
            fw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

先说一下sigarSystem()这个方法。mem.getUsedPercent()是获取当前系统内存的使用百分比，cpuPerc.getCombined()是获取CPU的使用百分比。sigar很强大，除此之外还有其他非常丰富的api，大家有兴趣的话可以上网查一下，这里不再赘述。
虽然是实时获取服务器系统信息，但是触发熔断的条件应该是一个时间段内，是否超过了我们设定的阈值，而不是某一个时间点。我这边是使用redis做的。定时任务每次执行时，从0开始往redis里面自增或自减插入一个值。如果超出阈值则自增，未超出阈值则自减。这样当这个值达到5的时候，就说明已经连续6秒，系统的cpu或者内存都超出了我们设定的阈值，于是去写入“over”到本地文件flag.txt。当这个值回归0，则写入“below”到flag.txt。
至于server_1和overstep_system_1这些常量，是因为在生产环境有5台服务器，所以对应了5个redis中的key。根据服务器的ip地址去区分的。
以上是sigar相关的代码，写完打包放到服务器上执行就好了

业务代码中的降级熔断

在需要熔断的服务中心加一个定时任务。

@Slf4j
@Component
public class SigarJob {

    private static final String PATH = "/var/sigar/flag.txt";
    private static final String OVER = "over";

    @Scheduled(cron = "0/1 * * * * ?")
    public void querySystem() throws Exception {
        String flag = read(PATH);
//        log.error("querySystem flag:{}",flag);
        if (OVER.equals(flag)){
            SigarBaseService.setSigarFlag(true);
        }else {
            SigarBaseService.setSigarFlag(false);
        }
    }

    private String read(String path){
        BufferedReader br = null;
        StringBuffer stringBuffer = new StringBuffer();
        try {
            br = new BufferedReader(new FileReader(path));
            String s = "";
            while ((s = br.readLine()) != null){
                stringBuffer.append(s);
            }
        }catch (Exception e){
            log.error("SigarJob.read error", e);
        }finally {
            try {
                if (br != null){
                    br.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return stringBuffer.toString();
    }

}

定时任务每秒执行，读取flag.txt文件。根据读取出来的结果，修改SigarBaseService中的变量的值。

@Service
public class SigarBaseService {
    public static boolean SIGAR_FLAG = false;

    public static boolean isSigarFlag() {
        return SIGAR_FLAG;
    }

    public static void setSigarFlag(boolean sigarFlag) {
        SIGAR_FLAG = sigarFlag;
    }
}

这样在具体的业务代码中，就可以根据SigarBaseService.SIGAR_FLAG的值，去判断是否进行降级处理了。

if (SigarBaseService.SIGAR_FLAG){
    // 降级逻辑     
 }else {
    // 正常逻辑
 }

总结

整个逻辑比较简单。
使用sigar时要在每台服务器上都上传系统对应的库文件，如果服务器多了就比较麻烦。所以除了sigar之外，还可以使用oshi获取服务器的信息，而且只需要引入maven依赖即可，无需上传库文件。但是oshi的api感觉不如sigar丰富，要计算CPU和内存占用百分比还需要自己计算，各有利弊吧。