This article presents a comprehensive, adaptable three‑tier architecture—gateway, business, and foundation layers—detailing how to evolve from simple LAMP or SSH structures to a scalable system that cleanly separates protocol handling, service logic, and data components.
This article outlines a practical, three‑tier Java backend architecture—gateway, business, and foundation layers—explaining how to handle HTTP and TCP requests, structure business services and processes, and choose core technical components such as storage, caching, messaging, transactions, and locking.
This article presents a senior architect's comprehensive guide to evolving a classic three‑tier backend architecture into a flexible system composed of a gateway layer handling HTTP and TCP protocols, a business layer with services, processes and reusable components, and a foundation layer that defines interfaces and essential technical components such as storage, caching, messaging, transactions, and locking.
This article presents a comprehensive overview of a flexible, layered software architecture—covering gateway, business, and foundation layers—explaining how to evolve from simple startup setups to adaptable structures that support HTTP/TCP handling, service design, component abstraction, and common technical components.
This article details the design and implementation of a transparent cross‑network data‑transfer system built on Dubbo, covering its evolution from early one‑way solutions to a highway architecture, the technical challenges encountered, the applied fixes and community contributions, and the roadmap for future stability, extensibility, and multi‑protocol support.
This article introduces the technical challenges, community collaboration, and deeper architectural thinking involved in implementing a cross-network data transmission system based on Dubbo at Zhengcaiyun, a government procurement cloud platform.
The article presents a practical, layered backend architecture—including gateway, business, and foundation layers—designed to replace simple early‑stage setups, improve maintainability, and handle various protocols such as HTTP and TCP while offering reusable components and technical guidelines.
This report details Soul's challenges with a multi‑layer gateway chain, evaluates Envoy, MSE and ALB, presents performance test results, outlines short‑term and long‑term migration plans, and shares post‑migration improvements and lessons learned for a cloud‑native gateway solution.
This article explains a comprehensive backend user login flow, covering token generation, expiration policies, request validation, logout handling, anonymous access strategies, rate‑limiting with authorized tokens, path‑regex filtering, blacklist management, and includes a Spring‑Redis implementation example.
The article explains Baidu's Janus gateway—its motivations, three‑level routing design, variable and condition expression language, plugin implementations for disaster recovery and caching, and performance benchmarks—showing how it supports millions of QPS while remaining flexible and efficient.
This article demonstrates how to build a Spring Cloud Gateway microservice that serves as a centralized authentication and authorization gateway, covering Maven dependencies, YAML configuration, whitelist handling, exception processing, RestTemplate setup, and a custom global filter with code examples.
Janus is Baidu’s high‑throughput, multi‑purpose gateway that complements BFE, supporting traffic, business, and hybrid routing for dozens of internal services; the article explains its motivations, architecture, three‑tier routing rules, variable and conditional expressions, plugin system, performance benchmarks, and future extensions.
This article describes the background, design, configuration, code implementation, and testing of BetterGateway—a Spring Cloud Alibaba‑based gateway that centralizes error‑code management using Nacos and dynamic refresh to enable fast, accurate exception tracing across micro‑services and third‑party interfaces.
The article explains why Baidu built the high‑performance Janus gateway, its architecture and deployment topology, the three routing modes, the three‑level rule system with variable and condition expressions, plugin extensibility, performance benchmarks, and how the design can be generalized to other use cases.
This article analyzes Baidu's Janus gateway—why it was built despite BFE, its architecture and deployment, three‑layer routing design, variable and condition expression languages, performance benchmarks versus raw Go code, and how its plugin system enables both generic and highly customized traffic‑dispatch solutions.
Learn how to enable Spring Cloud CircuitBreaker in Spring Cloud Gateway using Resilience4j, configure filters, define fallback URIs, customize timeout settings, handle exceptions, and control circuit breaking based on HTTP status codes, with both YAML and Java code examples.
This article compares three approaches—microservice isolation, gateway with Redis whitelist, and a gateway‑plus‑AOP header strategy—to enforce internal‑only API access, and provides a complete Spring Cloud implementation with code examples and a diagram.
This article explains the concept of observability, why it is essential for cloud‑native gateway architectures, and provides step‑by‑step best practices—including metric selection, black‑box and white‑box monitoring, gray‑release handling, synthetic testing, and extending gateway data to business‑level observability.
KubeGateway, a custom seven‑layer gateway built by ByteDance, eliminates kube‑apiserver load‑imbalance and adds comprehensive request governance—including routing, rate‑limiting, and degradation—by parsing HTTP2 traffic, supporting flexible policies, and transparently proxying requests without client changes.
Learn three practical strategies to prevent external exposure of specific APIs—isolating them in separate microservices, employing a Redis‑backed whitelist via the gateway, and using gateway‑added headers with AOP annotations—to enforce internal‑only access, complete with Java code examples.
This article details the architectural evolution of China Telecom's Tianyi Account gateway, describing the migration from a Zuul‑based 1.0 system to a Kong‑driven 2.0 and 3.0 platform, the performance improvements, plugin ecosystem, cloud‑native deployment, and operational benefits achieved through each upgrade.
This article details the architectural evolution of China Telecom's Tianyi Account gateway from its initial Zuul‑based 1.0 version through a Kong‑based 2.0 redesign to the high‑performance, multi‑language, hybrid‑deployment 3.0 architecture that now supports over 100 k QPS and 99.96% SLA.
This article explains three practical solutions for exposing internal‑only APIs in a Spring Cloud environment—separating services, using a gateway with a Redis whitelist, and applying a gateway‑plus‑AOP strategy—complete with code examples and deployment tips.
This article explains how to build a highly extensible modular backend service using Spring Cloud Gateway, Gradle scripts, and service‑discovery metadata to automatically generate and refresh routing configurations for both monolithic and microservice deployment modes.
This tutorial walks through designing an OAuth2 authentication architecture, configuring Spring Boot services, setting up MySQL schemas, integrating Nacos discovery, implementing security with JWT tokens, and connecting microservices through a Spring Cloud Gateway, while demonstrating all four OAuth2 grant types with code examples.
This guide explains how to set up Alibaba Cloud's MSE Cloud‑Native Gateway, replace traditional multi‑layer gateway architectures, and use it with EDAS to achieve full‑link gray deployments through step‑by‑step configuration, service import, routing, and verification.
This tutorial walks through implementing login authentication using Spring Cloud Gateway and JWT, covering core concepts of authentication, authorization, credential handling, token generation, gateway validation, service integration, and token refresh strategies within a microservice architecture.
This article examines security challenges encountered in JD Logistics' sorting platform, details the investigative process for abnormal API requests, proposes a SHA‑256 based authentication scheme with digital signatures, compares industry‑wide API protection methods, and shares practical insights from the author's experience in financial API gateway design.
This article explains how to integrate JWT-based login authentication into a Spring Cloud micro‑service architecture using Spring Cloud Gateway, detailing the authentication flow, token generation, gateway validation, service‑side user handling, and token refresh strategies with practical code examples.
This article explains the concept of VLANs, how they segment broadcast domains like classroom groups, describes single‑arm routing and layer‑3 switches for inter‑VLAN communication, and covers essential networking components such as gateways, DNS, MAC addresses, IP addressing, and subnet masks, illustrating each with clear analogies.
This tutorial explains how to centralize URL‑level authentication in a Spring Cloud Gateway by integrating Spring Security OAuth2 Resource Server, defining custom authorization managers, handling token errors, forwarding JWT claims to downstream services, and configuring the gateway with YAML and Java code examples.
The guide shows how to deploy an Nginx container with Docker, configure it to proxy a custom domain to a SpringBoot microservice registered in Nacos, add a Spring Cloud Gateway upstream, and route all requests through Nginx, simplifying access and eliminating CORS issues.
This article explores practical solutions for implementing a distributed WebSocket cluster in a Spring Cloud environment, detailing the challenges of session sharing, comparing Netty and Spring WebSocket approaches, and presenting two strategies—session broadcasting and consistent‑hashing—along with gateway configuration, load‑balancing, and code examples.
This article explains the concept of VLANs, illustrates their purpose with real‑world analogies, and details how single‑arm routing, layer‑3 switches, gateways, DNS, MAC addresses, and subnet masks work together to segment and connect networks efficiently.
This article compares Alibaba Cloud's MSE cloud‑native gateway with the traditional Nginx Ingress Controller across performance, cost, reliability and security, presenting benchmark data, CVE analysis, architectural advantages, and a step‑by‑step migration plan for Kubernetes clusters.
This article explains the concepts of VLANs, single‑arm routing and layer‑3 switches, gateways, DNS, MAC addresses, and subnet masks, using simple analogies and diagrams to show how network segmentation and communication work together in modern LAN environments.
This article chronicles Alibaba's three‑stage evolution of Envoy Gateway—from the 1.0 incubation that powered Double‑11 traffic, through the 2.0 growth phase adding north‑south routing and hybrid‑cloud support, to the mature 3.0 release that unifies traffic and micro‑service gateways with high performance and community‑driven extensions.
This article explains the concept of VLANs, illustrates how they segment networks like classroom groups, describes single‑arm routing and layer‑3 switches for inter‑VLAN communication, and covers related fundamentals such as gateways, DNS, MAC addresses, and subnet masks, providing clear analogies and diagrams for beginners.
This article explains the two high‑severity Spring Cloud Gateway vulnerabilities (CVE‑2022‑22946 and CVE‑2022‑22947), detailing their descriptions, affected versions, exploitation conditions, and provides concrete remediation steps such as upgrading to safe releases or disabling the vulnerable actuator endpoints.
This article explores practical approaches for building a distributed WebSocket cluster in a Spring Cloud environment, covering session handling, Netty versus Spring WebSocket implementations, session broadcasting, consistent‑hash routing, gateway configuration, Ribbon limitations, and provides code examples for each solution.
This article provides a detailed introduction to microservices, covering its definition, core principles such as small independent services, lightweight communication, independent deployment and management, the advantages and disadvantages, suitable organizational contexts, and the essential components like service discovery, API gateways, configuration centers, monitoring, circuit breaking, container orchestration, and service mesh.
This article explains why and how to aggregate Swagger API documentation across multiple Spring Cloud microservices by creating a reusable swagger‑starter, configuring each service, and implementing a GatewaySwaggerResourcesProvider to expose a unified documentation entry point.
This article explains how to design and implement a microservice‑based PaaS platform using Docker containers, Spring Cloud Netflix components such as Zuul, Eureka, and Hystrix, covering service gateway routing, registration and discovery, deployment, fault tolerance, and dynamic configuration.
This article explains how to implement a Role‑Based Access Control (RBAC) permission model in Spring Cloud Gateway, covering the design, loading URL‑role mappings into Redis, customizing UserDetailsService, and integrating OAuth2.0 with code examples and database schema.
This article explains how to invalidate JWT tokens during password changes, permission updates, or logout by using a Redis-backed blacklist approach in Spring Cloud Gateway, detailing the extraction of the token's jti, gateway filtering, downstream modifications, and a logout endpoint implementation.
This article explains the complete user login process, token generation and validation, token expiration policies, logout handling, and two approaches for anonymous requests—authorized tokens with rate limiting and path‑based regex rules—illustrated with diagrams and Java/Redis code examples.
This article demonstrates how to build a unified authentication and authorization solution by integrating Spring Cloud Gateway with OAuth2.0, covering architecture design, service setup, JWT token handling, custom authentication and authorization managers, Redis-based permission management, and end‑to‑end testing steps.
This article describes how to design and build a high‑throughput, extensible gateway using Spring WebFlux, Netty, and Nacos, covering technical selection, architecture, core modules, plugin chain, data synchronization, WebSocket cache, testing, and performance results.
This guide explains the concept of gray (canary) releases and provides detailed Istio configuration files—including Deployments, Service, Gateway, VirtualService, and DestinationRule—to gradually shift traffic between version 1 and version 2 of a service.
This article details the redesign of Shimo Docs' WebSocket gateway—from a Node.js/Socket.IO 1.0 version to a Go‑based 2.0 architecture—covering handshake degradation, TLS memory savings, SnowFlake SocketID generation, Redis‑based session broadcasting, heartbeat tuning, custom Kafka headers, object pooling, MessagePack compression, extensive performance testing, and the resulting stability and scalability improvements for handling half‑a‑million concurrent connections.
This article details the design, refactoring, and performance testing of a high‑traffic WebSocket gateway for Shimo Docs, covering the evolution from a Node.js Socket.IO version to a Go‑based microservice architecture, TLS memory tuning, socket ID generation, heartbeat handling, custom Kafka headers, and resource‑efficient scaling to half‑a‑million concurrent connections.
This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.
This article provides a comprehensive overview of microservices, covering its origin, core architectural principles, key characteristics, advantages and drawbacks, suitable organizational contexts, and essential technical components such as service discovery, gateways, configuration centers, monitoring, circuit breaking, and container orchestration.
This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.
This article provides a comprehensive overview of microservices architecture, explaining its definition, core principles such as small independent services, process isolation, lightweight communication, independent deployment and management, while also discussing advantages, drawbacks, suitable organizations, service discovery, gateway, configuration center, monitoring, containerization, orchestration and related tooling.
This article analyzes the challenges of multi‑user WebSocket communication in a clustered environment, compares Netty and Spring WebSocket implementations, and presents two practical solutions—session broadcast and a consistent‑hashing based routing scheme—complete with code samples, gateway configuration, and load‑balancing considerations.
This article explains the principles and practical steps for implementing rate limiting at the SLB, Nginx/Kong, Spring Cloud Gateway, and Java microservice layers, covering traffic characteristics, interception rules, configuration methods, and isolation techniques to protect cloud‑native systems.
Alibaba’s AServer access gateway, handling billions of users and millions of QPS, transitioned from a monolithic tengine‑based system to a cloud‑native, containerized architecture with Kubernetes, Pilot, and Envoy, improving operational complexity, dynamic routing, traffic isolation, and scalability for massive e‑commerce traffic.
This article provides a comprehensive overview of microservices architecture, covering its definition, key characteristics, advantages and drawbacks, suitable organizational contexts, core components such as service discovery, gateways, configuration centers, monitoring, circuit breaking, as well as containerization and orchestration technologies.
The article explains how to apply rate‑limiting at each entry point of a distributed system—SLB, Nginx, Spring Cloud Gateway, and individual Java microservices—detailing traffic characteristics, limiting strategies, isolation techniques, and the role of circuit breaking to protect backend stability.
This article outlines the objectives, detailed call process, architectural modules, and potential challenges of a payment center system that unifies order, payment, and finance services while ensuring security, scalability, and data support for downstream applications.
This article presents a comprehensive set of practical guidelines for Spring Cloud microservice development, covering Maven project structure, core and starter modules, versioning conventions, service invocation via SDK and Feign, RESTful API design rules, and gateway responsibilities such as access control and gray release.
This article explains how to build a cloud‑native PaaS platform using a microservice architecture powered by Spring Cloud Netflix, Docker containers, an ELB‑based gateway, Eureka service registry, Hystrix fault tolerance, and a dynamic configuration center to achieve agile development and continuous integration.
This article explains how to design and implement a secure gRPC gateway using OpenResty, analyzes performance bottlenecks such as excessive TIME_WAIT connections, and provides practical kernel and Nginx/OpenResty tuning steps to achieve long‑lived connections and lower latency.
This article presents a comprehensive design guide for a microservice gateway, covering functional aspects such as routing, load‑balancing, aggregation, authentication, rate limiting, circuit breaking, and retries, as well as non‑functional concerns like high performance, high availability, scalability, extensibility, and observability.
This tutorial demonstrates how to configure Spring Cloud Gateway with service discovery, integrate Hystrix for circuit breaking, implement global and custom route filters, and apply Redis-based rate limiting, providing complete Maven dependencies, Java code examples, and YAML configurations for a robust microservice gateway.
This article explains the design, configuration, and usage of the JD Logistics gateway frontend plugin built on Axios, detailing how it enables zero‑cost integration across multiple environments and account types while providing extensible request/response handling and customizable login redirects.
This article details Ximalaya's evolution of its HTTP gateway—from a Tomcat NIO prototype to a fully asynchronous Netty design—covering architectural diagrams, performance bottlenecks, traffic management features, monitoring, GC tuning, and future plans for HTTP/2 and graceful degradation.
This article outlines a comprehensive design for a microservice API gateway, covering functional aspects such as routing, load balancing, aggregation, authentication, rate limiting, circuit breaking, caching, retries, and logging, as well as non‑functional concerns like high performance, high availability, scalability, and monitoring, with practical implementation options and recommendations.
This article details Ximalaya's evolution from a Tomcat‑based gateway to a Netty‑driven, fully asynchronous architecture, covering design challenges, performance bottlenecks, traffic management features, monitoring, and future HTTP/2 plans that enabled handling over 200 billion daily calls with high QPS.
This article details Ximalaya's evolution of its high‑traffic gateway—from a Tomcat‑based prototype to a fully asynchronous Netty design—covering core features, full‑link timeout handling, monitoring, performance optimizations, and future plans for HTTP/2 and unified downgrade.
This article explains how Kubernetes exposes applications using Service types, NodePort, LoadBalancer, and Ingress, compares popular Ingress controllers such as Nginx, Kong, and Envoy, and presents a CRD‑based gateway management architecture for both cloud and on‑premise environments.
The latest Soul gateway release introduces a revamped admin dashboard with permission control and internationalization, adds numerous GRPC, Tars, Sofa, Sentinel, and other plugins, expands client support for Spring, Dubbo and various registration centers, and boosts test coverage to 70% while welcoming new contributors.
This article presents the design, implementation, and performance evaluation of a Netty‑based WebSocket long‑connection gateway that centralizes session management, decouples business logic, supports horizontal scaling, and provides monitoring and alerting for high‑throughput real‑time data push in iQIYI’s platform.
This article details the design evolution, architectural choices, performance tuning, monitoring, and future plans of Ximalaya's high‑traffic HTTP gateway, covering its migration from Tomcat NIO to a fully asynchronous Netty implementation and the associated engineering challenges and solutions.
This article describes how Ximalaya’s high‑traffic HTTP gateway evolved from a Tomcat NIO + AsyncServlet design to a Netty‑based fully asynchronous architecture, detailing the challenges of blocking I/O, memory copying, GC pressure, and how layered redesign, lock‑free connection pools, comprehensive monitoring, and performance optimizations enabled stable handling of over 200 billion daily calls with peak QPS exceeding 40 k per machine.
This article describes the design, architecture, implementation, and testing of a high‑throughput API gateway built with Spring WebFlux, Netty, and Nacos, covering technology selection, custom routing rules, load‑balancing, service registration, data synchronization, and performance benchmarking.
This article details Ximalaya's evolution from a Tomcat‑based gateway to a fully asynchronous Netty implementation, covering architectural redesign, performance bottlenecks, traffic management features, connection‑pool handling, timeout mechanisms, monitoring, and future plans for HTTP/2 and cloud‑native stability.
iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.
This article describes the end‑to‑end design, technology selection, architecture, core code implementation, data synchronization, and performance testing of a custom high‑throughput gateway built with Spring WebFlux, Netty, and Nacos, highlighting routing rules, load‑balancing, and gray‑release capabilities.
The article uses a courtyard and gatekeeper metaphor to explain the roles of gateways, DNS, DHCP, routing tables, static and dynamic routing, route selection, IP/MAC addressing, ARP spoofing, DDoS/DoS attacks, and related security concepts in computer networking.
This article provides a detailed introduction to microservices, covering its definition, advantages and disadvantages, suitable organizational contexts, core architectural components such as service discovery, gateways, configuration centers, communication protocols, monitoring, circuit‑breaker patterns, containerization, orchestration engines, and related open‑source tools.
The article explores practical design principles for microservice architecture, covering core concepts, team and database partitioning, API granularity, domain‑composed services, gateway strategies, shared JAR dependencies, decoupling techniques, and change‑impact analysis to guide robust backend system development.
This article explains how to build a microservice‑based PaaS platform using Spring Cloud Netflix components, Docker containers, Eureka for service registration, Zuul as a gateway, Hystrix for fault tolerance, and a dynamic configuration center to achieve agile development and continuous integration.
This article recounts the JD.com 11.11 tech salon presentation where architect Shi Weihang explains how the NeuHub gateway was redesigned to handle over two billion TTS service calls, detailing the challenges, scaling techniques, and architectural decisions that enabled such massive traffic.
This tutorial walks through setting up the PassJava project, covering microservice architecture, service discovery with Nacos, remote calls via OpenFeign, API gateway configuration, OSS file storage integration, and centralized exception handling, providing detailed code examples and configuration steps for each component.
This article details the architecture, protocol design, permission control, reliability mechanisms, and scaling strategies of a long‑connection gateway built with OpenResty, Kafka, and Redis, illustrating how to share persistent connections across multiple business services while ensuring high performance and fault tolerance.
This article describes the design and implementation of a PaaS cloud platform based on microservice architecture, covering service access paths, gateway functions with Zuul, service registration with Eureka, fault tolerance using Hystrix, dynamic configuration via Spring Cloud ConfigServer, and Docker container deployment.
This article explains networking fundamentals such as VLANs, single‑arm routing, layer‑3 switches, gateways, DNS, MAC addresses, IP addressing, and subnet masks, using simple analogies and examples to illustrate how devices communicate across different network segments.
Learn to unify API documentation across multiple Spring Cloud microservices by configuring Nacos, Spring Cloud Gateway, and Knife4j, covering prerequisite setup, service definitions, detailed implementation steps, Swagger resource aggregation, UI switching, and complete code examples for user, order, and gateway services.
This guide walks through building a unified microservice authentication and authorization solution using Spring Boot 2.2+, Spring Cloud Hoxton, Nacos, Spring Cloud Gateway, and JWT, detailing the architecture, service division, and step‑by‑step implementation of auth, gateway, and API services with code examples.
The article summarizes the technical innovations of the open‑source Kube‑OVN project—including a namespace‑based subnet model, comprehensive fixed‑IP support, flexible gateway options, performance optimizations for control and data planes, extensive monitoring tools, and real‑world user cases—highlighting its relevance for modern cloud‑native networking.
This article explains the concept of VLANs, how they segment networks like classroom groups, the role of single‑arm routing and layer‑3 switches for inter‑VLAN communication, and clarifies related fundamentals such as gateways, DNS, MAC addresses, IP addressing, and subnet masks.
This article shares practical dubbo-go experience at Tuya Smart, covering the gateway architecture, generic invocation mechanics, step‑by‑step integration, configuration pitfalls, performance tuning, and extension points to help developers adopt the high‑performance RPC framework efficiently.
This tutorial walks through disabling ICMP ping, hardening a Linux web server with iptables, configuring a dual‑NIC gateway, and implementing DNAT port mapping, providing complete command examples, verification steps, and visual results for each scenario.
This tutorial walks through building a Spring Cloud micro‑service platform by preparing the development environment, adding backend menus, auto‑generating Vue pages, configuring Spring Cloud Gateway routing, registering services with Nacos, and solving CORS issues to enable seamless frontend‑backend interaction.
This article provides a comprehensive guide to Spring Cloud Gateway, covering its role as an API gateway, core features, underlying principles, step‑by‑step module creation, Maven dependency configuration, application annotations, YAML routing examples, and a runnable demo for building cloud‑native microservice architectures.
This article provides a detailed introduction to microservices, covering its definition, core principles, advantages and disadvantages, suitable organizational contexts, and the essential components such as service discovery, API gateways, configuration centers, communication protocols, monitoring, circuit breaking, and container orchestration, illustrated with numerous diagrams.
This guide shows how to configure one CentOS machine as a NAT gateway using iptables, enabling nine other LAN servers to access the Internet via SNAT or MASQUERADE, with step‑by‑step commands, kernel settings, and client configuration tips.
The article introduces Alibaba's open‑source web server Tengine, explains its Dubbo integration that enables HTTP‑to‑Dubbo proxying, compares it with traditional Java gateway architectures, highlights performance and stability advantages, and provides practical examples and future roadmap details.
