

## 一、为什么需要服务注册与发现

在传统单体架构中，服务实例是固定的，客户端可以直接配置服务地址。但在微服务架构中：

- **服务实例动态变化**：随时可能扩容、缩容、迁移
- **服务地址不固定**：容器化部署后IP频繁变化
- **服务数量众多**：手工维护配置不现实
- **故障需要自动感知**：实例故障时自动剔除

**服务注册与发现解决的核心问题：**
- 服务实例动态注册和注销
- 消费者能动态感知服务提供者变化
- 健康检查，自动剔除不健康实例

## 二、核心原理

### 1. 注册流程

```
服务启动 → 注册中心注册 → 心跳保活 → 服务下线 → 注销或超时剔除
```

**关键点：**
- 服务启动时自动注册
- 运行期间定期发送心跳
- 服务停止时主动注销
- 长时间未发送心跳则自动剔除

### 2. 发现流程

```
消费者 → 注册中心获取实例列表 → 本地缓存 → 负载均衡调用 → 服务提供者
```

**两种模式：**
- **客户端发现**：消费者直接查询注册中心
- **服务端发现**：通过负载均衡器（如Nginx）转发

### 3. 一致性模型

| CAP | 说明 | 代表产品 |
|-----|------|----------|
| AP | 可用性优先，数据可能不一致 | Eureka、Nacos（AP模式） |
| CP | 一致性优先，可能牺牲可用性 | Consul、Nacos（CP模式）、Zookeeper |

## 三、Nacos实战

### 1. 快速开始

**下载安装：**

```bash
# 下载
wget https://github.com/alibaba/nacos/releases/download/2.2.0/nacos-server-2.2.0.tar.gz
tar -xvf nacos-server-2.2.0.tar.gz
cd nacos

# 单机启动
sh bin/startup.sh -m standalone
```

**Docker部署：**

```yaml
# docker-compose.yml
version: '3'
services:
  nacos:
    image: nacos/nacos-server:v2.2.0
    environment:
      MODE: standalone
      PREFER_HOST_MODE: hostname
    ports:
      - "8848:8848"
      - "9848:9848"
    volumes:
      - ./data:/home/nacos/data
```

### 2. 服务注册

**方式一：Spring Boot自动注册**

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

```yaml
spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        # 服务名称，默认从spring.application.name读取
        service: ${spring.application.name}
  application:
    name: order-service
```

**方式二：手动注册**

```java
@Service
public class NacosServiceRegistration {
    
    @Autowired
    private NamingService namingService;
    
    @PostConstruct
    public void register() throws NacosException {
        // 注册服务实例
        namingService.registerInstance(
            "order-service",  // 服务名
            "192.168.1.100",  // IP
            8080,             // 端口
            "DEFAULT"          // 分组
        );
        
        // 添加元数据
        namingService.registerInstance(
            "order-service",
            "192.168.1.100",
            8080,
            1.0,              // 权重
            new HashMap<String, String>() {{
                put("version", "1.0");
                put("region", "us-east");
            }}
        );
    }
    
    @PreDestroy
    public void deregister() throws NacosException {
        namingService.deregisterInstance(
            "order-service",
            "192.168.1.100",
            8080
        );
    }
}
```

### 3. 服务发现

**发现所有实例：**

```java
@RestController
public class OrderController {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @GetMapping("/instances")
    public List<ServiceInstance> getInstances() {
        // 获取用户服务的所有实例
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        return instances;
    }
    
    @GetMapping("/services")
    public List<String> getServices() {
        // 获取所有服务
        List<String> services = discoveryClient.getServices();
        return services;
    }
}
```

**获取所有服务及其实例：**

```java
@GetMapping("/all-services")
public Map<String, List<ServiceInstance>> getAllServices() {
    List<String> services = discoveryClient.getServices();
    Map<String, List<ServiceInstance>> result = new HashMap<>();
    
    for (String serviceName : services) {
        List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
        result.put(serviceName, instances);
    }
    
    return result;
}
```

### 4. 负载均衡调用

**Ribbon + RestTemplate：**

```java
@Configuration
public class RestTemplateConfig {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    public User getUser(Long userId) {
        // 使用服务名代替IP:Port，Ribbon会自动负载均衡
        String url = "http://user-service/user/" + userId;
        return restTemplate.getForObject(url, User.class);
    }
}
```

**Feign声明式客户端：**

```java
@FeignClient(name = "user-service", fallbackFactory = UserFallbackFactory.class)
public interface UserClient {
    
    @GetMapping("/user/{id}")
    User getUser(@PathVariable("id") Long id);
    
    @PostMapping("/user/create")
    User createUser(@RequestBody UserCreateRequest request);
}

@Component
public class UserFallbackFactory implements FallbackFactory<UserClient> {
    
    @Override
    public UserClient create(Throwable cause) {
        return new UserClient() {
            @Override
            public User getUser(Long id) {
                log.error("调用用户服务失败", cause);
                return new User().setId(id).setName("默认用户");
            }
            
            @Override
            public User createUser(UserCreateRequest request) {
                throw new RuntimeException("用户服务不可用");
            }
        };
    }
}
```

### 5. 命名空间和分组

```yaml
spring:
  cloud:
    nacos:
      discovery:
        # 命名空间（用于环境隔离）
        namespace: dev
        # 分组（用于业务隔离）
        group: ORDER_GROUP
```

