服务发现与配置中心

服务提供者                    注册中心                    服务消费者
    |                           |                           |
    |--1. 服务注册------------->|                           |
    |   (服务名,IP,端口)        |                           |
    |                           |                           |
    |--2. 心跳续约------------->|                           |
    |   (定时发送)              |                           |
    |                           |                           |
    |                           |<--3. 订阅服务-------------|
    |                           |   (服务名)                |
    |                           |                           |
    |                           |--4. 返回实例列表--------->|
    |                           |   (IP列表)                |
    |                           |                           |
    |                           |--5. 实例变更推送--------->|
    |   (实例下线)              |   (推送新列表)            |
    |                           |                           |

服务消费者                    注册中心                    服务提供者
    |                           |                           |
    |--查询实例列表------------>|                           |
    |<--返回所有实例-------------|                           |
    |                           |                           |
    |--选择实例(负载均衡)-------|                           |
    |                           |                           |
    |--------------------------直接调用--------------------->|
    |                           |                           |

服务消费者                    负载均衡器/网关            注册中心        服务提供者
    |                           |                           |               |
    |--调用服务名-------------->|                           |               |
    |                           |--查询实例列表------------>|               |
    |                           |<--返回实例列表-------------|               |
    |                           |--负载均衡选择实例---------|               |
    |                           |--------------------------直接调用------->|
    |<--返回响应----------------|                           |               |

// Spring Cloud Nacos 服务注册示例
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# application.yml
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: public
        group: DEFAULT_GROUP
        metadata:
          version: 1.0.0
          zone: beijing

spring:
  cloud:
    nacos:
      discovery:
        heart-beat-interval: 5000      # 心跳间隔 5秒
        heart-beat-timeout: 15000      # 心跳超时 15秒
        ip-delete-timeout: 30000       # IP删除超时 30秒

@RestController
public class HealthController {
    
    @GetMapping("/health")
    public Map<String, Object> health() {
        Map<String, Object> health = new HashMap<>();
        health.put("status", "UP");
        health.put("db", checkDatabase() ? "UP" : "DOWN");
        health.put("redis", checkRedis() ? "UP" : "DOWN");
        return health;
    }
}

spring:
  cloud:
    nacos:
      discovery:
        health-check-enabled: true
        health-check-interval: 10000

消费者启动
    ↓
订阅服务实例列表
    ↓
缓存到本地内存
    ↓
┌──────┐
│ 定时更新 ←─────┐
└──────┘         │
    ↓            │
变更通知 ─────────┘
    ↓
更新本地缓存
    ↓
触发负载均衡器刷新

@Configuration
public class LoadBalancerConfig {
    
    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            Environment environment, 
            LoadBalancerClientFactory factory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(
            factory.getLazyProvider(name, ServiceInstanceListSupplier.class), 
            name
        );
    }
}

spring:
  cloud:
    loadbalancer:
      ribbon:
        enabled: false  # 禁用 Ribbon,使用 Spring Cloud LoadBalancer
      configurations: random  # 使用随机负载均衡

┌─────────────────────────────────────────────────────────┐
│                      Nacos Console                       │
│                    (管理控制台)                           │
└─────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────┐
│                     Nacos Server                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │  Open API    │  │  Config      │  │  Naming      │  │
│  │  (HTTP API)  │  │  Service     │  │  Service     │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
│  ┌────────────────────────────────────────────────────┐ │
│  │              Consistency Protocol                  │ │
│  │         (Raft / Distro)                            │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────┐
│                     Storage Layer                        │
│            (MySQL / Derby Embedded)                      │
└─────────────────────────────────────────────────────────┘

Namespace (命名空间)
    └── Group (分组)
        └── Service (服务)
            └── Cluster (集群)
                └── Instance (实例)

                    ┌─────────────┐
                    │   Nginx     │
                    │ (负载均衡)   │
                    └─────────────┘
                          ↓
        ┌─────────────────┼─────────────────┐
        ↓                 ↓                 ↓
┌─────────────┐   ┌─────────────┐   ┌─────────────┐
│   Nacos     │   │   Nacos     │   │   Nacos     │
│   Node 1    │   │   Node 2    │   │   Node 3    │
│  (Leader)   │   │ (Follower)  │   │ (Follower)  │
└─────────────┘   └─────────────┘   └─────────────┘
        └─────────────────┼─────────────────┘
                          ↓
                    ┌─────────────┐
                    │   MySQL     │
                    │  (主从集群)  │
                    └─────────────┘

