工作中最常用的6种API网关

前言

API网关在项目中非常重要。
今天这篇文章跟大家一起聊聊工作最常用的6种网关，希望对你会有所帮助。
一、为什么需要API网关？

有些小伙伴在工作中可能会问：我们的系统直接调用微服务不是更简单吗？
为什么非要引入API网关这个"中间商"呢？
让我们先来看一个实际的例子。
没有网关的微服务困境

1. // 前端直接调用多个微服务 - 问题重重
2. @RestController
3. public class FrontendController {
4.    
5.     // 问题1：服务地址硬编码
6.     @Value("${user.service.url:http://localhost:8081}")
7.     private String userServiceUrl;
8.    
9.     @Value("${order.service.url:http://localhost:8082}")
10.     private String orderServiceUrl;
11.    
12.     @Autowired
13.     private RestTemplate restTemplate;
14.    
15.     @GetMapping("/user-dashboard")
16.     public UserDashboard getUserDashboard(@RequestHeader("Authorization") String token) {
17.         // 问题2：每个服务都要重复认证逻辑
18.         if (!validateToken(token)) {
19.             throw new UnauthorizedException("Token invalid");
20.         }
21.         
22.         // 问题3：需要手动处理服务间调用顺序
23.         User user = restTemplate.getForObject(userServiceUrl + "/users/current", User.class);
24.         List<Order> orders = restTemplate.getForObject(orderServiceUrl + "/orders?userId=" + user.getId(), List.class);
25.         
26.         // 问题4：错误处理复杂
27.         if (user == null || orders == null) {
28.             throw new ServiceUnavailableException("Backend service unavailable");
29.         }
30.         
31.         return new UserDashboard(user, orders);
32.     }
33.    
34.     // 问题5：重复的认证代码
35.     private boolean validateToken(String token) {
36.         // 每个接口都要实现的认证逻辑
37.         return token != null && token.startsWith("Bearer ");
38.     }
39. }

复制代码

引入网关后的优雅架构

1. // 网关统一处理所有横切关注点
2. @Configuration
3. public class GatewayConfig {
4.    
5.     @Bean
6.     public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
7.         return builder.routes()
8.             .route("user_service", r -> r.path("/api/users/**")
9.                 .uri("lb://user-service"))
10.             .route("order_service", r -> r.path("/api/orders/**")
11.                 .uri("lb://order-service"))
12.             .route("product_service", r -> r.path("/api/products/**")
13.                 .uri("lb://product-service"))
14.             .build();
15.     }
16. }
18. // 前端只需调用网关
19. @RestController
20. public class FrontendController {
21.    
22.     @Autowired
23.     private RestTemplate restTemplate;
24.    
25.     @GetMapping("/api/user-dashboard")
26.     public UserDashboard getUserDashboard() {
27.         // 网关已经处理了认证、路由、负载均衡等问题
28.         return restTemplate.getForObject("http://gateway/api/users/current/dashboard", UserDashboard.class);
29.     }
30. }

复制代码

API网关的核心价值

让我们通过架构图来理解网关在微服务架构中的关键作用：

网关解决的8大核心问题：

• 统一入口：所有请求都通过网关进入系统
  
• 认证授权：集中处理身份验证和权限控制
  
• 流量控制：限流、熔断、降级等 resiliency 模式
  
• 监控统计：统一的日志、指标收集
  
• 协议转换：HTTP/1.1、HTTP/2、gRPC 等协议适配
  
• 缓存加速：响应缓存降低后端压力
  
• 安全防护：WAF、防爬虫、防重放攻击
  
• 服务治理：服务发现、负载均衡、路由转发
  

下面我们一起看看工作中最常见的6种API网关有哪些。
二、Spring Cloud Gateway

有些小伙伴在Spring技术栈中开发微服务，Spring Cloud Gateway 无疑是最自然的选择。
作为Spring官方推出的第二代网关，它基于WebFlux响应式编程模型，性能卓越。
核心架构深度解析

