line/armeria

Features

• Netty-Based Servers - Uses a non-blocking event-driven model based on Netty to handle many concurrent connections with few threads.
• Multi-Protocol - Functions as a unified server capable of hosting gRPC, Thrift, and REST services on a single port.
• Multi-Protocol Servers - Runs gRPC, Thrift, GraphQL, and HTTP on a single unified server to streamline communication.
• Thread Pool Offloading - Moves blocking synchronous service logic from the network event loop to a dedicated worker thread pool.
• Service Discovery Clients - Integrates with DNS, ZooKeeper, and Consul to enable autonomous client-side service discovery and routing.
• Service Meshes - Implements service mesh capabilities including client-side load balancing and circuit breakers for resilient microservice communication.
• Apache Thrift Integrations - Facilitates communication with remote services using the Apache Thrift binary protocol for efficient data exchange.
• Hybrid RPC Hosting - Runs both gRPC and Thrift implementations over HTTP/1 and HTTP/2 using official compilers and clients.
• Thrift RPC Servers - Serves remote procedure calls over HTTP using binary, compact, JSON, or text serialization formats via Thrift.
• Dynamic Service Discovery - Locates available service instances in real-time using external sources like DNS or service registries.
• gRPC Client Implementations - Provides the ability to execute remote procedure calls over HTTP/2 to trigger actions on a remote server.
• gRPC Implementations - Implements remote procedure calls using gRPC with support for multiple serialization formats and clients.
• gRPC-Web Bridging - Supports communication via HTTP/1.1, HTTP/2, and gRPC-Web to bridge various client formats to the server.
• JSON Transcoding - Converts gRPC service calls into JSON-based HTTP requests to enable compatibility with web clients.
• HTTP/2 Support - Handles connections via TLS or cleartext and supports protocol upgrades from HTTP/1 to HTTP/2.
• HTTP Client Integrations - Enables sending requests to RESTful endpoints using a base URI and relative paths to retrieve or update data.
• Client-Side Load Balancing - Implements client-side logic to distribute outgoing requests across multiple cluster nodes without a central proxy.
• Multi-Protocol Service Publishing - Exposes a single service implementation across multiple communication protocols including HTTP, gRPC, and Thrift.
• Single Port Protocol Multiplexing - Routes multiple RPC protocols like gRPC and Thrift over a single port by inspecting request headers and payloads.
• gRPC Service Implementations - Hosts gRPC services supporting multiple serialization formats and protocols for diverse client communication.
• Reactive RPC Clients - Ships reactive RPC clients with built-in support for circuit breakers, retries, and backpressure.
• Multi-Protocol Hosting - Runs gRPC, Thrift, and REST services on a single server and port to simplify network architecture.
• Single-Port Multi-Protocol Support - Hosts gRPC, Thrift, REST, and static files on one port to eliminate the need for external proxies.
• Non-Blocking I/O Interfaces - Uses reactive streams and non-blocking connection pools to prevent application stalling under high load.
• Reactive Application Development - Builds non-blocking services using reactive streams to handle high concurrency and prevent application stalling.
• Interceptor Middleware - Processes requests and responses through a sequence of reusable decorators to handle cross-cutting concerns like authentication.
• Resiliency & Observability Patterns - Combines circuit breakers, client-side load balancing, and health checks to ensure microservice system stability.
• Reactive Data Streams - Regulates data flow between producers and consumers using backpressure to prevent memory exhaustion during high-load streaming.
• RPC Debugging Consoles - Provides an integrated web console for discovering and executing remote procedure calls using human-friendly JSON.
• RPC Debugging Consoles - Provides a web-based interface to browse available remote methods and execute calls using human-friendly JSON.
• Blocking Task Offloaders - Provides mechanisms to offload synchronous service logic to dedicated thread pools to prevent event loop starvation.
• Request Retries - Automatically resends failed network requests based on specific error responses to improve system reliability.
• RPC Service Documentation - Produces interactive documentation pages that allow users to verify server status and test RPC calls.
• Resiliency Decorators - Wraps requests and responses with logic for circuit breakers and retries to improve service resilience.
• Client-Side Load Balancing - Distributes outgoing requests across discovered service instances based on health checks and weighting without a central proxy.
• Service Endpoint Distribution Strategies - Supports advanced traffic distribution strategies like weighted round-robin and sticky sessions for discovered service endpoints.
• Registry-Based Service Discovery - Retrieves backend server information from external registries such as ZooKeeper, Eureka, and Consul.
• DNS-Based Service Discovery - Resolves backend server lists using DNS A and SRV records with automatic TTL-based refreshes.
• Reflection Services - Exposes a reflection service that allows clients to discover available services and methods hosted by the server.
• RPC Traffic Debugging - Provides a web-based interface for inspecting and debugging remote procedure call traffic using JSON.
• Circuit Breakers - Stops traffic to unhealthy service instances to prevent cascading failures across the distributed system.
• Backpressure Management - Regulates data flow between producers and consumers using backpressure to prevent memory exhaustion during large response streaming.
• Health-Based Endpoint Filtering - Performs periodic health checks to remove unhealthy servers from the active request rotation.
• Automatic Service Registrations - Broadcasts server information to a discovery service upon startup to enable automated client routing.
• Distributed Observability Systems - Integrates distributed tracing, metrics collection, and health checks to monitor performance across multiple service boundaries.
• gRPC Service Observability - Tracks performance metrics and operational health specifically for hosted gRPC services.
• Distributed Tracing - Tracks requests across multiple service boundaries using distributed tracing to analyze execution flow.
• Service Metrics Monitoring - Collects and tracks runtime performance and health indicators on both server and client sides.
• Service Method Mapping - Maps HTTP methods and paths to logic using annotations to implement standard CRUD operations.
• Request Interception Middleware - Allows wrapping clients to modify outgoing requests or responses before they reach the destination.
• Service Middleware Pipelines - Enables the application of middleware functions to intercept or modify requests and responses in a specific sequence.
• Microservices and Messaging - Asynchronous RPC/REST framework for building microservices.
• Language Frameworks - Asynchronous RPC/REST library for Java.
• Microservices - Asynchronous RPC/REST client and server library.
• Network Programming - Asynchronous RPC/API client/server library.

Star history