# cluster.conf
192.168.1.1:8848
192.168.1.2:8848
192.168.1.3:8848

# 数据库配置
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://192.168.1.100:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=nacos
db.password.0=nacos

# 集群配置
nacos.member.list=192.168.1.1:8848,192.168.1.2:8848,192.168.1.3:8848

# 使用 Distro 协议
nacos.core.protocol.raft.data.enabled=false
nacos.core.protocol.distro.enabled=true

# 使用 Raft 协议
nacos.core.protocol.raft.data.enabled=true
nacos.core.protocol.distro.enabled=false

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2022.0.0.0</version>
</dependency>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2022.0.0.0</version>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    nacos:
      # 服务发现配置
      discovery:
        server-addr: 192.168.1.1:8848,192.168.1.2:8848,192.168.1.3:8848
        namespace: prod
        group: USER_GROUP
        cluster-name: BEIJING
        metadata:
          version: 1.0.0
          preserved.register.source: SPRING_CLOUD
      # 配置中心配置
      config:
        server-addr: 192.168.1.1:8848,192.168.1.2:8848,192.168.1.3:8848
        namespace: prod
        group: USER_GROUP
        file-extension: yaml
        shared-configs:
          - data-id: common.yaml
            group: COMMON_GROUP
            refresh: true

┌─────────────────────────────────────────────────────────┐
│                   Application Service                    │
│                     (服务提供者)                          │
└─────────────────────────────────────────────────────────┘
        ↓ Register/Renew/Cancel        ↑ Query
┌─────────────────────────────────────────────────────────┐
│                    Eureka Server                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │   Registry   │  │    Peer      │  │   Service    │  │
│  │   (注册表)    │  │  Replication │  │   Status     │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘
        ↑ Query                          ↓ Replicate
┌─────────────────────────────────────────────────────────┐
│                   Application Client                     │
│                     (服务消费者)                          │
└─────────────────────────────────────────────────────────┘

eureka:
  server:
    enable-self-preservation: true      # 开启自我保护
    renewal-percent-threshold: 0.85     # 续约比例阈值
    eviction-interval-timer-in-ms: 60000 # 剔除任务间隔

┌─────────────────────────────────────────────────────────┐
│                      Consul Server                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │   HTTP API   │  │    DNS       │  │    Raft      │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘
        ↓ Register           ↑ Query          ↓ RPC
┌─────────────────────────────────────────────────────────┐
│                      Consul Agent                        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │   Service    │  │   Health     │  │   Proxy      │  │
│  │   (服务)      │  │   Check      │  │  (代理)       │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘

{
  "service": {
    "name": "user-service",
    "tags": ["v1"],
    "address": "192.168.1.100",
    "port": 8080,
    "check": {
      "http": "http://192.168.1.100:8080/health",
      "interval": "10s",
      "timeout": "1s"
    }
  }
}

spring:
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: user-service
        health-check-path: /health
        health-check-interval: 10s

/services
    /user-service
        /instance-00000001 (临时节点)
            数据: {"host":"192.168.1.100","port":8080}
        /instance-00000002 (临时节点)
            数据: {"host":"192.168.1.101","port":8080}

spring:
  cloud:
    zookeeper:
      connect-string: 192.168.1.1:2181,192.168.1.2:2181,192.168.1.3:2181
      discovery:
        enabled: true
        register: true
        instance-host: 192.168.1.100
        instance-port: 8080

Namespace (命名空间)
    └── Group (分组)
        └── Data ID (配置ID)
            ├── Content (配置内容)
            ├── Version (版本号)
            ├── Create Time (创建时间)
            ├── Modify Time (修改时间)
            └── History (历史版本)

配置中心 ──推送变更──> 服务实例

服务实例 ──定时拉取──> 配置中心

服务实例 ──发起长轮询──> 配置中心
         ↓ (等待30秒)
配置变更 ──立即返回──> 服务实例

配置变更
    ↓
推送到服务实例
    ↓
触发配置刷新事件
    ↓
Spring Cloud Context 刷新
    ↓
重新绑定配置到 Bean
    ↓
业务逻辑生效

@RestController
@RefreshScope  // 支持配置动态刷新
public class ConfigController {
    
    @Value("${app.config.threshold:100}")
    private int threshold;
    