1. @Configuration
2. public class AdvancedGatewayConfig {
3.    
4.     @Bean
5.     @Order(-1)
6.     public GlobalFilter customGlobalFilter() {
7.         return (exchange, chain) -> {
8.             // 前置处理
9.             long startTime = System.currentTimeMillis();
10.             ServerHttpRequest request = exchange.getRequest();
11.             
12.             // 添加追踪ID
13.             String traceId = UUID.randomUUID().toString();
14.             ServerHttpRequest mutatedRequest = request.mutate()
15.                 .header("X-Trace-Id", traceId)
16.                 .build();
17.                
18.             return chain.filter(exchange.mutate().request(mutatedRequest).build())
19.                 .then(Mono.fromRunnable(() -> {
20.                     // 后置处理
21.                     long duration = System.currentTimeMillis() - startTime;
22.                     log.info("Request {} completed in {}ms", traceId, duration);
23.                 }));
24.         };
25.     }
26.    
27.     @Bean
28.     public RouteLocator advancedRoutes(RouteLocatorBuilder builder) {
29.         return builder.routes()
30.             // 用户服务 - 带熔断和重试
31.             .route("user_service", r -> r.path("/api/users/**")
32.                 .filters(f -> f
33.                     .circuitBreaker(config -> config
34.                         .setName("userServiceCB")
35.                         .setFallbackUri("forward:/fallback/user-service"))
36.                     .retry(config -> config
37.                         .setRetries(3)
38.                         .setMethods(HttpMethod.GET, HttpMethod.POST)
39.                         .setBackoff(100L, 1000L, 2, true))
40.                     .requestRateLimiter(config -> config
41.                         .setRateLimiter(redisRateLimiter())
42.                         .setKeyResolver(apiKeyResolver()))
43.                     .modifyRequestBody(String.class, String.class,
44.                         (exchange, s) -> Mono.just(validateAndTransform(s))))
45.                 .uri("lb://user-service"))
46.             
47.             // 订单服务 - 带JWT认证
48.             .route("order_service", r -> r.path("/api/orders/**")
49.                 .filters(f -> f
50.                     .filter(jwtAuthenticationFilter())
51.                     .prefixPath("/v1")
52.                     .addResponseHeader("X-API-Version", "1.0"))
53.                 .uri("lb://order-service"))
54.             
55.             // 商品服务 - 静态资源缓存
56.             .route("product_service", r -> r.path("/api/products/**")
57.                 .filters(f -> f
58.                     .dedupeResponseHeader("Cache-Control", "RETAIN_FIRST")
59.                     .setResponseHeader("Cache-Control", "public, max-age=3600"))
60.                 .uri("lb://product-service"))
61.             .build();
62.     }
63.    
64.     @Bean
65.     public JwtAuthenticationFilter jwtAuthenticationFilter() {
66.         return new JwtAuthenticationFilter();
67.     }
68.    
69.     @Bean
70.     public RedisRateLimiter redisRateLimiter() {
71.         return new RedisRateLimiter(10, 20);
72.     }
73.    
74.     @Bean
75.     public KeyResolver apiKeyResolver() {
76.         return exchange -> {
77.             String apiKey = exchange.getRequest().getHeaders().getFirst("X-API-Key");
78.             return Mono.just(Optional.ofNullable(apiKey).orElse("anonymous"));
79.         };
80.     }
81. }
83. // JWT认证过滤器
84. @Component
85. class JwtAuthenticationFilter implements GatewayFilter {
86.    
87.     @Autowired
88.     private JwtUtil jwtUtil;
89.    
90.     @Override
91.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
92.         String token = extractToken(exchange.getRequest());
93.         
94.         if (token == null) {
95.             return onError(exchange, "Missing authentication token", HttpStatus.UNAUTHORIZED);
96.         }
97.         
98.         try {
99.             Claims claims = jwtUtil.parseToken(token);
100.             String username = claims.getSubject();
101.             
102.             // 将用户信息添加到header
103.             ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
104.                 .header("X-User-Name", username)
105.                 .header("X-User-Roles", String.join(",", claims.get("roles", List.class)))
106.                 .build();
107.                
108.             return chain.filter(exchange.mutate().request(mutatedRequest).build());
109.         } catch (Exception e) {
110.             return onError(exchange, "Invalid token: " + e.getMessage(), HttpStatus.UNAUTHORIZED);
111.         }
112.     }
113.    
114.     private String extractToken(ServerHttpRequest request) {
115.         String bearerToken = request.getHeaders().getFirst("Authorization");
116.         if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
117.             return bearerToken.substring(7);
118.         }
119.         return null;
120.     }
121.    
122.     private Mono<Void> onError(ServerWebExchange exchange, String err, HttpStatus status) {
123.         exchange.getResponse().setStatusCode(status);
124.         DataBuffer buffer = exchange.getResponse().bufferFactory()
125.             .wrap(("{"error":"" + err + ""}").getBytes());
126.         return exchange.getResponse().writeWith(Mono.just(buffer));
127.     }
128. }

