This tutorial walks through adding Spring Cloud Gateway as a single entry point for client calls to multiple microservices, covering why a gateway is needed, project structure, dependency and configuration setup, global logging and authentication filters, startup verification, and common pitfalls with solutions.
The article explains that Nginx and Spring Cloud Gateway serve distinct roles—Nginx as a network‑level gateway handling static assets, SSL termination, and load balancing, while Gateway focuses on business‑level routing and filters—making the two‑layer architecture both logical and efficient.
The article explains that Nginx and Spring Cloud Gateway serve different roles—Nginx as a network gateway handling static files, load balancing, SSL termination, and ops tasks, while Gateway focuses on business routing—so using both together improves performance, scalability, and operational separation.
This article walks through a practical implementation of gray (canary) release in a Spring Cloud ecosystem using Nacos for service discovery, Spring Cloud Gateway for routing, Ribbon (or Spring Cloud LoadBalancer) for load balancing, and custom interceptors to control traffic based on request metadata.
A production incident caused by replacing two Nginx reverse proxies introduced an upstream name with an underscore, resulting in invalid Host headers and 400 Bad Request responses from Spring Cloud Gateway; the article details the step‑by‑step investigation, evidence from logs, tcpdump, and code, and presents configuration fixes to restore normal operation.
When a business service needs an API that should only be callable within the internal network, this article evaluates three approaches—microservice isolation, gateway‑Redis whitelist, and gateway‑AOP—and demonstrates a concrete AOP implementation to enforce intranet‑only access.
This article provides a detailed technical overview of Spring Cloud Gateway, covering its role as a second‑generation API gateway built on Spring 5, WebFlux, and Reactor, its core responsibilities, architectural placement, key concepts like routes, predicates and filters, the request processing flow, and a concrete YAML configuration example.
This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.
The article explains that without a gateway each microservice must duplicate authentication, rate‑limiting, logging and other cross‑cutting concerns, leading to maintenance overhead and security risks, and shows how a gateway centralises these functions while providing routing, load‑balancing, circuit‑breaking and observability, backed by real‑world code examples and a comparative analysis of popular gateway solutions.
Even with Nginx handling high‑performance load balancing and static content, a dedicated API gateway is essential for flexible routing, dynamic service discovery, fine‑grained traffic governance, and centralized business logic such as authentication and logging in microservice architectures.
This article explains the fundamental differences between gray release and A/B testing, provides step‑by‑step guidance for implementing both strategies with Spring Cloud Gateway, Nacos and Kubernetes, and compares container‑level canary deployments with gateway‑level traffic routing to help you choose the right approach for reliable production releases.
This article explains how Spring Cloud Gateway leverages asynchronous non‑blocking I/O, horizontal scaling, Redis‑based rate limiting, and circuit‑breaker patterns to sustain massive QPS, reduce latency, and improve system resilience in microservice architectures.
This article walks through a complete design and implementation of a unified single sign‑on system using OAuth2.0 authorization‑code flow, Spring Cloud Gateway, JWT, Redis, and Nacos, comparing JWT, authentication, and authorization while presenting performance metrics, security considerations, and interview‑ready answers.
Spring Cloud Gateway achieves ultra‑high concurrency through asynchronous non‑blocking I/O, minimal Netty event‑loop threads, horizontal scaling with load balancers, Redis‑based distributed rate limiting, and built‑in circuit‑breaker protection, ensuring stable performance even under massive traffic spikes.
Spring Cloud Gateway leverages reactive programming, Netty’s non‑blocking I/O, and cluster scaling on Kubernetes or Docker to support tens of millions of QPS, using techniques like sharding, load‑balancing, DNS/Anycast, and built‑in rate‑limiting and circuit‑breaker mechanisms for resilient, high‑throughput microservice traffic.
This article outlines the key building blocks of a microservice architecture—including Nginx as the traffic entry, Spring Cloud Gateway, service registration, Redis caching, MySQL persistence, Elasticsearch, message queues, ELK logging, distributed scheduling, and object storage—providing practical guidance on design choices and high‑availability setups.
This article explains how to use Spring Cloud Gateway for traffic coloring and gray release, enabling you to tag requests, route VIP or test traffic to new service versions gradually, and ensure safe, controlled rollouts in production environments.
After a year‑long mystery, we discovered that Spring Cloud Gateway 3.x caches stale weight data from Nacos, causing 404 errors when routes are removed, and we detail the debugging steps, root‑cause analysis, and a custom solution that synchronizes the weight cache on configuration changes.
This guide walks through using Spring Cloud Gateway to replace direct service calls with a unified entry point, covering service discovery, load‑balanced routing, predicate definitions, custom predicates, rewrite‑path filters, global filters, and CORS configuration for microservice architectures.
This article explains how Spring Cloud Gateway leverages a non‑blocking NIO model, Reactor's reactive programming, cluster horizontal scaling, token‑bucket rate limiting, and Resilience4j circuit breaking to sustain million‑level concurrent traffic while maintaining low latency and high throughput.
This article provides a comprehensive overview of Spring Cloud Gateway, covering its role as a reactive API gateway, core functionalities such as routing, security authentication, rate limiting, logging, circuit breaking, the request lifecycle, and a comparison with other gateway solutions.
This article explains how Spring Cloud Gateway leverages an asynchronous non‑blocking model built on Netty and Project Reactor, along with rate limiting, circuit breaking, and degradation strategies, to sustain million‑level concurrent traffic while protecting backend services.
The article explains how Spring Cloud Gateway leverages a fully non‑blocking, reactive architecture built on Project Reactor and Netty to handle millions of concurrent requests, and discusses essential protection mechanisms such as rate limiting, circuit breaking, and degradation for high‑traffic scenarios.
This guide walks through upgrading a Spring Cloud Gateway by integrating Nacos as a service registry and configuration center, showing how to enable automatic request forwarding, dynamic route loading, and load‑balancing with step‑by‑step code examples and configuration files.
This article introduces Spring Cloud Gateway as a high‑performance replacement for Zuul, explains its core components (Route, Predicate, Filter) and request flow, provides step‑by‑step setup of a gateway project, demonstrates route configuration, custom GlobalFilter and GatewayFilter implementations, and validates the behavior with example requests.
This article provides a comprehensive walkthrough of Spring Cloud Gateway, covering its core concepts, architecture, key components such as Route, Predicate, and Filter, and detailed source‑code analysis with configuration examples and the underlying HTTP handling flow.
This article explains symmetric and asymmetric encryption principles, digital signatures, HTTPS with certificate authorities, and demonstrates how to implement combined encryption, digital signing, and URL protection using Spring Cloud Gateway filters and Java code examples.
This tutorial introduces Spring Cloud Gateway, explains its core features and Actuator integration, and provides step‑by‑step practical examples for viewing routes, global filters, route filters, refreshing routes, managing routes via REST endpoints, creating and deleting routes, and sharing routes with Redis, all accompanied by code snippets and configuration details.
This article explains the fundamentals of symmetric and asymmetric encryption, how digital signatures and HTTPS work with certificate authorities, and demonstrates a practical implementation of secure URL encryption, key exchange, and request validation using custom Spring Cloud Gateway filters written in Java.
This comprehensive guide explains why a gateway is essential in microservice architectures, outlines Spring Cloud Gateway's core features, walks through building a gateway from scratch, and demonstrates advanced topics such as custom predicates, filters, Nacos service discovery, dynamic routing, and global error handling.
This article explains what a microservice gateway is, outlines the advantages of Spring Cloud Gateway, and provides step‑by‑step instructions with code examples to create, configure, and run a reactive API gateway for Java microservices.
Learn how to set up Spring Cloud Gateway, configure routes, predicates, and filters—including custom global filters and time-based predicates—while testing load balancing, weight distribution, and request handling in a microservices environment effectively.
This article introduces Spring Cloud Gateway as a high‑performance, reactive API gateway for microservice architectures, explains why it is chosen, details Maven and YAML configuration, demonstrates routing predicates and filters with code examples, and evaluates its performance impact compared to alternatives.
This article explains how to create custom predicate and gateway filter factories in Spring Cloud Gateway, covering the underlying concepts, implementation steps, example code, and YAML configuration to tailor routing conditions and request handling for specific business needs.
This article introduces Spring Cloud Gateway as a powerful tool for building scalable microservice gateways, explains its reactive architecture and advantages, and provides a step‑by‑step tutorial—including Maven dependency, route configuration, custom filter code, and deployment instructions—plus suggestions for advanced features.
This tutorial explains how to use Spring Cloud Gateway for unified API routing, metrics collection, metadata handling, timeout settings, fluent Java route definitions, service‑discovery routing, and troubleshooting techniques in microservice architectures.
This article explains how to achieve full‑link gray (canary) release in a microservice architecture by adding a gray tag in a Spring Cloud Gateway global filter, propagating it through request headers, customizing Ribbon load‑balancing rules to select gray instances from Nacos, and using an OpenFeign interceptor to transmit the tag downstream, ensuring seamless A/B testing and stable deployments.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session management, role and permission retrieval, and global gateway filters in a Spring Cloud micro‑service architecture, including complete code examples and deployment tips.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session storage in Redis, service discovery via Nacos, and permission checks in a Spring Cloud Gateway micro‑service architecture, complete with code examples and deployment settings.
This article explains how to use Spring Cloud Gateway 3.1.5 to create a lightweight API gateway by configuring routes in YAML and implementing routing logic directly in a Spring MVC or WebFlux controller with ProxyExchange, covering features, code examples, and dynamic path mapping.
This article explains how EDAS enhances Spring Cloud Gateway by fixing memory‑leak issues, adding route‑validation, providing dynamic configuration, custom plugins, observability features, and step‑by‑step deployment instructions for Java‑based microservice environments.
This article reviews how Spring Cloud Gateway modifies HTTP requests/responses with built‑in filters, introduces the Higress cloud‑native gateway’s Transformer plugin as a higher‑performance alternative, compares their CPU and memory usage, and provides step‑by‑step deployment and configuration instructions.
This tutorial explains how to configure Spring Cloud Gateway, set up static routes, and then use Nacos for dynamic route management by adding dependencies, configuring bootstrap.yml, defining JSON route data, and implementing a listener bean to refresh routes without restarting the service.
This guide explains what a microservice gateway is, outlines the advantages of Spring Cloud Gateway, and provides a step‑by‑step tutorial—including Maven dependency, YAML routing configuration, custom filter code, and deployment instructions—to help developers build scalable, reactive API gateways for modern backend systems.
LApiGateway is Huolala's custom Java-based microservice gateway built on Spring Cloud Gateway, featuring service discovery via Consul, centralized configuration, a rich plugin system, DSL-driven routing, high‑availability designs like physical and service isolation, gray‑scale migration, traffic pre‑warming, and adaptive load balancing to ensure stable, efficient API management.
After a sudden 500 error crippled an online service, the author traced the issue to Spring Cloud Gateway’s HttpMessageReader creating temporary directories for every request, eventually exhausting inode space; the article explains the root cause, inode basics, and how upgrading to version 5.2.16 resolves the problem.
This article introduces Spring Cloud Gateway as a unified entry for microservices, explains its core functions, advantages over Zuul, Maven dependencies, YAML routing configuration, detailed route components, filter types with code examples, custom global filters, execution order, and CORS solutions for backend development.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
This guide explains why API rate limiting is essential, outlines common algorithms, and walks through three practical implementations in Spring Boot 3—using Guava, Spring Cloud Gateway with RedisRateLimiter, and a custom annotation‑based solution with Redis backing.
This article explores how Spring Cloud Gateway (Hoxton.SR11) initializes predicate factories, binds configuration values, creates Route objects, and uses CachingRouteLocator and RouteDefinitionRouteLocator to locate and match routes at startup, detailing the underlying code flow and key classes involved.
This article introduces Spring Cloud Gateway as a unified entry point for microservices, explains its core functions, compares it with Zuul, provides Maven and YAML configuration examples, details route definitions, filter types and ordering, shows how to implement custom filters, and demonstrates CORS solutions using both YAML and Java code.
This article explains the purpose of an API gateway, introduces Spring Cloud Gateway as a modern, WebFlux‑based solution, outlines its features, core concepts such as routes, predicates and filters, shows configuration examples, dynamic routing, and how to create custom predicates and filters for microservice architectures.
This article explains how Spring Cloud Gateway (Hoxton.SR11) creates and configures predicate factories, binds their Config objects, builds Route objects, caches them with CachingRouteLocator, and finally matches incoming requests to the appropriate route using asynchronous predicates.
The team discovered that frequent Logback file rotations created thousands of FileOutputStream objects whose finalize‑based FinalReference instances flooded the G1GC reference‑processing phase, causing 13‑second pauses, and resolved the issue by enabling parallel reference processing, enlarging log rotation size, and adjusting GC initiation thresholds.
This article explains the role of API gateways in microservice architectures, outlines their four core functions, discusses design priorities such as high performance, availability, and scalability, and compares major open‑source gateway solutions like OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This article explains why API gateways are essential in micro‑service architectures, outlines their four core functions, discusses high‑performance, high‑availability, and scalability design goals, and compares major open‑source gateways such as OpenResty, Kong, Zuul, and Spring Cloud Gateway to help engineers choose the right solution.
This guide explains how to configure route metadata in Spring Cloud Gateway 3.1.4, retrieve metadata via ServerWebExchange, set global and per‑route HTTP timeouts, use Java DSL for timeout settings, and enable DiscoveryClient‑based routing with custom predicates and filters.
An in‑depth walkthrough of Spring Boot 2.7.10 with Spring Cloud Gateway 3.1.6 shows how the RouteToRequestUrlFilter, ReactiveLoadBalancerClientFilter, NettyRoutingFilter, and NettyWriteResponseFilter sequentially transform incoming URLs, resolve service instances via load balancing, and forward requests to target microservices.
This article explains the fundamentals of API gateways, outlines their core functions, compares popular solutions such as Nginx, Zuul, Spring Cloud Gateway, Kong, and Traefik, and details a custom Traefik‑based gateway architecture with its technology stack, backend design, and protocol‑conversion module.
This article explains three practical approaches—separate microservices, gateway + Redis whitelist, and gateway + AOP—to restrict external access to internal APIs, and provides a detailed Spring Cloud Gateway and AOP code implementation for Java microservice architectures.
This article explains why an API gateway is essential in micro‑service architectures, introduces Spring Cloud Gateway’s core features, walks through project setup, routing predicates, filters, integration with Nacos for service discovery and dynamic routing, and demonstrates custom global error handling.
The article explains why Spring Cloud Gateway may still call a downed service due to a stale CachingRouteLocator cache, and demonstrates how to listen to Nacos InstancesChangeEvent to evict the cache so the gateway always uses the latest service list.
This guide explains how to configure HTTP connect and response timeouts globally and per route in Spring Cloud Gateway using YAML, Java DSL, and DiscoveryClient integration, including code examples for timeout settings, route predicates, filters, and custom metadata.
This guide explains the purpose, signatures, and ordering of GlobalFilter and GatewayFilter in Spring Cloud Gateway, shows how to combine them, and provides detailed code examples for custom global filters, forward routing, load‑balancing, Netty, WebSocket, and other core filters, including configuration tips.
This article provides a step‑by‑step guide to building a Spring Cloud Gateway for microservices, covering system setup, request routing, cross‑origin handling, token‑bucket rate limiting, password hashing with BCrypt, an overview of symmetric and asymmetric encryption, and JWT‑based authentication with code examples and configuration details.
This article explains why browsers enforce same‑origin policies causing CORS problems, outlines common remedies such as the @CrossOrigin annotation, HttpClient usage, and Spring Cloud Gateway integration, and provides detailed configuration and code examples for implementing these solutions in a Java backend.
This tutorial walks you through setting up a Spring Cloud Gateway service using Spring Boot, configuring static and Nacos‑driven dynamic routes, and implementing a custom authentication filter with Redis token validation, providing a complete beginner‑friendly guide to gateway development.
This article explains what an API gateway is, why it is needed in micro‑service architectures, outlines core design ideas such as routing, service registration, load balancing, resilience and security, distinguishes traffic and business gateways, and compares major open‑source implementations like OpenResty, Kong, Zuul 1/2 and Spring Cloud Gateway.
The article explains why browsers enforce same‑origin policies, then presents three practical ways to solve cross‑origin issues in a Spring Boot backend—using the @CrossOrigin annotation, routing through Spring Cloud Gateway, and making server‑side requests with HttpClient—accompanied by configuration examples and full code snippets.
This article explains why browsers enforce same‑origin policies, presents common CORS solutions such as the @CrossOrigin annotation, gateway integration with Spring Cloud Gateway, and using HttpClient, and provides detailed configuration and code examples for implementing these approaches in a Java backend project.
This article explains why browsers enforce same‑origin policies, presents common CORS solutions such as the @CrossOrigin annotation, HttpClient usage, and Spring Cloud Gateway integration, and provides detailed code examples for configuring gateways, CORS filters, and making HTTP requests in Java backend projects.
This article explores the shortcomings of current HTTP caching practices, proposes a three‑level cache design for B/S architectures, discusses gateway simplification with Apache APISIX, offers data‑size reduction tips, and presents a hand‑crafted Java HTTP cache framework with code examples.
This article explains the internal execution process of Spring Cloud Gateway, detailing how DispatcherHandler locates HandlerMapping, creates FilteringWebHandler, selects SimpleHandlerAdapter, builds and runs the filter chain—including core filters like RouteToRequestUrlFilter and NettyRoutingFilter—and transforms incoming URLs to their target destinations.
This article explains how to extend Sentinel's flow‑control capabilities in a Spring Cloud Gateway to implement traffic replication, covering Sentinel fundamentals, its slot‑chain architecture, custom filter code, configuration steps, and practical usage for testing and load‑testing with real traffic.
This article explains how to configure distributed rate limiting in Spring Cloud Gateway by adding the reactive Redis dependency, setting up Redis connection properties, defining a RequestRateLimiter filter with token‑bucket parameters, implementing a custom KeyResolver, and demonstrating the behavior with HTTP 429 and 403 responses.
This article explores the use of Reactor in Spring Cloud Gateway, highlighting its role in enabling reactive programming for efficient API gateway implementations through non-blocking, asynchronous operations and advanced data flow management.
This article explains why cross‑origin issues occur, presents common solutions such as @CrossOrigin, HttpClient and Spring Cloud Gateway, and provides detailed code examples for configuring CORS, building a gateway module, and making HTTP requests in a Java backend project.
This article provides a comprehensive overview of Spring Cloud Gateway's routing model, detailing the essential components of a route, the built‑in predicate factories, and the various gateway, default, and global filter implementations, helping developers avoid redundant work and reduce development costs.
After moving to a new team lacking a dedicated gateway, the author evaluates two popular microservice gateway solutions—Spring Cloud Gateway and Apache APISIX—comparing their features, cloud‑native capabilities, performance, and ease of use, ultimately selecting Spring Cloud Gateway for its Java ecosystem and extensibility.
This tutorial walks through setting up a Spring Cloud Gateway integrated with Nacos as a registration and configuration center, covering Nacos installation, project configuration, route definition, and a listener that dynamically refreshes service instances to ensure reliable request forwarding.
The article explains the specific stability, regulatory, and precision requirements of financial software, examines Java's role in the sector, describes the shortcomings of Spring Cloud Gateway, and details how Apache APISIX was adopted, deployed, customized, and evaluated to improve performance, cost, and operational efficiency in a cloud‑native environment.
This tutorial demonstrates how to set up a Spring Cloud Gateway service with static route configuration, then extend it to support dynamic routing through Nacos, and finally implement custom authentication and global filters using Java and Spring Boot.
This tutorial explains what gateway rate limiting is, shows how to integrate Alibaba Sentinel with Spring Cloud Gateway, details the configuration of Sentinel dashboard, gateway flow rules, API group management, implementation principles, and how to customize block responses for robust microservice protection.
This comprehensive guide explains why a service gateway is needed in microservice architectures, details Spring Cloud Gateway's core concepts, deployment steps, route and predicate configurations, local and global filters, integration with Nacos for service discovery, dynamic routing via Apollo, and custom global exception handling, providing code examples throughout.
This article explains how to design API gateways by comparing common gateway solutions, outlining essential design aspects such as routing, service discovery, load balancing, resilience, security, and high performance, availability, and scalability, and summarizing the strengths of OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This guide walks through setting up a Spring Cloud Gateway service using Spring Boot 2.1, configuring static and dynamic routes via YAML and Nacos JSON, and implementing a custom authentication filter with Redis token validation, covering gateway framework, route definitions, dynamic updates, and security filters.
Monet is a custom API gateway built on Spring Cloud Gateway that consolidates multiple platform endpoints into a single domain, providing unified routing, API management via Zookeeper, authentication and authorization, dynamic rate‑limiting with Sentinel, and extensible monitoring, addressing scalability and operational challenges of the Linglong platform.
This article explains the fundamentals of API gateways, their role in microservice architectures, key design considerations such as routing, load balancing, security, and elasticity, and compares major open‑source implementations like OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This article explains how to protect Spring Cloud Gateway APIs from data interception by using RSA asymmetric encryption, adding request timestamps and UUIDs for replay protection, and implementing request signatures, with detailed Java code examples and gateway filter configuration.
This guide explains how to protect a Spring Cloud Gateway service from packet sniffing by using RSA asymmetric encryption, timestamp validation, unique request IDs stored in Redis, and MD5 signature checks, with complete Java and front‑end code examples.
This article provides a comprehensive guide on securing Spring Cloud Gateway APIs using RSA asymmetric encryption, timestamp-based replay protection, unique request IDs stored in Redis, and MD5 signature verification, complete with detailed Java and front‑end code examples and testing results.
This article explains how to integrate Alibaba Sentinel with Spring Cloud Gateway to configure rate‑limiting and circuit‑breaker rules, covering Maven dependencies, Java configuration classes, Sentinel rule definitions, and optional console‑based management for robust backend API protection.
This article demonstrates how to integrate Alibaba Sentinel into Spring Cloud Gateway for traffic rate limiting and circuit breaking, covering Maven dependencies, configuration of SentinelGatewayFilter and exception handler, rule definitions via YAML or Java code, and custom API grouping, providing a complete backend gateway protection guide.
This article explains how to replace the deprecated Spring Security OAuth2 with a modern Spring Authorization Server solution, detailing the authentication flow, required components, configuration examples for Spring Cloud Gateway, Resource Server, and Id Server, and provides step‑by‑step demo instructions.
This article demonstrates how to set up a Spring Cloud Gateway service using SpringBoot 2.1, configure static routes, implement dynamic routing through Nacos configuration listening, and create a custom authentication GlobalFilter, providing a step‑by‑step guide with Maven dependencies, YAML/JSON examples, and full Java code.
This article explores two common microservice authentication and authorization architectures, compares a dedicated auth server versus gateway‑handled OAuth2 flows, and provides a step‑by‑step implementation using Spring Cloud Gateway, Spring Authorization Server, Spring Security, OpenID Connect, and token relay techniques to secure resources.
This article explains why Spring Cloud Gateway may return multiple Access-Control-Allow-Origin headers, analyzes the internal processing flow that causes the duplication, and provides two practical solutions—using DedupeResponseHeader configuration or a custom GlobalFilter—to ensure a single, correct CORS header in responses.
On March 1 2022 Spring released two critical CVEs (22946 and 22947) affecting Spring Cloud Gateway, detailing a remote code execution flaw via exposed Actuator endpoints and an insecure HTTP/2 TrustManager, and provides upgrade and configuration mitigation steps.
This article explains the two high‑severity Spring Cloud Gateway vulnerabilities disclosed on March 1, 2022, details their impact and affected versions, and provides concrete upgrade and configuration steps to mitigate the risks.
This article explains how to achieve gray (canary) release across multiple environments by using Spring Cloud LoadBalancer in Spring Cloud Gateway, configuring service metadata and request headers to route traffic to specific instances, and provides two implementation approaches with full code examples.
