Skip to main content

Apache Shenyu

Apache ShenYu is a Java-based Application Programming Interface (API) gateway and microservices gateway (API management / integration middleware) that provides high-performance, extensible routing, traffic management, and plugin-based governance for Hypertext Transfer Protocol (HTTP), WebSocket, and other protocols.

  • Pluggable, reactive API gateway for HTTP, WebSocket, and other protocols (API gateway / integration middleware).
  • Plugin-based architecture for routing, traffic control, authentication, logging, and protocol adaptation (API management / extensibility).
  • Support for multiple upstream registries and service discovery mechanisms (service discovery / service mesh integration).
  • Dashboard-driven rule management for routing, plugins, and traffic governance (operations / configuration management).
  • Extensible SPI-based plugin model for custom filters, protocols, and governance policies (developer platform / extensibility).

More About Apache Shenyu

Apache ShenYu is an open-source, Java-based gateway framework (API gateway / integration middleware) under The Apache Software Foundation designed to route, proxy, and manage traffic across microservices and backend APIs. It targets scenarios where enterprises need a unified, high-throughput entry point for heterogeneous services, including HTTP-based microservices, WebSocket endpoints, and other protocol backends. ShenYu focuses on reactive design and plugin-based extensibility to support different protocols and governance policies.

The core of ShenYu is a gateway engine that supports reactive processing built on the Java ecosystem (application integration). It exposes a unified API entry and forwards requests to upstream services based on routing rules defined in its administrative console. ShenYu supports multiple protocols at the edge, such as HTTP and WebSocket (network / application protocols), and can integrate with different service registry systems (service discovery) to locate upstream instances. The framework uses asynchronous, non-blocking processing to handle large volumes of concurrent requests in microservice environments.

A central feature of Apache ShenYu is its plugin architecture (extensibility framework). The gateway behavior is extended through plugins that implement cross-cutting functions such as authentication and authorization (identity and access), rate limiting and traffic shaping (traffic management), logging and tracing (observability), routing and load balancing (traffic distribution), and protocol transformation (protocol mediation). Plugins are managed via a dashboard, and configuration changes can be propagated dynamically to the gateway nodes. The project uses a Service Provider Interface (SPI) mechanism (Java Stateful Packet Inspection (SPI) / extensibility) that allows organizations to implement custom plugins tailored to specific protocols, policies, or backends.

ShenYu provides an admin and dashboard component (operations / configuration management) where administrators define routes, selectors, and rules that govern how requests are matched and which plugins apply. This interface enables management of plugin configurations, enabling or disabling functionality, and updating routing information without redeploying the gateway. Configuration is typically synchronized to gateway instances through a registration and data synchronization mechanism, helping maintain consistency across distributed deployments.

In enterprise environments, Apache ShenYu is used as an access gateway in front of microservices, legacy services, or mixed polyglot backends (enterprise integration). It can integrate with multiple registries and configuration centers from the Java and cloud-native ecosystem (service discovery / configuration management), enabling dynamic lookup of service instances. ShenYu aligns with architectures that separate edge traffic concerns from service implementation, such as API gateways in microservices, and can coexist with service mesh deployments as an ingress or north-south traffic controller.

From a directory and taxonomy perspective, Apache ShenYu fits in the categories of API gateway, microservices gateway, and integration middleware (API management / traffic management). Its plugin-based model and support for reactive Java runtimes position it as a gateway framework that enterprises can embed, customize, or deploy as a standalone edge gateway. By centralizing routing, protocol adaptation, and governance in one gateway layer, ShenYu provides a focused tool for managing API traffic, observability hooks, and policy enforcement in distributed systems.