如何将注册中心落地

{
  "serviceName": "user-service",
  "group": "production",
  "namespace": "default",
  "cluster": "beijing-zone-a",
  "instances": [
    {
      "ip": "10.0.1.101",
      "port": 8080,
      "weight": 1.0,
      "enabled": true,
      "healthy": true,
      "ephemeral": true,
      "metadata": {
        "version": "2.3.0",
        "region": "cn-north",
        "zone": "zone-a",
        "weight": "100",
        "warmup": "120000"
      }
    }
  ]
}

// Nacos 2.x gRPC 长连接注册
NamingService naming = NacosFactory.createNamingService("nacos-server:8848");

// 注册临时实例（依赖心跳保活）
naming.registerInstance("user-service", "10.0.1.101", 8080, 
    Instance.builder()
        .weight(1.0)
        .enabled(true)
        .ephemeral(true)
        .metadata(Map.of("version", "2.3.0", "zone", "zone-a"))
        .build()
);

// 注册持久实例（需主动注销）
naming.registerInstance("database-proxy", "10.0.1.200", 3306,
    Instance.builder()
        .ephemeral(false)  // 持久实例
        .build()
);

// Spring Boot 优雅停机
@PreDestroy
public void gracefulShutdown() {
    // 1. 先从注册中心注销
    namingService.deregisterInstance(serviceName, ip, port);
    
    // 2. 等待进行中的请求完成
    awaitInProgressRequests(Duration.ofSeconds(30));
    
    // 3. 关闭服务端口
    shutdownServer();
}

# Nacos Client 缓存相关配置（示意，实际配置项以官方文档为准）
nacos:
  naming:
    # 本地缓存目录
    cache-dir: /var/nacos/naming
    # 缓存刷新间隔（毫秒）
    refresh-interval: 5000
    # 快照保存间隔
    snapshot-interval: 30000
    # 失败重试次数
    retry-times: 3

// Nacos 2.x 自动使用 gRPC 长连接
NamingService naming = NacosFactory.createNamingService(properties);

// 订阅服务变更
naming.subscribe("user-service", new EventListener() {
    @Override
    public void onEvent(Event event) {
        if (event instanceof NamingEvent) {
            NamingEvent namingEvent = (NamingEvent) event;
            List<Instance> instances = namingEvent.getInstances();
            // 更新本地服务列表
            updateServiceInstances(instances);
        }
    }
});

# Nacos 2.x 集群配置
nacos:
  server:
    # gRPC 端口（主端口 + 1000）
    grpc-port: 9848
    # gRPC 间通信端口（主端口 + 1001）
    grpc-port-internal: 9849
  
  # 存储配置
  storage:
    # 内置存储（仅开发环境）
    embedded:
      enabled: false
    # MySQL 存储（生产环境）
    mysql:
      jdbc-url: jdbc:mysql://mysql:3306/nacos
      username: nacos
      password: nacos

# Consul 服务定义
service {
  name = "user-service"
  id = "user-service-1"
  tags = ["production", "v2"]
  address = "10.0.1.101"
  port = 8080
  
  # 健康检查
  check {
    id = "health-check"
    name = "HTTP Health Check"
    http = "http://10.0.1.101:8080/actuator/health"
    interval = "10s"
    timeout = "5s"
    deregister_critical_service_after = "30m"
  }
  
  # 元数据
  meta = {
    version = "2.3.0"
    zone = "zone-a"
  }
}

// etcd v3 客户端注册服务
import (
    "context"
    clientv3 "go.etcd.io/etcd/client/v3"
    "go.etcd.io/etcd/client/v3/concurrency"
)

func RegisterService(client *clientv3.Client, serviceName, instanceID, addr string, ttl int) error {
    ctx := context.Background()
    
    // 创建 Session（基于 Lease）
    session, err := concurrency.NewSession(client,
        concurrency.WithTTL(ttl),
    )
    if err != nil {
        return err
    }
    
    // 注册服务实例
    key := fmt.Sprintf("/services/%s/%s", serviceName, instanceID)
    _, err = client.Put(ctx, key, addr, clientv3.WithLease(session.Lease()))
    
    // concurrency.Session 已内置 Lease 自动续约（KeepAlive），无需额外心跳
    return err
}

# Headless Service（无 ClusterIP）
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  clusterIP: None  # Headless
  selector:
    app: user-service
  ports:
  - port: 8080
---
# EndpointSlice 自动管理
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: user-service-xyz
  labels:
    kubernetes.io/service-name: user-service
addressType: IPv4
ports:
  - port: 8080
endpoints:
  - addresses:
      - "10.244.1.5"
    conditions:
      ready: true

# Dubbo 3 多注册中心配置
dubbo:
  registries:
    nacos-registry:
      address: nacos://nacos-prod:8848
      group: production
    consul-registry:
      address: consul://consul-prod:8500
      group: production
  
  # 服务注册到多个注册中心
  provider:
    registry-ids: nacos-registry,consul-registry
  
  # 消费者从多个注册中心订阅
  consumer:
    registry-ids: nacos-registry,consul-registry

// 并行订阅优化
public class ParallelServiceSubscriber {
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
    
    public void subscribeServices(List<String> serviceNames) {
        List<CompletableFuture<Void>> futures = serviceNames.stream()
            .map(serviceName -> CompletableFuture.runAsync(() -> {
                try {
                    namingService.subscribe(serviceName, eventListener);
                } catch (Exception e) {
                    log.warn("Subscribe {} failed, will retry", serviceName, e);
                }
            }, executor))
            .collect(Collectors.toList());
        
        // 等待所有订阅完成，设置超时
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .get(30, TimeUnit.SECONDS);
    }
}

// 批量反注册
public void batchDeregister(String serviceName, List<Instance> instances) {
    // Nacos 支持批量操作
    namingService.batchDeregisterInstance(serviceName, instances);
}

// 僵尸节点清理任务
@Scheduled(fixedRate = 60000)
public void cleanZombieNodes() {
    List<Instance> allInstances = namingService.getAllInstances(serviceName);
    long now = System.currentTimeMillis();
    
    for (Instance instance : allInstances) {
        // 检查心跳时间
        long lastHeartbeat = instance.getLastHeartBeatTime();
        if (now - lastHeartbeat > heartbeatTimeout) {
            log.warn("Found zombie instance: {}", instance);
            // 主动摘除
            namingService.deregisterInstance(serviceName, instance);
        }
    }
}

// Nacos 自动支持增量更新
// Consumer 端维护本地版本号
public class ServiceUpdateHandler {
    private long localRevision = 0;
    
    public void onServiceChange(ServiceChangeNotify notify) {
        // 检查版本号，跳过过期通知
        if (notify.getRevision() <= localRevision) {
            return;
        }
        
        // 增量更新
        List<Instance> added = notify.getAddedInstances();
        List<Instance> removed = notify.getRemovedInstances();
        List<Instance> modified = notify.getModifiedInstances();
        
        // 更新本地缓存
        localCache.applyDelta(added, removed, modified);
        localRevision = notify.getRevision();
    }
}

# Nacos Server 推送相关配置（示意，实际配置项以官方文档为准）
nacos:
  naming:
    # 推送合并窗口（毫秒）
    push-merge-window: 500
    # 最大推送速率（条/秒）
    push-max-rate: 1000
    # 单次推送最大实例数
    push-max-instances: 1000