精华内容
下载资源
问答
  • 2022-02-28 09:51:58

    Linux** 网卡流量限制**

    简介

    我们线上用的云服务器,机器都接入了同一个共享带宽,某些机器偶尔会产生上下行的异常流量,导致影响整体的线上流量使用情况,这时候就需要做相关限制

    网卡限制

    限制工具(wondershaper)

    该工具主要用于限制某单个网卡的上下行流量,比如centos6系统里的eth0

    Wondershaper安装

    执行:git clone https://github.com/magnific0/wondershaper.git(https://github.com/magnific0/wondershaper.git)拉取项目代码,再执行:cd wondershaper

    Wondershaper使用
    • 使用(wondershaper -a 网卡名 -u 上行速率 -d 下行速率)来限制,例如:./wondershaper -a eth0 -u 1024 -d 1024,这样就将网卡上下行速率限制到1m了
    • 成功后会多出ifb0网卡
      在这里插入图片描述
    • 使用(wondershaper -a 网卡名 -s)查看限速状态,例如wondershaper -a eth0 –s
    • 使用(wondershaper -a 网卡名 -c)解除限速,例如wondershaper -a eth0 -c

    如果觉得该文章对你有帮助的话请给我点个👍吧,感谢

    更多相关内容
  • Sentinel限流实战

    千次阅读 2019-10-16 10:26:54
    一,应用场景:开放平台提供url给第三方调用时,针对调用方请求进行限流,实现对ip和参数进行限流 两种实现方式 1,对SentinelGatewayBlockExceptionHandler进行改造,新创建一个该类,重写里面的返回方法 可参考...

    一,应用场景:开放平台提供url给第三方调用时,针对调用方请求进行限流,实现对ip和参数进行限流

    两种实现方式

    1,对SentinelGatewayBlockExceptionHandler进行改造,新创建一个该类,重写里面的返回方法

    可参考:http://www.cppcns.com/ruanjian/java/257764.html

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        // Register the block exception handler for Spring Cloud Gateway.
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    2,平台实现,自定义响应处理类,实现BlockRequestHandler接口,包装返回信息,初始化调用自定义响应处理类

    参考:https://blog.csdn.net/developlee/article/details/100987345

    您可以在 GatewayCallbackManager 注册回调进行定制:

    • setBlockHandler:注册函数用于实现自定义的逻辑处理被限流的请求,对应接口为 BlockRequestHandler。默认实现为 DefaultBlockRequestHandler,当被限流时会返回类似于下面的错误信息:Blocked by Sentinel: FlowException

    二,代码实现,改造SentinelGatewayBlockExceptionHandler

    1,Sentinel配置类

    /**
     * sentinel配置
     *
     * @author lr
     * @date 2019-09-12 13:31
     */
    @Configuration
    public class SentinelGatewayConfiguration {
    
        @Autowired
        private InetUtils inetUtils;
    
        private final List<ViewResolver> viewResolvers;
        private final ServerCodecConfigurer serverCodecConfigurer;
    
        public SentinelGatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                            ServerCodecConfigurer serverCodecConfigurer) {
            this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
            this.serverCodecConfigurer = serverCodecConfigurer;
        }
    
    //    @Bean
    //    @Order(Ordered.HIGHEST_PRECEDENCE)
    //    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
    //        // Register the block exception handler for Spring Cloud Gateway.
    //        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    //    }
    
        /**
         * 自定义响应参数
         *
         * @return
         */
        @Bean
        @Order(Ordered.HIGHEST_PRECEDENCE)
        public JsonSentinelGatewayBlockExceptionHandler jsonSentinelGatewayBlockExceptionHandler() {
            return new JsonSentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
        }
    
        @Bean
        @Order(-1)
        public GlobalFilter sentinelGatewayFilter() {
            return new SentinelGatewayFilter();
        }
    
        @PostConstruct
        public void doInit() {
            initGatewayRules();
            //GatewayCallbackManager.setBlockHandler(new OpenBlockRequestHandler());
            //设置监控ip(多网卡时默认获取有问题,所以需要采用springCloud网卡工具类)
            SentinelConfig.setConfig(TransportConfig.HEARTBEAT_CLIENT_IP, inetUtils.findFirstNonLoopbackAddress().getHostAddress());
        }
    
        /**
         * 初始化路由规则
         */
        private void initGatewayRules() {
            Set<GatewayFlowRule> rules = new HashSet<>();
    
            //限制每个ip每秒只能调用5次,
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_CLIENT_IP)
                    )
            );
    
            //限制一个应用appId每秒只能调用5次
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM)
                            .setFieldName("appId")
                    )
            );
    
            //限制一个应用appId每秒只能调用5次
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM)
                            .setFieldName("appId").setPattern("testApp")
                    )
            );
    
            GatewayRuleManager.loadRules(rules);
        }
    }
    

    2,自定义响应类

    public class JsonSentinelGatewayBlockExceptionHandler implements WebExceptionHandler {
    
        private List<ViewResolver> viewResolvers;
        private List<HttpMessageWriter<?>> messageWriters;
        private final Supplier<ServerResponse.Context> contextSupplier = () -> {
            return new ServerResponse.Context() {
                public List<HttpMessageWriter<?>> messageWriters() {
                    return JsonSentinelGatewayBlockExceptionHandler.this.messageWriters;
                }
    
                public List<ViewResolver> viewResolvers() {
                    return JsonSentinelGatewayBlockExceptionHandler.this.viewResolvers;
                }
            };
        };
    
        public JsonSentinelGatewayBlockExceptionHandler(List<ViewResolver> viewResolvers, ServerCodecConfigurer serverCodecConfigurer) {
            this.viewResolvers = viewResolvers;
            this.messageWriters = serverCodecConfigurer.getWriters();
        }
    
        private Mono<Void> writeResponse(ServerResponse response, ServerWebExchange exchange) {
            ServerHttpResponse serverHttpResponse = exchange.getResponse();
            serverHttpResponse.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
            JSONObject responseObj = new JSONObject();
            responseObj.put("code", 403);
            responseObj.put("msg", "请求过于频繁,请稍后重试");
            byte[] datas = responseObj.toString().getBytes(StandardCharsets.UTF_8);
            DataBuffer buffer = serverHttpResponse.bufferFactory().wrap(datas);
            return serverHttpResponse.writeWith(Mono.just(buffer));
        }
    
        public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
            if (exchange.getResponse().isCommitted()) {
                return Mono.error(ex);
            } else {
                return !BlockException.isBlockException(ex) ? Mono.error(ex) : this.handleBlockedRequest(exchange, ex).flatMap((response) -> {
                    return this.writeResponse(response, exchange);
                });
            }
        }
    
        private Mono<ServerResponse> handleBlockedRequest(ServerWebExchange exchange, Throwable throwable) {
            return GatewayCallbackManager.getBlockHandler().handleRequest(exchange, throwable);
        }
    
    }
    

     三,代码实现,GatewayCallbackManager回调

    1,Sentinel配置类

    /**
     * sentinel配置
     *
     * @author lr
     * @date 2019-09-12 13:31
     */
    @Configuration
    public class SentinelGatewayConfiguration {
    
        @Autowired
        private InetUtils inetUtils;
    
        private final List<ViewResolver> viewResolvers;
        private final ServerCodecConfigurer serverCodecConfigurer;
    
        public SentinelGatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                            ServerCodecConfigurer serverCodecConfigurer) {
            this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
            this.serverCodecConfigurer = serverCodecConfigurer;
        }
    
        @Bean
        @Order(Ordered.HIGHEST_PRECEDENCE)
        public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
            // Register the block exception handler for Spring Cloud Gateway.
            return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
        }
    
        /**
         * 自定义响应参数
         *
         * @return
         */
    //    @Bean
    //    @Order(Ordered.HIGHEST_PRECEDENCE)
    //    public JsonSentinelGatewayBlockExceptionHandler jsonSentinelGatewayBlockExceptionHandler() {
    //        return new JsonSentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    //    }
    
        @Bean
        @Order(-1)
        public GlobalFilter sentinelGatewayFilter() {
            return new SentinelGatewayFilter();
        }
    
        @PostConstruct
        public void doInit() {
            initGatewayRules();
            GatewayCallbackManager.setBlockHandler(new OpenBlockRequestHandler());
            //设置监控ip(多网卡时默认获取有问题,所以需要采用springCloud网卡工具类)
            SentinelConfig.setConfig(TransportConfig.HEARTBEAT_CLIENT_IP, inetUtils.findFirstNonLoopbackAddress().getHostAddress());
        }
    
        /**
         * 初始化路由规则
         */
        private void initGatewayRules() {
            Set<GatewayFlowRule> rules = new HashSet<>();
    
            //限制每个ip每秒只能调用5次,
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_CLIENT_IP)
                    )
            );
    
            //限制一个应用appId每秒只能调用5次
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM)
                            .setFieldName("appId")
                    )
            );
    
            //限制一个应用appId每秒只能调用5次
            //setBurst突发请求额外增加5个
            rules.add(new GatewayFlowRule("open_gateway")
                    .setCount(5)
                    .setIntervalSec(1)
                    .setBurst(5)
                    .setParamItem(new GatewayParamFlowItem()
                            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM)
                            .setFieldName("appId").setPattern("testApp")
                    )
            );
    
            GatewayRuleManager.loadRules(rules);
        }
    }
    

    2,自定义响应消息类

    /**
     * @author lr
     * @date 2019-09-12 15:15
     */
    public class OpenBlockRequestHandler implements BlockRequestHandler {
    
        @Override
        public Mono<ServerResponse> handleRequest(ServerWebExchange exchange, Throwable ex) {
            // JSON result by default.
            return ServerResponse.status(HttpStatus.OK)
                    .contentType(MediaType.APPLICATION_JSON_UTF8)
                    .body(fromObject(buildErrorResult(ex)));
        }
    
    
        private ResponseBean buildErrorResult(Throwable ex) {
            return ResponseBeanUtils.getResponseBean(ErrorCode.REQUEST_QPS_LIMIT_ERROR);
        }
    }

    四,postman调用结果

     

    展开全文
  • Linux 端口限流(tc + iptables)

    千次阅读 2019-10-30 23:12:02
    报文分组从输入网卡(入口)接收进来,经过路由的查找, 以确定是发给本机的,还是需要转发的。如果是发给本机的,就直接向上递交给上层的协议,比如TCP,如果是转发的, 则会从输出网卡(出口)发出。网络流量的控制...

    一、相关概念

    报文分组从输入网卡(入口)接收进来,经过路由的查找, 以确定是发给本机的,还是需要转发的。如果是发给本机的,就直接向上递交给上层的协议,比如TCP,如果是转发的, 则会从输出网卡(出口)发出。网络流量的控制通常发生在输出网卡处。虽然在路由器的入口处也可以进行流量控制,Linux也具有相关的功能, 但一般说来, 由于我们无法控制自己网络之外的设备, 入口处的流量控制相对较难。本文将集中介绍出口处的流量控制。流量控制的一个基本概念是队列(Qdisc),每个网卡都与一个队列(Qdisc)相联系, 每当内核需要将报文分组从网卡发送出去, 都会首先将该报文分组添加到该网卡所配置的队列中, 由该队列决定报文分组的发送顺序。
    因此可以说,所有的流量控制都发生在队列中,详细流程图见下图。
    在这里插入图片描述
    有些队列的功能是非常简单的, 它们对报文分组实行先来先走的策略。有些队列则功能复杂,会将不同的报文分组进行排队、分类,并根据不同的原则, 以不同的顺序发送队列中的报文分组。为实现这样的功能,这些复杂的队列需要使用不同的过滤器(Filter)来把报文分组分成不同的类别(Class)。这里把这些复杂的队列称为可分类(ClassfuI)的队列。通常, 要实现功能强大的流量控制, 可分类的队列是必不可少的。因此,类别(class)和过滤器(Filter)也是流量控制的另外两个重要的基本概念。图2所示的是一个可分类队列的例子。
    在这里插入图片描述

    二、端口限流(TC和IPTABLES)

    在Linux中,流量控制都是通过TC这个工具来完成的,但是如果对端口限流需要使用IPTABLES对端口绑定TC队列。通常, 要对网卡端口进行流量控制的配置,需要进行如下的步骤:

    • 为网卡配置一个队列;
    • 在该队列上建立分类;
    • 根据需要建立子队列和子分类;
    • 为每个分类建立过滤器;
    • 使用iptables对端口绑定tc队列。

    接下来具体为80,22端口设置限流:

    1.使用命令ifconfig查看服务器上的网卡信息,比如网卡eth0是用来对外的网络,也就是用户通过该网卡连接到系统,那么我们就对这个网卡进行带宽限制。

    ifconfig

    2.建立eth0队列

    tc qdisc add dev eth0 root handle 1: htb default 20
    命令解释:
    add :表示要添加,
    dev eth0 :表示要操作的网卡为eth0,
    root :表示为网卡eth0添加的是一个根队列,
    handle 1: 表示队列的句柄为1:,
    htb :表示要添加的队列为HTB队列。
    default 20: 是htb特有的队列参数,意思是所有未分类的流量都将分配给类别1:20。

    3.建立根分类

    tc class add dev eth0 parent 1:0 classid 1:1 htb rate 3Mbit
    命令解释:
    在队列1:0上创建根分类1:1 限速,类别htb,限速3Mbit。
    rate 3Mbit:表示系统将为该类别确保3Mbit的带宽。

    4.创建分类

    tc class add dev eth0 parent 1:1 classid 1:11 htb rate 2Mbit ceil 3Mbit
    命令解释:
    以根分类1:1为父类创建分类1:11 ,限速 2Mbit ~3Mbit(htb可借用其它类带宽)。
    ceil 3Mbit:表示该类别的最高可占用带宽为3mbit。

    5.创建过滤器并制定handle

    tc filter add dev eth0 parent 1:0 prio 1 protocol ip handle 11 fw flowid 1:11
    prio 1:您可以设置额外的带宽优先级,prio数值越低优先级越高。
    protocol ip:表示该过滤器应该检查报文分组的协议字段。
    flowid 1:11: 表示将把该数据流分配给类别1:11。

    6.使用iptable对端口绑定tc队列

    iptables -A OUTPUT -t mangle -p tcp --sport 80 -j MARK --set-mark 11
    iptables -A OUTPUT -t mangle -p tcp --sport 22 -j MARK --set-mark 11

    三、查看和删除规则

    1.列出TC队列

    tc -s qdisc ls dev eth0

    2.删除TC队列

    tc qdisc del dev eth0 root

    3.删除iptables的mangle表

    单纯的删除TC队列,在下次再次设置的时候,原有的mangle表规则仍会生效,所以如果想重新设置整个限流规则应该同时删除TC队列和mangle表。

    列出mangle规则并分配编号:
    iptables -L -t mangle --line-numbers
    根据编号删除规则(x为规则编号):
    iptables -t mangle -D POSTROUTING x

    参考文章:

    Linux tc QOS 详解
    Linux上的TC流量控制几个例子(80端口流量限制)
    LINUX中IPTABLES和TC对端口的带宽限制 端口限速

    展开全文
  • SpringBoot+Redis实现接口限流

    千次阅读 2022-03-15 11:56:21
    //关于key的生成规则可以自己定义 本项目需求是对每个方法都加上限流功能,如果你只是针对ip地址限流,那么key只需要只用ip就好 String key = SystemUtil.getClientIp(httpServletRequest) + hm.getMethod()....

    思路分析

    • 想要实现用户对接口访问的限制,就要考虑实现功能的两个维度:
    1. 固定时间、
    2. 固定访问次数
    • 实现功能的具体方法:
    1. redis设置key过期时间的方法–>expire key seconds
    2. redis设置键的数字值递增的方法–>incr key
      那么我们可以用请求用户的ip这一唯一标识作为redis的key,通过increment方法实现访问次数的记录

    代码实现

    • 访问控制注解类(AcessLimit.java)
    @Retention(RUNTIME)
    @Target(METHOD)//用在方法上的注解
    public @interface AccessLimit {
        int seconds();
        int maxCount();
    }
    
    • 拦截器(MyInterceptor.java)
      控制访问接口频率的业务逻辑主要靠拦截器实现
    @Slf4j
    public class MyInterceptor implements HandlerInterceptor {
        @Resource
        RedisService redisService;
    
        @Override
        public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
            System.out.println("request=====>"+httpServletRequest);
            System.out.println("response=====>"+httpServletResponse);
            System.out.println("handler=====>"+handler);
            //如果请求输入方法
            if (handler instanceof HandlerMethod) {
                HandlerMethod hm = (HandlerMethod) handler;
                //获取方法中的注解,看是否有该注解
                AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);
                if (accessLimit != null) {
                    long seconds = accessLimit.seconds();
                    int maxCount = accessLimit.maxCount();
                    //关于key的生成规则可以自己定义 本项目需求是对每个方法都加上限流功能,如果你只是针对ip地址限流,那么key只需要只用ip就好
                    String key = SystemUtil.getClientIp(httpServletRequest) + hm.getMethod().getName();
    
                    //从redis中获取用户访问的次数
                    try {
                        long q = redisService.incr(key, seconds);//此操作代表获取该key对应的值自增1后的结果
                        //在限定的时间内访问超过限制次数 报请求频繁错误
                        if (q > maxCount) {
                            //加1
                            render(httpServletResponse, new ResponseMsg(0, "请求过于频繁,请稍候再试", null)); //这里的CodeMsg是一个返回参数
                            return false;
                        }
                        return true;
                    } catch (RedisConnectionFailureException e) {
                        log.info("redis错误" + e.getMessage().toString());
                        return true;
                    }
                }
            }
            return false;
        }
    
        private void render(HttpServletResponse response, ResponseMsg cm) throws Exception {
            response.setContentType("application/json;charset=UTF-8");
            OutputStream out = response.getOutputStream();
            String str = new Gson().toJson(cm);
            out.write(str.getBytes("UTF-8"));
            out.flush();
            out.close();
        }
    }
    
    • 拦截器注册(MyWebConfig.java)
      当然,有了拦截器还得注册进web中,否则无法生效
    @SpringBootConfiguration
    public class MyWebConfig implements WebMvcConfigurer {
        @Bean
        public MyInterceptor getMyInterceptor(){
            return new MyInterceptor();
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(getMyInterceptor()).addPathPatterns("/**");
        }
    }
    
    • 操作redis的服务层(RedisServiceImpl.java)
      • 接口
    public interface RedisService {
        boolean set(String key, String value);
        String get(String key);
        boolean expire(String key, long expire);
        boolean remove(String key);
        Long incr(String key,long time);
    }
    
    • .
      • 实现
    @Service
    public class RedisServiceImpl implements RedisService{
        @Resource
        private RedisTemplate<String, ?> redisTemplate;
    
    
        @Override
        public boolean set(final String key, final String value) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    connection.set(serializer.serialize(key), serializer.serialize(value));
                    return true;
                }
            });
            return result;
        }
    
        @Override
        public String get(final String key) {
            String result = redisTemplate.execute(new RedisCallback<String>() {
                @Override
                public String doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    byte[] value = connection.get(serializer.serialize(key));
                    return serializer.deserialize(value);
                }
            });
            return result;
        }
    
        @Override
        public boolean expire(final String key, long expire) {
            return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
        @Override
        public boolean remove(final String key) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    connection.del(key.getBytes());
                    return true;
                }
            });
            return result;
        }
        @Override
        public Long incr(String key,long time){//key:ip+方法 time是时间6秒
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            long count = redisTemplate.opsForValue().increment(key, 1);
            //String o = (String) redisTemplate.opsForValue().get(key);
            //System.out.println("自增后的key值" + o);
            //count=1表示某段限制时间内的第一次访问
            if (count == 1) {
                //设置有效期一分钟
                set(key,"1");
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return count;
        }
    }
    
    • 获取请求用户ip的工具类
    @RestController
    @RequestMapping
    public class LimitTestController {
        @RequestMapping("testlimit")
        //将限制接口注解加上
        @AccessLimit(seconds = 6,maxCount = 2)
        public String  testLimit(){
            System.out.println("进入方法");
            return "测试方法";
        }
    }
    
    • 最后是获取请求用户ip的工具类
    public class SystemUtil {
        public static String getClientIp(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || "unknow".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
                if (ip.equals("127.0.0.1")) {
                    //根据网卡取本机配置的IP
                    InetAddress inet = null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    ip = inet.getHostAddress();
                }
            }
            if (ip != null && ip.length() > 15) {
                if (ip.indexOf(",") > 0) {
                    ip = ip.substring(0, ip.indexOf(","));
                }
            }
            return ip;
        }
    }
    

    访问测试接口

    1. 访问http://localhost:8080/testlimit正常返回
      . 在这里插入图片描述
    2. 访问频率超过接口定义
      在这里插入图片描述
    展开全文
  • 限流算法之漏桶算法、令牌桶算法

    万次阅读 多人点赞 2017-07-11 11:03:59
    昨天CodeReview的时候看到同时使用...每个API接口都是有访问上限的,当访问频率或者并发量超过其承受范围时候,我们就必须考虑限流来保证接口的可用性或者降级可用性.即接口也需要安装上保险丝,以防止非预期的请求对系统
  • linux下简单限制网卡速度

    千次阅读 2021-05-10 07:43:25
    Linux下限制网卡的带宽,可用来模拟服务器带宽耗尽,从而测试服务器在此时的访问效果。1、安装iprouteyum -y install iproute2、限制eth0网卡的带宽为50kbit:/sbin/tc qdisc add dev eth0 root tbf rate 50kbit ...
  • Spring Cloud Gateway实现IP限流

    千次阅读 2020-07-15 09:22:27
    在高并发的系统中,往往需要在系统中做限流,一方面是为了防止大量的请求使服务器过载,导致服务不可用,另一方面是为了防止网络攻击。这节课详细探讨在 Spring Cloud Gateway 中如何实现限流 常见的限流算法 滑动...
  • 限流错误理解:使用Nginx限制连接或者请求的带宽,通过很多尝试那个带宽值本地测试不出来影响关系。 Nginx限流的对象:客户端的IP请求的并发连接数和客户端的IP每秒允许的请求数。 对于网卡而言,我们收到的请求...
  • 1、为什么要限流 拿旅游景点举个示例,每个旅游景点通常都会有最大的接待量,不可能无限制的放游客进入,比如故宫每天只卖八万张票,超过八万的游客,无法买票进入,因为如果超过八万人,景点的工作人员可能就忙不...
  • 随着计算机网络技术的飞速发展,为了满足各种应用环境和应用层次的需求,出现了许多 不同类型的网卡网卡的划分标准也因此出现了多样化,下面我们就对目前市面上主流的网卡分类情况进行一下浏览。按总线接口类型分...
  • 一种基于Linux下TC的流量控制管理架构
  • api接口限流 防止恶意刷接口

    千次阅读 2019-12-26 18:36:16
    api限流的场景 限流的需求出现在许多常见的场景中 1.秒杀活动,有人使用软件恶意刷单抢货,需要限流防止机器参与活动 2.某api被各式各样系统广泛调用,严重消耗网络、内存等资源,需要合理限流 3.淘宝获取ip所在城市...
  • 现在一般线都会有这3个无线局域网适配器,windows10用命令口ipconfig/all就会显示mac地址,这3个网卡的mac地址是相同的,如图,因为wifi现在的协议很多,n,x,ac是现在流行的型号,对应不同的无线速度。如果是安装...
  • 锐捷与虚拟机NAT联网的所谓冲突就是实体机的锐捷客户端默认不允许有多块网卡!所以关键是破解锐捷的这个限制。 步入正题,说一下如何突破锐捷自动关NAT共享办法,之前在网上看到网友的分享,这里再次提一下: ...
  • 有几种常见的网卡接口类型

    千次阅读 2021-06-17 08:17:57
    全部展开网卡最终已连接到网络,因此必须有一个接口,网络电缆才能与其他计算机网络设备连接. 不同的网络接口适用于不同的网络类型. e799bee5baa6e79fa5e98193e4b893e5b19e31333234303730之前的常用接口主要包括...
  • 背景技术:多队列网卡是一种技术,最初是用来解决网络IO QoS(quality of service)问题的,后来随着网络IO的带宽的不断提升,单核CPU不能完全满足网卡的需求,通过多队列网卡驱动的支持,对传入数据包的头文件进行...
  • 流程控制、控制、FlowControl 这个选项基本上所有网卡都会有,但是叫法会有些差别,比如Realtek网卡叫做控制,Intel网卡叫做流程控制,还有一些网卡选项干脆是英文的,叫做FlowControl,很多交换机上也有这个...
  • 【测试工具】Linux限流工具

    千次阅读 2015-03-16 23:11:02
    Linux下限制网卡的带宽,可用来模拟服务器带宽耗尽,从而测试服务器在此时的访问效果。
  • “侦破”网卡传输能力的“个”案作者:李烨楠一个平静的下午,在某监控大厅,应急召集令发出,一时间应急电话、汇报、询问声音响成一片。这是怎么了?原来某重要+系统应用交易严重超时,业务产生大量积压,无法顺利...
  • linux双网卡相同网段可以访问,跨网段有一个网卡无法访问问题 问题分析 架构描述 公司有三个网段分别为: 192.168.2.0/24 192.168.3.0/24 172.16.100.0/24 server1有两个块网卡: IP地址:192.168.2.2 gw...
  • 添加 ntuple 过滤规则: 1 2 3// 大写 U 设置规则 // 添加 ntuple 过滤规则,让目标端口80的TCP发送到RX队列2 ethtool -U eth0 flow-type tcp4 dst-port 80 action 2 注意:可以使用ntuple过滤在硬件级别丢弃特定...
  • 5G的到来无疑将加速网络虚拟化的进程,在电信领域,网络虚拟化不仅在核心网,也在网络的边缘。但是,仅仅通过软件解决...不同于传统网卡,智能网卡同时具备高性能及可编程的能力,既能处理高速的网络数据,又能...
  • 【转载】网络数据包分析 网卡Offload

    千次阅读 2017-12-19 13:53:32
    对于网络安全来说,网络传输数据包的捕获和分析是个基础工作,绿盟科技研究员在日常工作中,经常会捕获到一些大小远大于MTU值的数据包,经过分析这些大包的特性,发现和网卡的offload特性有关,本文对网卡Offload...
  • 基础知识 无线网卡的网速

    千次阅读 2020-09-19 00:18:13
    经常听到的百兆、千兆、万兆网络(这里是指网络设备的速度标准)通常交换机、路由器、WIFI设备、无线网卡、网线、光纤网卡,是这样的单位。 宽带的接入的速度10MB、20MB、50MB 、100MB、200MB 2、速率与实际传输...
  • 文章目录目录数据包从物理网卡进入虚拟机的流程物理网卡处理如何将网卡收到的数据写入到内核内存?中断下半部分软中断处理将数据包交给内核态的 OvS Bridge(Datapath)处理Linux 虚拟 “网线”(veth)的工作原理...
  • PHY 在发送数据的时候,收到MAC 过来的数据(对PHY 来说,没有帧的概念,对它来说,都是数据而不管什么地址,数据还是CRC),每4bit 就增加1bit 的检错码,然后把并行数据转化为串行数据,再按照物理层的编码规则...
  • 网关、网卡、网桥、

    千次阅读 2020-10-12 19:22:09
    由于篇幅所,就不再详述了。 如果开始看路由知识的话,就会容易明白了, 进入命令行模式: c:>route print 会有一条路由: 0.0.0.0 0.0.0.0 默认网关的IP 接口(机器的IP) 跳数 比如我的机器: 0.0.0.0 0.0.0.0 ...
  • 虚拟网卡技术-VETH、MACVLAN、IPVLAN

    千次阅读 2021-02-08 10:42:34
    Linux的网卡驱动中内含了很多“虚拟网卡”。早先的文章曾经详细分析过tun,ifb等虚拟网卡,类似的思路,在虚拟化大行其道的趋势下,Linux源码树中不断增加对“网络虚拟化”的支持,不光是为了支持“虚拟机”技术,更...
  • 最近作RTC项目,晚上边缘计算的一台宿主机由于CPU单核耗被打满,最后查到原因是网卡调优没有生效,今天查了一下网卡调优的资料,下面是关于我们公司网卡调优的相关知识,欢迎大家共同探讨。
  • 网卡 (一) 1 LAN简介

    千次阅读 2019-03-24 18:50:42
    待验证 RJ45接口,双绞线 负责传输比特 OSI参考模型与IEEE802的关系 IEEE802.3 IEEE802.3的实现 ENC28J60 和 OSI模型 网卡究竟工作在OSI的哪一层? ETH—Lwip以太网通信—零死角玩转STM32-F429系列 数据链路层...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,530
精华内容 15,012
关键字:

网卡限流