userver-framework/userver
Userver
userver is a comprehensive C++ backend application platform and asynchronous framework designed for building scalable microservices. It provides a high-performance execution environment for deploying services that communicate via gRPC and HTTP using a middleware-based request pipeline.
The platform distinguishes itself through a distributed service orchestration toolset that manages shared state, distributed locking, and dynamic configuration updates without requiring process restarts. It utilizes a coroutine-based asynchronous execution model and event-loop network I/O to handle high-concurrency tasks while minimizing operating system thread blocks.
The framework includes a broad suite of capabilities covering non-blocking database drivers for SQL and NoSQL stores, message broker integration, and local data caching. It further provides observability and reliability tools, including cloud-native service monitoring, production profiling, and chaos testing support to verify fault tolerance.
Development is supported by schema-driven code generation that produces strongly typed C++ structures from JSON and SQL definitions.
Features
- High-Performance Web Services - Offers a high-performance framework for building scalable microservices that maximize throughput using asynchronous I/O.
- Asynchronous Database Drivers - Ships a suite of non-blocking database drivers for high-throughput data exchange.
- Distributed Task Coordination - Coordinates distributed tasks and shared state across multiple instances using locking primitives.
- Distributed Locks - Provides distributed locking primitives to synchronize state and task execution across service instances.
- Dynamic Configuration Management - Enables updating service settings and runtime parameters dynamically without requiring process restarts.
- Service Health Monitoring - Collects performance metrics and inspects in-flight requests for export to external monitoring systems.
- Distributed Coordination Services - Provides primitives for distributed state management, locking, and coordination across multiple service instances.
- gRPC Microservices Integration - Integrates gRPC as the primary communication layer with built-in support for timeouts and retries.
- HTTP Traffic Handling - Processes incoming HTTP, HTTPS, and WebSocket traffic through a programmable middleware pipeline.
- gRPC Service Implementations - Provides a framework for implementing gRPC services with built-in support for middleware, timeouts, and retries.
- Coroutine-Based Asynchronous I/O - Utilizes coroutines to manage high-concurrency I/O and avoid expensive operating system thread blocks.
- Asynchronous Frameworks - Implements a high-performance C++ framework utilizing coroutines and event-loop I/O for scalable asynchronous services.
- Backend Application Platforms - Provides a full-featured toolkit for production-grade backend apps with integrated logging, metrics, and tracing.
- Non-blocking IO Architectures - Architects non-blocking drivers for network and database operations to maximize worker thread efficiency.
- Event-Driven I/O - Employs an event-loop based network I/O model to handle multiple simultaneous TCP connections.
- Cloud Native Observability - Provides integrated metrics, tracing, and live profiling for monitoring health in cloud-native production environments.
- Asynchronous Server Support - Provides a high-performance non-blocking execution environment optimized for asynchronous microservices.
- Non-Relational Data Storage - Provides non-blocking integration for interacting with NoSQL databases.
- Relational Database Drivers - Implements drivers for executing queries and managing transactions across SQL-compatible databases.
- gRPC Interceptor Libraries - Implements gRPC client interceptors for shared logic including authentication, rate limiting, and tracing.
- Schema-Driven Code Generators - Generates strongly typed C++ structures by parsing external JSON and SQL definitions.
- Schema-Based Code Generators - Automatically creates C++ types and logic from JSON schemas and SQL files.
- Chaos Engineering Frameworks - Ships tools for simulating unpredictable failures and network instabilities to verify system fault tolerance.
- Backend Resilience Toolsets - Includes dynamic configuration updates and chaos testing support to ensure high availability and fault tolerance.
- Asynchronous Task Managers - Manages the construction and cancellation of asynchronous tasks using low-level synchronization.
- Background Task Schedulers - Executes periodic background work using distributed locks to ensure data consistency.
- Dependency Injection - Organizes service logic into reusable components with managed lifecycles via dependency injection.
- Request Interception Middleware - Implements a middleware-based request interception chain for authentication, logging, and tracing.
- Live Process Profilers - Allows analysis of memory usage and debugging of running processes in a live production environment.
- Service Utility Components - Provides high-level utility tools for implementing local caches, distributed locking, and observability primitives.
- DevOps & Infrastructure - Production-ready asynchronous framework
- Web Development - Asynchronous framework for microservices.
- Web Frameworks - Asynchronous framework for building efficient microservices and utilities.
