CoSky Discovery vs Traditional Service Registries: Architecture and Performance Comparison

CoSky discovery is a Redis-backed, ultra-lightweight service registry that eliminates dedicated server processes by leveraging existing Redis infrastructure, delivering 100K+ TPS and 70M+ QPS through client-side caching and Pub/Sub notifications.

CoSky discovery, part of the ahoo-wang/cosky repository, reimagines service mesh infrastructure by transforming Redis into a fully-featured service registry. Unlike traditional implementations like Eureka, Consul, Zookeeper, or Nacos that require separate server clusters, CoSky discovery operates as a client-side library with no additional operational overhead. This architecture fundamentally changes how microservices register and discover each other while maintaining full Spring Cloud compatibility.

Architectural Model: Redis vs Dedicated Servers

Traditional service registries rely on standalone server processes that maintain their own data stores, creating deployment complexity and network bottlenecks. CoSky discovery eliminates this layer entirely.

Storage Backend Elimination

In RedisServiceDiscovery.kt, CoSky discovery stores all service instance data directly in Redis using Lua scripts for atomic operations. Traditional registries like Eureka or Consul require provisioning dedicated server instances with their own storage mechanisms—whether in-memory maps, Raft logs, or MySQL databases. CoSky discovery simply requires access to an existing Redis cluster you already operate for caching or session storage.

Process Architecture Comparison

The core implementation in cosky-discovery/src/main/kotlin/me/ahoo/cosky/discovery/redis/RedisServiceDiscovery.kt communicates directly with Redis, removing the network hop to a registry server. Traditional architectures force clients to communicate with registry servers via HTTP or custom protocols, adding latency and creating potential single points of failure. CoSky discovery clients maintain local caches synchronized via Redis Pub/Sub, enabling zero-latency reads after initial fetch.

Consistency Model: Hybrid CP-AP Implementation

Traditional registries force a choice between strong consistency (CP) like Zookeeper or availability (AP) like Eureka. CoSky discovery provides both through a hybrid approach implemented in ConsistencyRedisServiceDiscovery.kt.

The consistency layer uses Redis Lua scripts defined in DiscoveryRedisScripts.kt to guarantee atomic writes while maintaining high availability for reads. This differs from traditional CP registries that require leader elections and quorum reads, or AP registries that sacrifice consistency for availability. The Lua scripts ensure that service registration updates are atomic across the Redis cluster, preventing race conditions without blocking read operations.

Performance Characteristics

Benchmarks included in the CoSky repository demonstrate significant performance advantages over traditional registry implementations.

Throughput Benchmarks

CoSky discovery achieves 100,000+ TPS for discovery operations and 70 million+ QPS for cache refresh operations according to JMH benchmarks. Traditional registries typically operate in the low-thousands TPS range due to network overhead between clients and registry servers, consistency checks, and gossip protocols. The performance gap stems from CoSky's direct Redis access and local caching strategy versus the multi-hop architectures of Eureka or Consul.

Client-Side Caching Mechanism