复制代码

Spring Cloud Gateway 执行流程

优点：

• 与Spring Cloud生态完美集成
  
• 基于WebFlux，性能优秀
  
• 功能丰富，支持过滤器和断言
  
• 配置灵活，支持代码和配置文件两种方式
  

缺点：

• 对非Spring技术栈不友好
  
• 学习曲线相对陡峭
  
• 依赖Spring Cloud组件
  

使用场景：

• Spring Cloud微服务架构
  
• 需要深度定制网关逻辑
  
• 团队熟悉Spring技术栈
  

三、Kong：企业级API网关标杆

有些小伙伴在企业级场景中需要更高的性能和更丰富的功能，Kong就是这样一个基于Nginx和OpenResty的高性能API网关。
Kong 配置实战

1. # kong.yml - 声明式配置
2. _format_version: "2.1"
3. _transform: true
5. services:
6.   - name: user-service
7.     url: http://user-service:8080
8.     routes:
9.       - name: user-route
10.         paths: ["/api/users"]
11.         strip_path: true
12.     plugins:
13.       - name: key-auth
14.         config:
15.           key_names: ["apikey"]
16.           hide_credentials: true
17.       - name: rate-limiting
18.         config:
19.           minute: 10
20.           policy: redis
21.       - name: prometheus
22.         enabled: true
24.   - name: order-service
25.     url: http://order-service:8080
26.     routes:
27.       - name: order-route
28.         paths: ["/api/orders"]
29.         methods: ["GET", "POST", "PUT"]
30.     plugins:
31.       - name: cors
32.         config:
33.           origins: ["https://example.com"]
34.           methods: ["GET", "POST", "PUT"]
35.           headers: ["Accept", "Authorization", "Content-Type"]
36.       - name: request-transformer
37.         config:
38.           add:
39.             headers: ["X-From-Kong: true"]
40.           remove:
41.             headers: ["User-Agent"]
43. consumers:
44.   - username: mobile-app
45.     keyauth_credentials:
46.       - key: mobile-key-123
47.   - username: web-app
48.     keyauth_credentials:
49.       - key: web-key-456
51. plugins:
52.   - name: ip-restriction
53.     config:
54.       allow: ["192.168.0.0/16", "10.0.0.0/8"]
55.   - name: correlation-id
56.     config:
57.       header_name: "X-Request-ID"
58.       generator: "uuid"

复制代码

自定义Kong插件开发

