Projects sharing features with Stolon

Pigsty is a full-stack orchestration suite for deploying, monitoring, and managing high-availability PostgreSQL clusters and their supporting infrastructure. It functions as a cluster management platform and high-availability suite that automates failover, manages virtual IPs, and ensures data consistency through distributed consensus. The project distinguishes itself by providing a comprehensive database infrastructure-as-code framework and a dedicated observability stack. It incorporates a backup and recovery manager supporting point-in-time recovery via S3-compatible object storage, alongs

Spring Cloud Gateway is an API gateway and routing service built on Spring Boot. It acts as a central entry point for microservices, directing incoming HTTP traffic to downstream services using a combination of predicates and filters. The project is a non-blocking request router that leverages Netty and Project Reactor to handle high-concurrency traffic via asynchronous data streams. It functions as a dynamic request router and network traffic filter, allowing for the automated detection of and routing to available service instances in dynamic network environments. The gateway manages micros

CloudNativePG is a Kubernetes operator designed for the administration, lifecycle management, and high availability of PostgreSQL database clusters. It functions as a declarative orchestrator that manages database instances through custom resources and manifests. The project distinguishes itself by automating complex operational tasks, including primary election and failover management via streaming physical replication. It provides specialized tools for database version migrations, supporting both offline in-place upgrades and online migrations through logical replication. The operator cove

Higress is an AI API gateway and cloud-native traffic manager that functions as a Kubernetes ingress controller. It provides a centralized system for routing, securing, and optimizing traffic directed toward large language models, AI agents, and microservice architectures. The project distinguishes itself through deep AI orchestration, including the ability to host and manage Model Context Protocol servers that transform REST APIs into tools for AI agents. It features specialized AI infrastructure for model request proxying, protocol translation across multiple providers, and semantic-based c

This project is a reference implementation of microservices architectures using the Spring Cloud ecosystem. It provides a set of example services that demonstrate the construction of distributed systems through automated service discovery, dynamic routing, and shared configuration. The implementation covers core distributed patterns, including a service discovery system for tracking network components and an API gateway for orchestrating incoming traffic. It features a centralized configuration manager to propagate application settings across multiple instances and a distributed tracing syste

m3 is a distributed time series database designed for high-resolution metrics and high-cardinality data management. It functions as a scalable storage system and a multi-cluster query engine, providing a distributed metrics aggregator capable of downsampling and summarizing data before it is committed to storage. The project distinguishes itself through a coordinated cluster model using etcd for node membership and shard placement. It supports multiple ingestion protocols, including the Prometheus remote write protocol, InfluxDB line protocol, and Graphite Carbon plaintext protocol, and provi

Autobase is a self-hosted database-as-a-service platform designed to automate the deployment, scaling, and administration of high-availability PostgreSQL clusters. It functions as a cluster orchestrator that handles replication, failover, and version upgrades across multiple servers. The platform is distinguished by its GitOps-driven approach, using version control and CI/CD pipelines as the single source of truth to automate database configurations and deployments. It provides both a web-based management interface and a command-line tool for provisioning and monitoring clusters. The system

LiteFS is a FUSE-based distributed file system designed to replicate SQLite databases across a cluster of machines. It functions as a high availability layer that synchronizes data by intercepting write operations to ensure consistency across multiple server nodes. The system manages distributed database storage by mapping file operations to network requests via a user-space driver. This allows for multi-region data synchronization and the distribution of database content to edge nodes, facilitating local reads with synchronized global writes. The replication process utilizes write-ahead log

Patroni is a high availability manager and cluster orchestrator for PostgreSQL. It functions as an automatic failover controller and replication manager that ensures continuous database availability by automating leader election and promoting standby nodes during failures. The system maintains a consistent cluster state by acting as a distributed consensus coordinator. It synchronizes configuration and manages leader elections through integration with distributed configuration stores such as etcd, ZooKeeper, or Consul. Its broader capabilities include managing both synchronous and asynchrono

Fabio is a network gateway that provides reverse proxying, layer 7 traffic management, and automated service discovery mapping. It functions as an HTTP reverse proxy, a gRPC and TCP proxy, and a service discovery gateway to route incoming traffic to healthy backend instances. The project distinguishes itself through deep integration with service registries, specifically acting as a Consul load balancer to automatically synchronize routing tables and update destination targets. It manages diverse traffic types using SNI-based routing for raw TCP streams and maintains full protocol compatibilit

dqlite is a distributed SQL database that embeds a relational database engine to provide replicated storage across a cluster of nodes. It functions as a replicated SQL engine designed to ensure data remains available and consistent during node failures. The system utilizes a consensus algorithm to manage leader election and synchronize a replicated log across the cluster. This approach enables automatic cluster failover and leader promotion to maintain continuous service without manual intervention. The project covers state machine replication, network-based cluster membership, and transacti

rpcx is a high-performance remote procedure call framework for building scalable microservices in Go. It functions as a binary protocol RPC system and a service mesh, providing the necessary infrastructure for low-latency inter-service communication and distributed cloud environments. The project features a cross-language service gateway that provides an HTTP entry point, allowing clients written in any programming language to invoke Go remote services via protocol translation. It also includes a specialized RPC traffic analyzer for capturing and analyzing binary packets to debug network comm

