Gateway实现限流的一些常见方式_Java

gateway怎么实现限流的

在api网关（如spring cloud gateway、kong、nginx等）中实现限流是为了控制服务请求的频率，从而避免系统过载，确保稳定性和可用性。限流可以通过多种策略实现，常见的方法包括基于请求次数、时间窗口、ip地址等方式进行限制。下面是 spring cloud gateway 实现限流的一些常见方式：

1.基于请求次数的限流

这种方法通过限制单位时间内的请求次数来防止过多的请求访问服务。例如，限制每秒钟只能处理最多100个请求。

spring cloud gateway实现：spring cloud gateway提供了内置的限流功能，可以通过requestratelimiter过滤器来实现基于请求次数的限流。示例配置：

spring:
  cloud:
    gateway:
      routes:
        - id: rate_limiter_route
          uri: http://example.com
          predicates:
            - path=/api/**
          filters:
            - name: requestratelimiter
              args:
                redis-rate-limiter.replenishrate: 10  # 每秒钟请求的数量
                redis-rate-limiter.burstcapacity: 20  # 突发容量，即短时间内允许的最大请求数

replenishrate: 每秒钟允许的请求数。
burstcapacity: 突发容量，表示短时间内可以处理的最大请求数，超过该数的请求会被丢弃或拒绝。

2.基于令牌桶算法（token bucket）限流

令牌桶算法是一种平滑请求流量的算法，它通过固定的速率生成令牌并将其存放在桶中，请求到达时需要获取令牌才能处理，如果令牌桶为空，则请求被拒绝。

spring cloud gateway实现：使用requestratelimiter实现基于令牌桶的限流。

示例配置：

spring:
  cloud:
    gateway:
      routes:
        - id: token_bucket_route
          uri: http://example.com
          predicates:
            - path=/api/**
          filters:
            - name: requestratelimiter
              args:
                redis-rate-limiter.replenishrate: 10  # 每秒生成的令牌数
                redis-rate-limiter.burstcapacity: 20  # 令牌桶的容量

这里的配置和上面的请求次数限制类似，但背后实现的是令牌桶算法。

3.基于ip限流

可以根据客户端ip地址来限制每个ip的请求频率，避免某个客户端过度访问服务。通常使用redis来实现基于ip的限流。

示例配置（使用redis）：

spring:
  cloud:
    gateway:
      routes:
        - id: ip_rate_limiter_route
          uri: http://example.com
          predicates:
            - path=/api/**
          filters:
            - name: requestratelimiter
              args:
                redis-rate-limiter.replenishrate: 10
                redis-rate-limiter.burstcapacity: 20
                redis-rate-limiter.requestedtokens: 1
                redis-rate-limiter.keyresolver: "#{@ipkeyresolver}"

在这个例子中，keyresolver 指定了如何基于客户端 ip 地址来限流，可以自定义一个ip解析器ipkeyresolver，这样每个ip的请求次数会被限制。

4.基于时间窗口的限流

时间窗口限流是按照固定的时间窗口（如每分钟、每小时等）来限制请求的数量。通过时间窗口来控制单位时间内的最大请求数。

示例配置：

spring:
  cloud:
    gateway:
      routes:
        - id: time_window_route
          uri: http://example.com
          predicates:
            - path=/api/**
          filters:
            - name: requestratelimiter
              args:
                redis-rate-limiter.replenishrate: 5  # 每秒钟请求的数量
                redis-rate-limiter.burstcapacity: 10  # 突发容量
                redis-rate-limiter.requestedtokens: 1  # 每次请求消耗的令牌数

这种方式将请求限制在一定的时间窗口内，如果在窗口内的请求数量超过限制，将拒绝额外的请求。

5.自定义限流策略

spring cloud gateway 还允许通过自定义keyresolver、ratelimiter等来实现更灵活的限流策略。例如，基于用户的id、api路径等来做不同的限流策略。

自定义keyresolver示例：

@bean
public keyresolver ipkeyresolver() {
    return exchange -> mono.just(exchange.getrequest().getremoteaddress().gethoststring());
}

这个例子通过客户端ip地址进行限流。

6.其他网关限流工具

除了spring cloud gateway，其他网关如 kong、nginx 等也提供了丰富的限流功能：

kong使用插件机制实现限流，支持基于请求次数、ip、api key等的限流。
nginx可以通过limit_req和limit_conn模块来进行限流控制。

总结

在 spring cloud gateway 中，常见的限流方式包括：

基于请求次数的限流（rate limiting）
基于令牌桶算法的限流（token bucket）
基于ip的限流
基于时间窗口的限流

可以通过requestratelimiter过滤器实现这些策略，结合 redis 等存储技术来共享和持久化限流状态。在选择限流策略时，需要根据业务需求、流量模式、以及系统的负载能力来决定。

分析gateway 限流代码

 
@component
public class ratelimitconfig {
    @bean
    keyresolver userkeyresolver() {
	return exchange -> mono.just(exchange.getrequest().getqueryparams().getfirst("token"));
    }
    @bean
    keyresolver ipkeyresolver() {
	return exchange -> mono.just(exchange.getrequest().getremoteaddress().gethostname());
    }
    @bean
    keyresolver apikeyresolver() {
	return exchange -> mono.just(exchange.getrequest().getpath().value());
    }
    @primary
    @bean
    keyresolver appipkeyresolver() {
	return exchange -> {
	    route route = (route) exchange.getattributes().get(serverwebexchangeutils.gateway_route_attr);
	    return mono.just(exchange.getrequest().getremoteaddress().gethostname().concat(route.geturi().gethost()));
	};
    }
}

这段代码实现了spring cloud gateway的限流配置，具体的实现通过不同的keyresolver来为请求提供唯一的标识，用于区分不同的请求来源或策略。keyresolver是限流的核心组成部分，它决定了限流的“键”（即每个请求的唯一标识），从而确保不同的请求按照不同的规则被限流。

以下是对代码的详细分析：

1.keyresolver的作用

keyresolver 是 spring cloud gateway 中限流机制的一部分，用来生成与请求相关的唯一“键”。在限流时，基于这些“键”来计算每个限流单元（例如每个用户、每个ip、每个api等）的请求次数。限流规则会依据这些键来进行流量控制。

2.userkeyresolver

@bean keyresolver userkeyresolver() { return exchange -> mono.just(exchange.getrequest().getqueryparams().getfirst("token")); }

功能：该keyresolver基于请求的查询参数token生成唯一的限流键。
应用场景：当客户端使用token参数（可能是api key或用户身份标识符）时，可以基于该token对每个用户进行限流。每个用户（或每个token）的请求次数将被单独计数。
具体实现：从请求的查询参数中获取token参数的第一个值。如果没有这个参数，返回null或空值会导致限流功能不生效。

3.ipkeyresolver

@bean keyresolver ipkeyresolver() { return exchange -> mono.just(exchange.getrequest().getremoteaddress().gethostname()); }

功能：该keyresolver基于客户端的 ip 地址生成限流键。
应用场景：当需要限制每个ip地址的请求频率时，使用此keyresolver。例如，可以限制每个ip在一定时间窗口内的请求次数，从而避免单个ip的过多请求对系统造成压力。
具体实现：通过exchange.getrequest().getremoteaddress()获取客户端的远程ip地址，然后使用gethostname()获取ip的主机名。理论上，gethostname()会尝试解析ip地址为主机名，但在某些情况下，可能直接返回ip地址。

4.apikeyresolver

@bean keyresolver apikeyresolver() { return exchange -> mono.just(exchange.getrequest().getpath().value()); }

功能：该keyresolver基于请求的api路径生成唯一的限流键。
应用场景：当需要限制某个api路径的请求频率时，使用此keyresolver。例如，限制/api/v1/login或/api/v1/register路径的访问频率，可以防止某个特定api被过度访问。
具体实现：通过exchange.getrequest().getpath().value()获取请求的路径。这个路径通常是 uri 的路径部分，如/api/v1/resource。

5.appipkeyresolver

@primary
@bean keyresolver appipkeyresolver()
{ 
    return exchange -> 
    { 
        route route = (route) exchange.getattributes().get(serverwebexchangeutils.gateway_route_attr); return mono.just(exchange.getrequest().getremoteaddress().gethostname().concat(route.geturi().gethost())); 
    };
    }

功能：该keyresolver综合了客户端的 ip 地址和路由的 uri 来生成限流键。
应用场景：当希望根据客户端 ip 和访问的具体服务进行限流时，使用此keyresolver。例如，可以限制每个ip对特定api的访问频率。
具体实现：
- 通过exchange.getrequest().getremoteaddress().gethostname()获取客户端的 ip 地址。
- 通过exchange.getattributes().get(serverwebexchangeutils.gateway_route_attr)获取当前请求的路由信息。
- route.geturi().gethost()获取请求目标服务的主机名（或域名），并将其与客户端ip拼接，作为限流的唯一键。
- 使用concat()方法将客户端ip与目标服务主机名合并为一个字符串，以保证限流的独立性。

6.@primary注解

@primary @bean keyresolver appipkeyresolver()
{ 
    ... 
}

作用：在有多个相同类型的@bean时，@primary注解表示优先使用该bean。如果在其他地方有keyresolver的注入需求，spring 将默认使用appipkeyresolver()方法返回的实例。
场景：当存在多个keyresolver时，如果没有明确指定使用哪个keyresolver，spring 会自动选择标记为@primary的那个。这里标记了appipkeyresolver为默认的keyresolver。

总结

这段代码定义了多个 keyresolver，并为不同的限流策略提供了可选择的实现：

userkeyresolver：基于请求的token限流，适用于基于用户或身份的限流。
ipkeyresolver：基于客户端 ip 地址限流，适用于限制每个ip的请求次数。
apikeyresolver：基于请求路径限流，适用于限制某个特定api的访问。
appipkeyresolver：基于客户端 ip 地址和路由的 uri 组合限流，适用于更细粒度的限流需求，确保同一ip对不同api的请求可以独立计数。

@primary 注解确保 appipkeyresolver 是默认的限流键生成器，除非特别指定，否则会优先使用它。

这些 keyresolver 会与 requestratelimiter 等限流功能配合使用，从而在 api 网关层实现精细化的限流控制。

怎么没有指定限流的量，每秒允许访问的量

在这段代码中，虽然定义了不同的 keyresolver 来生成限流的标识符（如 token、ip 或 api路径），但确实没有指定实际的限流规则（例如每秒允许的访问量）。限流的具体控制是通过 spring cloud gateway 的 requestratelimiter 过滤器来实现的，而这个过滤器是用来根据指定的规则对请求进行限流的。

要实现每秒允许的访问量，你需要配置 requestratelimiter 过滤器，并为它指定限流规则（如每秒最大访问量和最大突发流量）。

完整的限流配置示例

首先，你需要创建一个 requestratelimiter 过滤器，并在过滤器中配置限流策略。通常，你可以通过如下方式来配置：

import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.cloud.gateway.filter.ratelimit.requestratelimiter;
import org.springframework.cloud.gateway.filter.ratelimit.keyresolver;
import org.springframework.cloud.gateway.config.globalfilterautoconfiguration;
@configuration
public class gatewayconfig {
    @bean
    public requestratelimiter filter(keyresolver keyresolver) {
        // 配置限流：每秒最多允许 10 次请求，突发流量最多为 20 次
        return new requestratelimiter()
                .setratelimiter(new myratelimiter(10, 20))  // 每秒 10 次请求，突发流量最多 20 次
                .setkeyresolver(keyresolver); // 设置限流的 keyresolver
    }
    // 自定义一个简单的 ratelimiter 实现类
    public static class myratelimiter implements ratelimiter {
        private final int replenishrate;
        private final int burstcapacity;
        public myratelimiter(int replenishrate, int burstcapacity) {
            this.replenishrate = replenishrate;
            this.burstcapacity = burstcapacity;
        }
        @override
        public boolean isallowed(string key) {
            // 此处实现你自己的限流逻辑，可以借助令牌桶算法、漏桶算法等
            return true;  // 只是示例，实际需要实现限流逻辑
        }
        // 配置每秒最大请求数（每秒 10 次）
        public int getreplenishrate() {
            return replenishrate;
        }
        // 配置突发容量
        public int getburstcapacity() {
            return burstcapacity;
        }
    }
}

如何将限流规则与keyresolver配合？

在这段代码中，requestratelimiter 的限流规则（如每秒允许 10 次请求，突发容量为 20）会与之前定义的 keyresolver 配合，限制特定 token、ip 或 api 路径的访问频率。

keyresolver 选择：可以使用你之前定义的 userkeyresolver、ipkeyresolver 或 apikeyresolver 来作为限流的依据。
限流逻辑：通过 myratelimiter 类实现限流逻辑（如令牌桶、漏桶等算法）。每个限流的“key”（例如 token 或 ip）会根据配置的规则（如每秒 10 次、突发流量 20 次）进行访问次数的限制。

示例配置：按token限流

假设你想基于 token 进行限流，你可以这样配置：

@bean
public requestratelimiter filter(keyresolver userkeyresolver) {
    return new requestratelimiter()
            .setratelimiter(new myratelimiter(10, 20))  // 每秒 10 次请求，突发流量最多 20 次
            .setkeyresolver(userkeyresolver);  // 使用之前定义的基于 token 的 keyresolver
}

限流的配置项

replenishrate：每秒允许的请求数。例如，10 表示每秒最多可以处理 10 个请求。
burstcapacity：突发容量，表示在短时间内可以允许的最大请求数。例如，20 表示最多允许瞬间访问 20 次，但通常会平滑地恢复到正常的请求速率。
keyresolver：你已经定义了多个 keyresolver，它们决定了限流的粒度。你可以按用户（token）、ip 地址、路径等来分别限流。

总结

这段代码本身只是定义了限流的标识符（通过 keyresolver）。真正的限流控制需要通过 requestratelimiter 过滤器来实现，并在其中指定限流的具体限制量（如每秒允许多少次请求）。你可以使用 replenishrate 和 burstcapacity 来配置每秒允许的访问量及突发流量。

到此这篇关于gateway实现限流的一些常见方式的文章就介绍到这了,更多相关gateway限流内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！