    @GetMapping("/threshold")
    public int getThreshold() {
        return threshold;
    }
}

@Configuration
public class RefreshConfig {
    
    @Bean
    @RefreshScope
    public SomeService someService() {
        return new SomeService();
    }
}

变更申请 ─> 审批 ─> 测试环境验证 ─> 预发环境验证 ─> 灰度发布 ─> 全量发布 ─> 监控观察

                    ┌─────────────┐
                    │   客户端     │
                    └─────────────┘
                          ↓
        ┌─────────────────┼─────────────────┐
        ↓                 ↓                 ↓
┌─────────────┐   ┌─────────────┐   ┌─────────────┐
│  Config     │   │  Config     │   │  Config     │
│  Server 1   │   │  Server 2   │   │  Server 3   │
└─────────────┘   └─────────────┘   └─────────────┘
        └─────────────────┼─────────────────┘
                          ↓
                    ┌─────────────┐
                    │   MySQL     │
                    │  (主从集群)  │
                    └─────────────┘

// Nacos 配置快照
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // 配置中心故障时,从本地快照加载配置
        System.setProperty("nacos.cache.enabled", "true");
        SpringApplication.run(Application.class, args);
    }
}

┌─────────────────────────────────────────────────────────┐
│                    Nacos Config                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │   Config     │  │   Config     │  │   Config     │  │
│  │   Open API   │  │   Service    │  │   History    │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘
        ↓ Pull/Push         ↑ Long Polling
┌─────────────────────────────────────────────────────────┐
│                  Spring Cloud App                        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │  Nacos       │  │  Property    │  │  Refresh     │  │
│  │  Config      │  │  Source      │  │  Scope       │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘

# bootstrap.yml
spring:
  application:
    name: user-service
  profiles:
    active: dev
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        namespace: ${spring.profiles.active}
        group: USER_GROUP
        file-extension: yaml

user-service.yaml          # 基础配置
user-service-dev.yaml      # 开发环境配置
user-service-test.yaml     # 测试环境配置
user-service-prod.yaml     # 生产环境配置
common.yaml                # 公共配置

spring:
  cloud:
    nacos:
      config:
        shared-configs:
          - data-id: common.yaml
            group: COMMON_GROUP
            refresh: true
          - data-id: redis.yaml
            group: COMMON_GROUP
            refresh: false

spring:
  cloud:
    nacos:
      config:
        extension-configs:
          - data-id: datasource.yaml
            group: INFRA_GROUP
            refresh: false
          - data-id: mybatis.yaml
            group: INFRA_GROUP
            refresh: false

app:
  config:
    threshold: 100
    enabled: true
    rules:
      - rule1
      - rule2

@Configuration
@RefreshScope
public class AppConfig {
    
    @Value("${app.config.threshold:100}")
    private int threshold;
    
    @Value("${app.config.enabled:true}")
    private boolean enabled;
    
    @Bean
    @RefreshScope
    public SomeService someService() {
        return new SomeService(threshold, enabled);
    }
    
    // getter methods
}

@Component
public class ConfigChangeListener {
    
    @NacosConfigListener(dataId = "user-service.yaml", groupId = "USER_GROUP")
    public void onConfigChange(String newConfig) {
        log.info("配置变更: {}", newConfig);
        // 处理配置变更逻辑
    }
}

                ┌─────────────┐
                │   Nginx     │
                │ (负载均衡)   │
                └─────────────┘
                      ↓
    ┌─────────────────┼─────────────────┐
    ↓                 ↓                 ↓
┌───────────┐   ┌───────────┐   ┌───────────┐
│  Nacos    │   │  Nacos    │   │  Nacos    │
│  Node 1   │◄──┤  Node 2   ├──►│  Node 3   │
│ (Leader)  │   │(Follower) │   │(Follower) │
└───────────┘   └───────────┘   └───────────┘
    └─────────────────┼─────────────────┘
                      ↓
                ┌─────────────┐
                │   MySQL     │
                │  (主从)      │
                └─────────────┘

机房A                          机房B
┌─────────────────┐          ┌─────────────────┐
│  Nacos Cluster  │◄────────►│  Nacos Cluster  │
│  (2节点)         │   同步    │  (2节点)         │
└─────────────────┘          └─────────────────┘
        ↓                            ↓
