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.

userver-frameworkuserver

Features

Star history