emmett-framework/granian
Granian
Granian is a Rust-based HTTP server written specifically to serve Python web applications. It supports the three major Python gateway interfaces—ASGI for asynchronous apps, WSGI for synchronous apps, and RSGI for async requests—while also handling HTTP/1.1, HTTP/2, and WebSocket connections through automatic protocol negotiation.
Architecturally, Granian uses a multiprocess worker model that isolates requests across CPU cores and provides configurable threadpool-limited concurrency to control backpressure per worker. It includes built-in Prometheus metrics exposition for connection counts and request rates, startup/shutdown/reload event hooks for application lifecycle management, and a static file serving bypass that delivers assets directly without involving the application runtime. Trusted proxy header rewriting preserves original client details when the server sits behind a reverse proxy.
The server can run applications using any of the supported gateway protocols, control its own lifecycle through synchronous or asynchronous callbacks, and tune how many concurrent connections are handled per worker. It also handles forwarded headers from trusted proxies to maintain correct client address and protocol information.
Features
- WSGI Application Servers - Serves Python applications using ASGI, WSGI, and RSGI protocols.
- Worker Process Isolation - Uses multiple worker processes to isolate requests across CPU cores.
- HTTP/2 and WebSocket Servers - Supports HTTP/1.1, HTTP/2, and WebSocket connections with automatic protocol negotiation.
- Protocol Negotiation - Accepts connections over both HTTP/1.1 and HTTP/2 via protocol negotiation.
- Automatic HTTP Protocol Selectors - Automatically selects HTTP/1.1 or HTTP/2 during connection handshake.
- Rust-Based Python Web Servers - A high-performance HTTP server written in Rust that serves Python web applications.
- Async-Sync Compatibility Layers - Supports both ASGI and WSGI applications within the same server runtime.
- Lifecycle Hooks - Provides startup, shutdown, and reload hooks for server lifecycle management.
- ASGI Request Producers - Processes incoming requests for asynchronous Python ASGI applications.
- Rust-Based Python HTTP Servers - A high-performance HTTP server written in Rust that serves Python web applications using multiple gateway protocols.
- Multi-Protocol Servers - Supports HTTP/1.1, HTTP/2, WebSocket, and multiple Python gateway protocols on a single server.
- RSGI Application Servers - Process requests for applications that use an asynchronous gateway interface and return responses.
- ASGI and WSGI Servers - Serves Python web applications using ASGI, WSGI, and RSGI gateway protocols.
- Web Applications - Runs web applications with support for multiple protocols and WebSockets.
- Concurrency Limits - Restricts concurrent connections per worker using configurable thread pools.
- Startup Hooks - Executes custom callbacks at startup, shutdown, and reload events.
- Proxy Headers - Rewrites request metadata based on forwarded headers from trusted proxies.
- Metrics Exporters - Exposes server metrics like connection counts and request rates for monitoring.
- Prometheus Exporters - Exposes built-in Prometheus metrics for connection counts, request rates, and threadpool statistics.
- Prometheus-Based Metric Exporters - Exposes connection counts and request rates in standard Prometheus format.
- Worker Threadpool Throttles - Limits concurrent connections per worker with configurable thread pools.
- Web Servers - A Rust HTTP server for Python applications supporting WSGI/ASGI/RSGI.
- Web Servers - Listed in the “Web Servers” section of the Awesome Python awesome list.