1. -- kong/plugins/request-validator/handler.lua
2. local BasePlugin = require "kong.plugins.base_plugin"
3. local cjson = require "cjson"
5. local RequestValidator = BasePlugin:extend()
7. function RequestValidator:new()
8.   RequestValidator.super.new(self, "request-validator")
9. end
11. function RequestValidator:access(conf)
12.   RequestValidator.super.access(self)
13.   
14.   local headers = kong.request.get_headers()
15.   local method = kong.request.get_method()
16.   local body = kong.request.get_raw_body()
17.   
18.   -- API Key验证
19.   local api_key = headers["X-API-Key"]
20.   if not api_key then
21.     kong.response.exit(401, { message = "Missing API Key" })
22.   end
23.   
24.   -- 验证API Key格式
25.   if not string.match(api_key, "^%x%x%x%-%x%x%x%-%x%x%x$") then
26.     kong.response.exit(401, { message = "Invalid API Key format" })
27.   end
28.   
29.   -- 请求体验证
30.   if method == "POST" or method == "PUT" then
31.     if not body or body == "" then
32.       kong.response.exit(400, { message = "Request body is required" })
33.     end
34.    
35.     local ok, json_body = pcall(cjson.decode, body)
36.     if not ok then
37.       kong.response.exit(400, { message = "Invalid JSON format" })
38.     end
39.    
40.     -- 业务规则验证
41.     if json_body.amount and tonumber(json_body.amount) <= 0 then
42.       kong.response.exit(400, { message = "Amount must be greater than 0" })
43.     end
44.   end
45.   
46.   -- 添加验证通过标记
47.   kong.service.request.set_header("X-Request-Validated", "true")
48.   kong.service.request.set_header("X-API-Key", api_key)
49.   
50.   -- 记录审计日志
51.   kong.log.info("Request validated for API Key: ", api_key)
52. end
54. return RequestValidator

复制代码

优点：

• 配置热更新，无需重启
  
• 性能卓越
  
• 插件生态丰富
  
• 云原生友好
  

缺点：

• 相对较新，生态不如Kong成熟
  
• 依赖etcd
  
• 学习成本较高
  

使用场景：

• 云原生环境
  
• 需要动态配置的场景
  
• 高性能要求的微服务架构
  

六、Zuul：Netflix经典网关

有些小伙伴在传统Spring Cloud项目中可能还在使用Zuul，虽然它已被Spring Cloud Gateway取代，但了解其原理仍有价值。
Zuul 过滤器实战

1. # nginx.conf - 生产环境配置
2. http {
3.     # 基础配置
4.     sendfile on;
5.     tcp_nopush on;
6.     tcp_nodelay on;
7.     keepalive_timeout 65;
8.     types_hash_max_size 2048;
9.    
10.     # 日志格式
11.     log_format main '$remote_addr - $remote_user [$time_local] "$request" '
12.                     '$status $body_bytes_sent "$http_referer" '
13.                     '"$http_user_agent" "$http_x_forwarded_for" '
14.                     'rt=$request_time uct="$upstream_connect_time" '
15.                     'uht="$upstream_header_time" urt="$upstream_response_time"';
16.    
17.     # 上游服务配置
18.     upstream user_service {
19.         server user-service-1:8080 weight=3;
20.         server user-service-2:8080 weight=2;
21.         server user-service-3:8080 weight=1;
22.         
23.         # 健康检查
24.         check interval=3000 rise=2 fall=3 timeout=1000;
25.     }
26.    
27.     upstream order_service {
28.         server order-service-1:8080;
29.         server order-service-2:8080;
30.         
31.         # 会话保持
32.         hash $cookie_jsessionid;
33.         hash_again 1;
34.     }
35.    
36.     upstream product_service {
37.         server product-service:8080;
38.         
39.         # 备份服务器
40.         server backup-product-service:8080 backup;
41.     }
42.    
43.     # API网关配置
44.     server {
45.         listen 80;
46.         server_name api.example.com;
47.         
48.         # 全局限流
49.         limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
50.         
51.         # 用户服务路由
52.         location /api/users/ {
53.             limit_req zone=api burst=20 nodelay;
54.             
55.             # 反向代理配置
56.             proxy_pass http://user_service;
57.             proxy_set_header Host $host;
58.             proxy_set_header X-Real-IP $remote_addr;
59.             proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
60.             proxy_set_header X-Forwarded-Proto $scheme;
61.             
62.             # 超时配置
63.             proxy_connect_timeout 5s;
64.             proxy_read_timeout 10s;
65.             proxy_send_timeout 10s;
66.             
67.             # 重试机制
68.             proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
69.             proxy_next_upstream_tries 3;
70.             proxy_next_upstream_timeout 10s;
71.             
72.             # 缓存配置
73.             proxy_cache api_cache;
74.             proxy_cache_key "$scheme$request_method$host$request_uri";
75.             proxy_cache_valid 200 302 5m;
76.             proxy_cache_valid 404 1m;
77.             
78.             # 添加安全头
79.             add_header X-Frame-Options DENY;
80.             add_header X-Content-Type-Options nosniff;
81.             add_header X-XSS-Protection "1; mode=block";
82.         }
83.         
84.         # 订单服务路由
85.         location /api/orders/ {
86.             # JWT验证
87.             auth_request /auth;
88.             auth_request_set $user $upstream_http_x_user;
89.             proxy_set_header X-User $user;
90.             
91.             proxy_pass http://order_service;
92.             
93.             # CORS配置
94.             if ($request_method = 'OPTIONS') {
95.                 add_header 'Access-Control-Allow-Origin' '*';
96.                 add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
97.                 add_header 'Access-Control-Allow-Headers' 'Authorization,Content-Type';
98.                 add_header 'Access-Control-Max-Age' 86400;
99.                 return 204;
100.             }
101.         }
102.         
103.         # 认证端点
104.         location = /auth {
105.             internal;
106.             proxy_pass http://auth_service/validate;
107.             proxy_pass_request_body off;
108.             proxy_set_header Content-Length "";
109.             proxy_set_header X-Original-URI $request_uri;
110.         }
111.         
112.         # 健康检查端点
113.         location /health {
114.             access_log off;
115.             return 200 "healthy\n";
116.             add_header Content-Type text/plain;
117.         }
118.         
119.         # 监控端点
120.         location /nginx-status {
121.             stub_status on;
122.             access_log off;
123.             allow 192.168.0.0/16;
124.             deny all;
125.         }
126.     }
127. }

