Maxine — Service Registry, Discovery & Operational Control Plane

Designed for Ultimate Resilience

Everything you need for seamless name resolution and control plane coordination inside Node.js microservices.

Pluggable Registry State

Run in local memory with persistent snapshots for simplicity, or leverage Redis-backed state modes for production multi-replica synchronization.

Dual Discovery Modes

Choose Redirect Mode to keep Maxine out of your active data path, or Proxy Mode to gain request control, custom routing, and unified auditing.

Redis Lease Leadership

Coordinate leader-protected mutations securely using Redis lease-based leader election backed by distributed fencing tokens.

Active Health Probes

Keep your upstream healthy. Evict unresponsive nodes automatically based on configurable background HTTP health probes.

RBAC Secured Actuators

Expose health, traces, audit logs, and Prometheus metrics safely through built-in RBAC roles (Viewer, Operator, Admin).

Multi-language SDKs

Integrate quickly with lightweight libraries built for Node.js, Go, Python, and Java (including Spring Boot starter support).

Try Live Load Balancing

Simulate how Maxine balances traffic between registered service nodes. Click the resolve button to trigger a discovery request, utilizing round robin balancing to allocate requests to upstream nodes according to their relative weight configurations.

node-a (Weight: 2) 0 requests

node-b (Weight: 1) 0 requests

CONSUMER REQUEST

👤 Consumer App

⚡ Maxine Registry

📦 node-a (w:2)

📦 node-b (w:1)

Simple Integration

Get up and running with a few lines of code. Register and discover services inside your application codebase.

client.js

const { MaxineClient } = require('@vrushankpatel/maxine-client');

async function main() {
  const client = new MaxineClient({ baseUrl: 'http://localhost:8080' });
  await client.signIn('admin', 'admin');

  // Register this service node
  await client.register({
    hostName: '127.0.0.1',
    nodeName: 'orders-node-a',
    serviceName: 'orders',
    port: 9000,
    ssl: false,
    timeOut: 5,
    weight: 2
  });

  // Discover another service endpoint
  const discovery = await client.discoverLocation('orders', '/health');
  console.log(discovery.location); // http://127.0.0.1:9000/health
}
                

package main

import (
    "fmt"
    "log"
    maxine "github.com/VrushankPatel/Maxine/client-sdk/go"
)

func main() {
    client := maxine.NewClient("http://localhost:8080")
    if _, err := client.SignIn("admin", "admin"); err != nil {
        log.Fatal(err)
    }

    registration := map[string]any{
        "hostName":    "127.0.0.1",
        "nodeName":    "orders-node",
        "serviceName": "orders-service",
        "port":        8081,
        "ssl":         false,
        "timeOut":     10,
        "weight":      1,
    }

    if _, err := client.Register(registration); err != nil {
        log.Fatal(err)
    }
}
                

from maxine_client import MaxineClient

client = MaxineClient("http://localhost:8080")
client.sign_in("admin", "admin")

registration = {
    "hostName": "127.0.0.1",
    "nodeName": "orders-node",
    "serviceName": "orders-service",
    "port": 8081,
    "ssl": False,
    "timeOut": 10,
    "weight": 1,
}

client.register(registration)
                

MaxineClient client = new MaxineClient("http://localhost:8080");
client.signIn("admin", "admin");

Map<String, Object> registration = Map.of(
    "hostName", "127.0.0.1",
    "nodeName", "node-a",
    "serviceName", "orders",
    "port", 9000,
    "ssl", false,
    "timeOut", 5,
    "weight", 1
);

client.register(registration);
                

The Node.js Control Plane & Service Registry