nacos

Enables services to self-register with Nacos via HTTP or gRPC APIs, exposing metadata (IP, port, weight, health status) that other services query for dynamic discovery. Uses a dual-protocol architecture (HTTP REST + gRPC) with real-time push notifications to clients when service instances change, eliminating polling overhead. Supports both pull-based queries and push-based subscriptions through a bidirectional RPC communication framework with ability negotiation.

Provides a centralized configuration repository where applications retrieve and subscribe to configuration changes via HTTP or gRPC without requiring restarts. Uses a versioned, namespace-aware storage model with support for multiple formats (properties, YAML, JSON, XML) and change notifications delivered through long-polling or push subscriptions. Configuration is persisted in a pluggable storage backend (Derby, MySQL, external databases) with cluster-wide consistency via Raft or custom consensus protocols.

Provides pluggable authentication mechanisms (username/password, LDAP, custom) with token-based authorization for API access. Implements role-based access control (RBAC) at the namespace and resource level. Supports both server-level authentication and fine-grained permission checks for configuration and service management operations.

Exposes operational metrics (request latency, error rates, instance health, cluster replication lag) via Prometheus-compatible endpoints and integrates with monitoring systems. Includes built-in dashboards for Grafana and supports custom metric collection via a metrics registry. Tracks health check results, configuration change events, and cluster synchronization metrics.

Synchronizes Kubernetes services with Nacos naming service via the nacos-k8s-sync module, enabling bidirectional service discovery between K8s and Nacos. Watches Kubernetes service endpoints and automatically registers/deregisters them in Nacos, and exposes Nacos services as Kubernetes DNS entries. Supports namespace mapping and service name transformation rules.

Exposes registered service instances as DNS A records, enabling applications to discover services via standard DNS queries without vendor-specific APIs. Supports weighted DNS responses where instance weight determines probability of selection, and integrates with Kubernetes DNS for seamless K8s service discovery. Uses a DNS server component that queries the naming service backend and returns weighted responses based on instance metadata.

Maintains consistency across Nacos server clusters using pluggable consensus protocols (Raft, custom implementations) that replicate configuration and naming data across all nodes. Uses a member discovery mechanism to identify cluster peers via configuration or dynamic detection, and implements a communication framework (RPC client/server) for inter-node synchronization. Supports both strong consistency (Raft) and eventual consistency modes depending on deployment requirements.

Performs server-side health checks on registered service instances using configurable strategies (TCP connection, HTTP endpoint, or no check) at regular intervals. Marks unhealthy instances as unavailable and removes them from service discovery results, preventing traffic routing to failed services. Integrates with the monitoring system to expose health metrics and supports custom health check plugins for specialized requirements.

Provides a unified RPC communication layer supporting both HTTP REST and gRPC protocols for client-server and server-server communication. Implements ability negotiation to determine which protocols both endpoints support, enabling graceful degradation and backward compatibility. Uses a connection pool and request/response marshaling abstraction that allows protocol switching without changing application code.

Enables bulk import/export of configurations in multiple formats (properties, YAML, JSON, XML) with validation against schema or custom rules before persistence. Supports configuration templates and variable substitution for environment-specific deployments. Includes conflict detection and merge strategies for importing configurations into existing namespaces.

Provides a registry for AI model capabilities and Model Context Protocol (MCP) tool definitions, enabling AI agents to discover and invoke available tools and services. Stores capability metadata (name, description, parameters, return types) and supports dynamic registration of new capabilities without server restart. Integrates with the naming service to map capabilities to service instances and enable capability-based routing.

Provides a web-based dashboard for managing services, configurations, clusters, and users. Implements a Vue.js frontend with REST API backend for CRUD operations on all Nacos resources. Includes real-time monitoring of service health, configuration changes, and cluster status with search and filtering capabilities.

Abstracts the storage layer with a pluggable architecture supporting multiple backends (embedded Derby, MySQL, PostgreSQL, custom implementations). Uses a data access layer (mapper pattern) that isolates storage-specific logic from business logic. Supports both embedded single-node deployments and external database backends for cluster deployments.