┌─────────────────┐          ┌─────────────────┐
│   MySQL 主      │◄────────►│   MySQL 从      │
└─────────────────┘   主从    └─────────────────┘

北京机房                      上海机房
┌─────────────────┐          ┌─────────────────┐
│  Nacos Cluster  │          │  Nacos Cluster  │
│  (独立集群)      │          │  (独立集群)      │
└─────────────────┘          └─────────────────┘
        ↓                            ↓
┌─────────────────┐          ┌─────────────────┐
│  本地服务实例    │          │  本地服务实例    │
│  (优先本地调用)  │          │  (优先本地调用)  │
└─────────────────┘          └─────────────────┘

# 全量备份
mysqldump -h 192.168.1.100 -u root -p nacos > nacos_backup.sql

# 增量备份 (binlog)
mysqlbinlog --start-datetime="2024-01-01 00:00:00" \
            --stop-datetime="2024-01-02 00:00:00" \
            mysql-bin.000001 > increment.sql

# Nacos 配置导出
curl -X GET "http://nacos:8848/nacos/v1/cs/configs?export=true&dataId=&group=&tenant=prod" \
     -o config_export.zip

1. 模拟故障 (关闭节点/断网)
    ↓
2. 观察服务行为
    - 是否从本地缓存读取配置
    - 服务是否正常启动
    ↓
3. 恢复故障
    ↓
4. 观察恢复过程
    - 配置是否自动同步
    - 服务是否自动恢复

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        # 注册中心故障时使用的兜底实例
        fallback:
          enabled: true
          instances:
            - host: 192.168.1.100
              port: 8080
            - host: 192.168.1.101
              port: 8080

// Nacos 本地快照配置
@Configuration
public class NacosConfig {
    
    @Bean
    public NacosConfigProperties nacosConfigProperties() {
        NacosConfigProperties properties = new NacosConfigProperties();
        // 开启本地快照
        properties.setCacheEnabled(true);
        return properties;
    }
}

spring:
  cloud:
    nacos:
      config:
        fail-fast: true  # 配置中心不可用时启动失败

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# application.yml
server:
  port: 8081

spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: prod
        cluster-name: BEIJING
        metadata:
          version: 1.0.0

@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    public UserDTO getUser(Long userId) {
        // 按服务名调用,无需知道具体实例地址
        return restTemplate.getForObject(
            "http://user-service/internal/users/" + userId, 
            UserDTO.class
        );
    }
}

@FeignClient(name = "user-service")
public interface UserClient {
    
    @GetMapping("/internal/users/{id}")
    UserDTO queryById(@PathVariable("id") Long id);
}

@Service
public class OrderService {
    
    @Autowired
    private UserClient userClient;
    
    public UserDTO getUser(Long userId) {
        return userClient.queryById(userId);
    }
}

# user-service.yaml (Nacos)
rate:
  limit:
    user-query: 200
    order-create: 100

@Configuration
@RefreshScope
public class RateLimitConfig {
    
    @Value("${rate.limit.user-query:200}")
    private int userQueryLimit;
    
    @Value("${rate.limit.order-create:100}")
    private int orderCreateLimit;
    
    @Bean
    @RefreshScope
    public RateLimiter userQueryLimiter() {
        return RateLimiter.create(userQueryLimit);
    }
    
    @Bean
    @RefreshScope
    public RateLimiter orderCreateLimiter() {
        return RateLimiter.create(orderCreateLimit);
    }
}

@Component
public class RateLimitInterceptor implements HandlerInterceptor {
    
    @Autowired
    private RateLimiter userQueryLimiter;
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                            HttpServletResponse response, 
                            Object handler) throws Exception {
        if (!userQueryLimiter.tryAcquire()) {
            response.setStatus(429);
            response.getWriter().write("Rate limit exceeded");
            return false;
        }
        return true;
    }
}

1. 在 Nacos 控制台修改配置
    rate.limit.user-query: 500
    ↓
2. 配置推送到服务实例
    ↓
3. 触发配置刷新事件
    ↓
4. RateLimitConfig 重新创建
    ↓
5. 新的限流阈值生效
    ↓
6. 无需重启服务

Nacos
├── dev (命名空间)
│   ├── user-service.yaml
│   └── order-service.yaml
├── test (命名空间)
│   ├── user-service.yaml
│   └── order-service.yaml
└── prod (命名空间)
    ├── user-service.yaml
    └── order-service.yaml