This is a learning collection of example projects that demonstrate core Spring Cloud patterns for building microservice architectures. The repository covers the fundamental building blocks of a microservices system, including service discovery through a central registry, centralized configuration management from Git or SVN repositories, API gateway-based request routing, circuit breaker patterns for fault tolerance, and distributed request tracing across service boundaries. The examples show how to implement service registration and dynamic discovery so that clients can locate microservices b

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

Traefik is a cloud-native load balancer and dynamic reverse proxy designed for microservices traffic routing. It automatically discovers services and generates network routes by listening to infrastructure changes in orchestrators and service registries. The project distinguishes itself through auto-configuring service routing, which eliminates manual configuration by updating routing rules in real time as infrastructure scales. It also provides automated SSL certificate management, utilizing ACME-based automation to request and renew certificates from remote authorities. Additional capabili

Eureka is a service registry and discovery server that serves as a coordination tool for microservices. It provides a distributed service registry where instances record their network locations and health status to enable dynamic communication without the use of hardcoded addresses. The system functions as a client-side load balancing framework, providing location data to consumers so they can distribute network traffic across available instances. It employs a heartbeat-based health monitor to track instance availability and automatically removes unresponsive nodes from the registry to manage

Registrator is a dynamic service discovery tool and metadata synchronizer that acts as a bridge between Docker containers and external service discovery registries. It automatically registers and deregisters containers in these backends to ensure that network addresses and service lists remain accurate in real time. The project utilizes a pluggable adapter architecture to support various external registry backends. It employs a formatting engine to process container labels and environment variables into structured service descriptions and uses label-based filtering to determine which containe

Apache Dubbo Go is a Go language implementation of the Apache Dubbo framework designed for building high-performance microservices. It serves as a cross-language RPC framework and microservices communication layer that enables remote procedure calls between services written in different programming languages. The framework functions as a service governance toolset and a distributed service mesh proxy, allowing data planes to connect with external control planes in proxy or proxyless modes. It specifically provides a compatibility layer to facilitate communication between Go and Java-based ser

Dubbo is a Java RPC framework and microservices governance platform designed for high-performance remote procedure calls in distributed architectures. It provides the foundational components necessary to connect distributed services across a network, including a binary data serialization library and a distributed service registry. The platform distinguishes itself through a comprehensive governance suite that manages service discovery, load balancing, and traffic routing. It enables precise control over network traffic via conditional routing and a pluggable extension mechanism based on a ser

This project is an API gateway and ingress controller designed to manage traffic, security, and service connectivity within Kubernetes environments. It operates as a controller that monitors cluster state to reconcile gateway configurations with desired infrastructure definitions, ensuring that network policies and routing rules remain consistent across distributed deployments. The system distinguishes itself through a modular request pipeline that allows for the injection of custom logic to handle transformations, security checks, and logging. It supports declarative infrastructure managemen

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

Armeria is a Netty-based microservice framework used for building high-performance asynchronous services. It functions as a multi-protocol RPC server capable of exposing gRPC, Thrift, and REST services on a single unified port. The project is distinguished by its ability to run diverse communication protocols simultaneously and its integrated RPC debugging web console, which allows for the discovery and invocation of remote procedure calls via JSON. It also includes a gRPC to JSON transcoder to enable web client compatibility with Protobuf services. The framework provides a comprehensive sui

This project is an integration framework that bootstraps Apache Dubbo remote procedure call services within Spring Boot applications. It serves as a microservice communication framework that enables the implementation of RPC services, service discovery, and distributed governance through automated configuration. The project distinguishes itself by providing a cross-language RPC bridge, allowing services written in different languages to communicate via standards such as gRPC and Protobuf. It further enables the exposure of backend microservices as REST endpoints using the Triple protocol for

pg_textsearch is a full-text search integration for PostgreSQL that provides large-scale text indexing and BM25 relevance ranking. It implements a scalable indexing architecture that uses a memtable system to spill data to disk segments, allowing for the processing of massive datasets. The project distinguishes itself through support for multilingual search via language-specific partial indexes and the ability to index complex expressions, such as JSONB fields or concatenated columns. It ensures high availability by utilizing PostgreSQL-native streaming replication and write-ahead logs to syn

LedisDB is a distributed NoSQL key-value store built in Go. It functions as a high-performance database server that persists simple values, counters, and complex data structures using pluggable storage engines. The system implements the Redis protocol to maintain compatibility with existing client libraries and drivers, while also providing an HTTP interface that exposes database functions through JSON, BSON, or msgpack formats. It includes an embedded virtual machine to execute custom server-side Lua scripts for complex operations. The platform supports high availability through data replic

RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It persists structured information as schema-flexible JSON documents and utilizes a unit-of-work session pattern to track entity changes and batch modifications into atomic transactions. The platform is built on a distributed architecture that supports horizontal scaling through sharding and ensures high availability via multi-node, master-to-master cluster replication. The database distinguishes itself through a self-optimizing query engine that automatically creates and maintains ind

pgdog is a PostgreSQL sharding proxy, distributed SQL router, and connection pooler. It is designed to enable horizontal data distribution by splitting tables and indices across multiple independent servers to scale storage and processing capacity. The project distinguishes itself through online resharding capabilities, using logical replication to move data between shards without application downtime. It supports multiple routing strategies, including hash, list, and range-based query routing, and manages distributed atomic transactions using a two-phase commit process to ensure consistency