```java
// 查询指定命名空间和分组的服务
List<Instance> instances = namingService.selectInstances(
    "order-service",
    true,  // healthyOnly，只返回健康的实例
    "DEFAULT",  // 分组
    "dev"  // 命名空间ID
);
```

### 6. 临时实例 vs 永久实例

```yaml
spring:
  cloud:
    nacos:
      discovery:
        # 临时实例：不会持久化，通过心跳保活，不存在则自动注销
        ephemeral: true
        # 永久实例：持久化，无心跳需主动注销
        ephemeral: false
```

## 四、Consul实战

### 1. 安装部署

**Docker部署：**

```bash
docker run -d \
    --name=consul \
    -p 8500:8500 \
    -p 8600:8600/udp \
    consul agent \
    -server \
    -ui \
    -bootstrap-expect=1 \
    -client=0.0.0.0
```

**集群部署：**

```bash
# Server 1
docker run -d --name=consul1 consul agent -server -ui -bootstrap-expect=3 \
    -node=consul1 -advertise=192.168.1.101 \
    -join=192.168.1.101 -join=192.168.1.102 -join=192.168.1.103

# Server 2
docker run -d --name=consul2 consul agent -server -ui \
    -node=consul2 -advertise=192.168.1.102 \
    -join=192.168.1.101

# Server 3
docker run -d --name=consul3 consul agent -server -ui \
    -node=consul3 -advertise=192.168.1.103 \
    -join=192.168.1.101
```

### 2. Spring Boot集成

**依赖：**

```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>
```

**配置：**

```yaml
spring:
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}
        health-check-interval: 10s
        health-check-path: /actuator/health
        prefer-ip-address: true
        metadata:
          version: "1.0"
          region: us-east
```

### 3. 健康检查

**HTTP健康检查：**

```yaml
spring:
  cloud:
    consul:
      discovery:
        health-check-path: /health
        health-check-interval: 10s
        health-check-timeout: 5s
```

**自定义健康检查：**

```java
@RestController
public class HealthController {
    
    @GetMapping("/health")
    public Map<String, Object> health() {
        Map<String, Object> result = new HashMap<>();
        result.put("status", "UP");
        
        // 检查数据库连接
        try {
            jdbcTemplate.queryForObject("SELECT 1", Integer.class);
            result.put("database", "UP");
        } catch (Exception e) {
            result.put("database", "DOWN");
            result.put("status", "DOWN");
        }
        
        // 检查Redis连接
        try {
            redisTemplate.getConnectionFactory().getConnection().ping();
            result.put("redis", "UP");
        } catch (Exception e) {
            result.put("redis", "DOWN");
            result.put("status", "DOWN");
        }
        
        return result;
    }
}
```

### 4. 服务发现

```java
@RestController
public class OrderController {
    
    @Autowired
    private ConsulClient consulClient;
    
    @GetMapping("/services")
    public List<String> getAllServices() {
        Response<Map<String, List<String>>> response = 
            consulClient.getMapServices();
        return new ArrayList<>(response.getValue().keySet());
    }
    
    @GetMapping("/instances")
    public List<String> getInstances() {
        Response<List<ServiceEntry>> response = 
            consulClient.getAllServiceInstances("user-service");
        
        return response.getValue().stream()
            .map(se -> se.getService().getAddress() + ":" + se.getService().getPort())
            .collect(Collectors.toList());
    }
}
```

## 五、注册中心对比

| 特性 | Nacos | Consul | Eureka |
|------|-------|--------|--------|
| CAP | AP+CP可切换 | CP | AP |
| 健康检查 | TCP/HTTP/MYSQL | HTTP/TCP/TTL | 心跳 |
| 配置中心 | 支持 | 支持 | 不支持 |
| 多语言 | 支持 | 支持 | 仅Java |
| 一致性 | Raft | Raft | 无 |
| 维护状态 | 活跃 | 活跃 | 停止维护 |

### Nacos vs Consul选型

**选择Nacos的场景：**
- 需要配置中心功能
- Spring Cloud Alibaba技术栈
- 需要CP/AP灵活切换

**选择Consul的场景：**
- 多语言微服务架构
- 已有Consul基础设施
- 需要服务网格集成

## 六、总结

服务注册与发现是微服务架构的基础设施：

- **自动注册**：服务启动自动注册
- **动态发现**：实时感知实例变化
- **健康检查**：自动剔除不健康实例
- **负载均衡**：结合Ribbon/Feign使用

**最佳实践：**
1. 合理划分命名空间和分组
2. 配置合适的健康检查策略
3. 临时实例和永久实例根据场景选择
4. 服务调用时设置超时和重试

**思考题**：你们用的什么注册中心？有没有遇到过服务发现延迟的问题？

---

*个人观点，仅供参考*

在传统单体架构中，服务实例是固定的，客户端可以直接配置服务地址。但在微服务架构中：

【架构实战】服务注册与发现原理（Nacos/Consul）

研发部经理

架构设计

微服务架构

负载均衡

服务网格

数据库

容器

Docker

Redis

Java

2026年中大促 | AI 领航 智绘未来

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

【架构实战】服务注册与发现原理（Nacos/Consul）-腾讯云开发者社区-腾讯云

【架构实战】服务注册与发现原理（Nacos/Consul）

【架构实战】服务注册与发现原理（Nacos/Consul）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