Each microservice maintains a local cache refreshed instantly via Redis Pub/Sub notifications. When a service instance registers or deregisters, the RedisServiceDiscovery implementation publishes changes to a Redis channel, and all listening clients update their local caches immediately. Traditional registries rely on periodic polling (such as Eureka's 30-second heartbeat) or long-polling mechanisms that introduce stale data windows.

Spring Cloud Integration

CoSky discovery provides seamless Spring Cloud integration through auto-configuration, implementing the same interfaces developers expect from traditional registries.

Service Registry Implementation

The CoSkyServiceRegistry.kt file implements Spring Cloud's ServiceRegistry interface, while CoSkyDiscoveryClient.kt implements DiscoveryClient. This allows drop-in replacement for Eureka or Consul clients without changing application code.

Registering a service requires only the Spring Cloud starter dependency:

// build.gradle.kts
implementation("me.ahoo.cosky:spring-cloud-starter-cosky-discovery:${coskyVersion}")

import org.springframework.cloud.client.discovery.EnableDiscoveryClient
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
@EnableDiscoveryClient // Automatically configures CoSkyDiscoveryClient
class DemoApplication

fun main(args: Array<String>) {
    runApplication<DemoApplication>(*args)
}

The CoSkyServiceRegistry automatically registers the instance in Redis when the application context starts, handling heartbeats through the client-side mechanism rather than requiring a separate health-check server.

Low-Level API Usage

For direct integration without Spring Cloud, use RedisServiceDiscovery:

import me.ahoo.cosky.discovery.ServiceInstance
import me.ahoo.cosky.discovery.redis.RedisServiceDiscovery
import org.springframework.data.redis.core.ReactiveStringRedisTemplate
import reactor.core.publisher.Mono

fun registerInstance(
    redisTemplate: ReactiveStringRedisTemplate, 
    instance: ServiceInstance
): Mono<Boolean> {
    val discovery = RedisServiceDiscovery(redisTemplate)
    // Atomic registration using Lua scripts + Pub/Sub notification
    return discovery.serviceRegistry.register(instance)
}

Querying services leverages the local cache for immediate results:

val discovery = RedisServiceDiscovery(redisTemplate)

// List all services
discovery.getServices()
    .subscribe { println("Service: $it") }

// Get instances for specific service
discovery.getInstances(serviceId = "order-service")
    .subscribe { println("Instance: $it") }

All lookups hit the local cache first, with Redis Pub/Sub ensuring cache consistency across the cluster in real-time.

Operational Advantages

Beyond performance, CoSky discovery reduces operational complexity compared to traditional registries.

Zero-Ops Deployment

Traditional registries require provisioning, monitoring, and scaling dedicated server clusters. CoSky discovery requires only a Redis connection string—leveraging infrastructure you already maintain. The ServiceDiscovery.kt interface abstracts the underlying storage, but the Redis implementation eliminates the need for health-check endpoints or heartbeat servlets required by Eureka or Consul servers.

Cross-Registry Synchronization

The CoSky-Mirror module enables real-time bidirectional synchronization between CoSky discovery and traditional registries like Nacos. This allows gradual migration from existing infrastructure without service interruption. Traditional registries typically require external adapters or manual scripts for cross-registry synchronization.

Scalability Characteristics

CoSky discovery scales horizontally with your Redis cluster. Adding more service instances increases read capacity through local caching rather than overwhelming a central registry server. Traditional registries face scaling challenges around leader election, gossip traffic, and connection limits on registry servers.

Summary

• CoSky discovery eliminates dedicated registry servers by using Redis as the backing store, reducing deployment complexity and infrastructure costs.
• Performance reaches 100K+ TPS and 70M+ QPS through local caching and Redis Pub/Sub, compared to low-thousands TPS for traditional registries.
• Consistency is achieved through Lua scripts in ConsistencyRedisServiceDiscovery.kt, providing hybrid CP-AP behavior without the latency penalties of leader elections.
• Integration maintains full Spring Cloud compatibility via CoSkyServiceRegistry and CoSkyDiscoveryClient, enabling drop-in replacement for Eureka or Consul.
• Operations require no separate server maintenance, with client-side heartbeats and the CoSky-Mirror module supporting migration scenarios.

Frequently Asked Questions

How does CoSky discovery handle service instance health checks?

CoSky discovery uses a client-beat mechanism where service instances update their status in Redis directly, eliminating the need for a separate health-check server. The RedisServiceDiscovery implementation tracks instance status through Redis keys with TTL (Time-To-Live), and the Pub/Sub system notifies all clients immediately when an instance fails to renew its registration. This contrasts with traditional registries like Eureka that require a dedicated server-side health-check servlet and heartbeats.

Can CoSky discovery replace Eureka in an existing Spring Cloud application?

Yes, CoSky discovery provides drop-in replacement capabilities. By adding spring-cloud-starter-cosky-discovery to your classpath and configuring Redis connection properties, the CoSkyServiceRegistry and CoSkyDiscoveryClient automatically implement Spring Cloud's ServiceRegistry and DiscoveryClient interfaces. Your existing @EnableDiscoveryClient annotations and DiscoveryClient autowiring continue to work without code changes, though you must remove Eureka-specific dependencies.

What happens if the Redis cluster becomes unavailable?

Since CoSky discovery maintains a local cache on each client, services can continue operating with the last known service registry state during brief Redis outages. However, new registrations and deregistrations will fail until connectivity restores. This provides better availability than traditional CP registries like Zookeeper, where client caches might be disabled or stale, though with similar behavior to AP registries during network partitions.

How does CoSky discovery ensure consistency across multiple Redis nodes?

The implementation uses Redis Lua scripts defined in DiscoveryRedisScripts.kt to execute atomic operations for service registration and deregistration. The ConsistencyRedisServiceDiscovery class wraps these operations to ensure that writes are strongly consistent across the Redis cluster while reads are served from the local cache. This hybrid approach allows CoSky discovery to provide immediate consistency for critical operations without requiring leader elections or quorum reads typical of traditional CP registries.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}