# bootstrap.yml
spring:
  profiles:
    active: dev  # 切换环境只需修改这里
  cloud:
    nacos:
      config:
        namespace: ${spring.profiles.active}

# 灰度实例配置
spring:
  cloud:
    nacos:
      discovery:
        metadata:
          gray: true
          version: 2.0.0

@Configuration
@ConditionalOnProperty(name = "gray.enabled", havingValue = "true")
@RefreshScope
public class GrayConfig {
    
    @Value("${gray.feature.enabled:false}")
    private boolean featureEnabled;
    
    @Bean
    public FeatureService featureService() {
        return new FeatureService(featureEnabled);
    }
}

@Configuration
public class GrayLoadBalancerConfig {
    
    @Bean
    ReactorLoadBalancer<ServiceInstance> grayLoadBalancer(
            Environment environment,
            LoadBalancerClientFactory factory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new GrayLoadBalancer(
            factory.getLazyProvider(name, ServiceInstanceListSupplier.class),
            name
        );
    }
}

public class GrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        // 优先选择灰度实例
        ServiceInstance instance = selectGrayInstance(instances);
        return Mono.just(new DefaultResponse(instance));
    }
}

@Component
public class GracefulStartup implements ApplicationRunner {
    
    @Autowired
    private NacosRegistration registration;
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 等待服务就绪
        Thread.sleep(10000);
        
        // 健康检查通过后再注册
        if (healthCheck()) {
            registration.start();
        }
    }
    
    private boolean healthCheck() {
        // 检查数据库、Redis 等依赖
        return true;
    }
}

@Component
public class ServiceWarmup implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 预热缓存
        warmupCache();
        
        // 预热连接池
        warmupConnectionPool();
        
        // 预热 JVM
        warmupJVM();
    }
}

@Component
public class GracefulShutdown implements DisposableBean {
    
    @Autowired
    private NacosRegistration registration;
    
    @Override
    public void destroy() throws Exception {
        // 1. 从注册中心注销
        registration.stop();
        
        // 2. 等待正在处理的请求完成
        Thread.sleep(30000);
        
        // 3. 关闭服务
    }
}

# deployment.yaml
spec:
  template:
    spec:
      containers:
      - name: user-service
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 30"]
      terminationGracePeriodSeconds: 60

# 测试 Nacos 连通性
curl http://nacos:8848/nacos/v1/ns/service/list?pageNo=1&pageSize=10

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 正确的地址
        namespace: 正确的命名空间
        enabled: true  # 是否启用服务发现

# 查看 Nacos 客户端日志
tail -f logs/nacos/nacos-discovery.log

# 查询服务实例列表
curl "http://nacos:8848/nacos/v1/ns/instance/list?serviceName=user-service"

# 查询实例详情
curl "http://nacos:8848/nacos/v1/ns/instance?serviceName=user-service&ip=192.168.1.100&port=8080"

# 测试实例连通性
curl http://192.168.1.100:8080/health

# 查询实例列表
curl "http://nacos:8848/nacos/v1/ns/instance/list?serviceName=user-service"

spring:
  cloud:
    nacos:
      discovery:
        heart-beat-timeout: 15000  # 心跳超时
        ip-delete-timeout: 30000   # IP 删除超时

# Data ID 格式
${spring.application.name}-${spring.profiles.active}.${file-extension}

# 示例
user-service-dev.yaml

spring:
  cloud:
    nacos:
      config:
        namespace: 正确的命名空间
        group: 正确的分组

# 测试 Nacos 连通性
curl http://nacos:8848/nacos/v1/console/health/readiness

spring:
  cloud:
    nacos:
      config:
        server-addr: 正确的地址
        namespace: 正确的命名空间

spring:
  cloud:
    nacos:
      config:
        fail-fast: false  # 关闭快速失败,使用本地快照

# 查询集群节点状态
curl "http://nacos:8848/nacos/v1/ns/operator/servers"

# 查询 Raft 状态
curl "http://nacos:8848/nacos/v1/ns/raft/state"

# cluster.conf
# 确保所有节点配置一致
192.168.1.1:8848
192.168.1.2:8848
192.168.1.3:8848

# AP 模式 (默认)
nacos.core.protocol.raft.data.enabled=false
nacos.core.protocol.distro.enabled=true

# CP 模式
nacos.core.protocol.raft.data.enabled=true
nacos.core.protocol.distro.enabled=false