复制代码

优点：

• 与Netflix集成良好
  
• 过滤器机制灵活
  
• 文档资料丰富
  

缺点：

• 性能较差（阻塞IO）
  
• 已被Spring Cloud Gateway取代
  
• 社区活跃度下降
  

使用场景：

• 遗留Spring Cloud项目
  
• Netflix技术栈
  
• 非性能敏感场景
  

七、Traefik：云原生动态网关

有些小伙伴在容器化环境中需要自动服务发现，Traefik就是为云原生而生的动态网关。
Traefik 配置示例

1. # apisix-config.yaml
2. routes:
3.   - uri: /api/users/*
4.     name: user-service
5.     methods: [GET, POST, PUT, DELETE]
6.     upstream:
7.       type: roundrobin
8.       nodes:
9.         user-service-1:8080: 1
10.         user-service-2:8080: 2
11.         user-service-3:8080: 1
12.     plugins:
13.       proxy-rewrite:
14.         uri: "/users$1"
15.       limit-count:
16.         count: 100
17.         time_window: 60
18.         key: remote_addr
19.         rejected_code: 503
20.       jwt-auth:
21.         key: user-service
22.         secret: my-secret-key
23.         exp: 86400
25.   - uri: /api/orders/*
26.     name: order-service  
27.     upstream:
28.       type: chash
29.       key: arg_user_id
30.       nodes:
31.         order-service-1:8080: 1
32.         order-service-2:8080: 1
33.     plugins:
34.       cors:
35.         allow_origins: "https://example.com"
36.         allow_methods: "GET,POST,PUT,DELETE"
37.         allow_headers: "*"
38.       response-rewrite:
39.         body: '{"code": 0, "message": "success", "data": $body}'
40.       fault-injection:
41.         abort:
42.           http_status: 500
43.           body: "service unavailable"
44.           percentage: 5
46.   - uri: /api/products/*
47.     name: product-service
48.     upstream:
49.       type: roundrobin
50.       nodes:
51.         product-service:8080: 1
52.     plugins:
53.       proxy-cache:
54.         cache_key: ["$uri", "$args"]
55.         cache_zone: disk_cache_one
56.         cache_ttl: 300
57.       uri-blocker:
58.         block_rules: ["^/admin/", ".php$"]
59.         rejected_code: 403
61. # 全局插件
62. plugins:
63.   - name: prometheus
64.     enable: true
65.   - name: zipkin
66.     enable: true
67.     config:
68.       endpoint: http://zipkin:9411/api/v2/spans
69.       sample_ratio: 0.001

复制代码

优点：

• 自动服务发现
  
• 配置简单
  
• 云原生友好
  
• 内置监控和Dashboard
  

缺点：

• 功能相对简单
  
• 性能不如Nginx系网关
  
• 高级功能需要企业版
  

使用场景：

• 容器化环境
  
• 需要自动服务发现的场景
  
• 快速原型开发
  

八、6大网关对比

通过前面的分析，我们现在对这六种API网关有了深入的了解。
让我们通过一个全面的对比来帮助大家做出正确的技术选型。
详细对比表格

特性维度Spring Cloud GatewayKongNginxAPISIXZuulTraefik性能高（WebFlux）极高（Nginx）极高（C）极高（Nginx）中（阻塞IO）中配置方式代码/配置声明式YAML配置文件动态配置代码/配置动态配置服务发现Spring Cloud插件支持需手动配置支持Spring Cloud自动发现K8s支持良好良好需Ingress优秀一般优秀监控MicrometerPrometheus基础监控PrometheusHystrix内置学习曲线中中高低中高中低适用场景Spring Cloud企业级传统架构云原生传统Spring容器化选型决策指南

选择Spring Cloud Gateway当：

• 技术栈以Spring为主
  
• 需要深度定制网关逻辑
  
• 已经使用Spring Cloud组件
  
• 团队熟悉响应式编程
  

选择Kong当：

• 企业级高并发场景
  
• 需要丰富插件生态
  
• 有专业运维团队
  
• 需要成熟的管理界面
  

选择Nginx当：

• 性能要求极高
  
• 场景相对简单
  
• 团队熟悉Nginx
  
• 资源受限环境
  

选择APISIX当：

• 云原生环境
  
• 需要动态配置
  
• 追求最新技术
  
• 高性能要求
  

选择Zuul当：

• 维护遗留Spring Cloud项目
  
• Netflix技术栈
  
• 非性能敏感场景
  

选择Traefik当：

• 容器化部署
  
• 需要自动服务发现
  
• 快速开发部署
  
• 配置简单要求
  

总结

通过本文的介绍，我们对6种主流API网关有了全面的认识。
在选择网关时需要考虑以下关键因素：

• 技术栈匹配：选择与团队技术栈最匹配的方案
  
• 性能要求：根据业务并发量选择性能合适的网关
  
• 功能需求：评估需要的功能特性，如限流、认证、监控等
  
• 运维成本：考虑部署、监控、维护的复杂度
  
• 团队能力：评估团队对网关技术的掌握程度
  

核心建议

• 新项目优先考虑：Spring Cloud Gateway（Spring技术栈）或 APISIX（云原生）
  
• 高并发场景：Kong 或 Nginx
  
• 快速原型：Traefik
  
• 遗留系统：根据现有技术栈选择
  

记住，没有最好的网关，只有最合适的网关。
合理的网关选型可以大大提升系统的可维护性、可扩展性和性能表现。
最后说一句(求关注，别白嫖我)

如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下我的同名公众号：苏三说技术，您的支持是我坚持写作最大的动力。
求一键三连：点赞、转发、在看。
关注公众号：【苏三说技术】，在公众号中回复：进大厂，可以免费获取我最近整理的10万字的面试宝典，好多小伙伴靠这个宝典拿到了多家大厂的offer。
更多项目实战在我的技术网站：http://www.susan.net.cn/project

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

很好很强大  我过来先占个楼 待编辑

感谢，下载保存了