What is service registration and discovery? What are the mainstream registries? What are their characteristics?

Service registration and discovery are core components in microservice architecture, solving the problem of dynamic service instance management:

Core Concepts:

1. Service Registration

• Service registers its information with the registry at startup
• Registration information includes: service name, IP, port, metadata, etc.
• Regularly sends heartbeats to maintain registration status

2. Service Discovery

• Client obtains service instance list from registry
• Supports dynamic service list updates
• Implements load balancing and failover

3. Health Check

• Periodically detects health status of service instances
• Automatically removes unhealthy instances
• Supports active and passive checking

Main Registry Comparison:

1. Zookeeper

• Features: Distributed coordination service based on ZAB protocol
• Advantages:
  • Mature and stable, active community
  • Strong consistency (CP)
  • Supports temporary and persistent nodes
• Disadvantages:
  • Relatively low performance
  • Complex operations
  • No HTTP interface support
• Applicable Scenarios: Scenarios with high consistency requirements

2. Eureka

• Features: Service discovery component developed by Netflix
• Advantages:
  • Simple to use, good integration with Spring Cloud
  • Supports self-protection mechanism
  • High availability (AP)
• Disadvantages:
  • Maintenance stopped (2.x version)
  • Weak consistency
  • No cross-datacenter support
• Applicable Scenarios: Spring Cloud microservice architecture

3. Consul

• Features: Service mesh tool developed by HashiCorp
• Advantages:
  • Comprehensive features (service discovery, health check, KV storage)
  • Supports HTTP and DNS interfaces
  • Supports multi-datacenter
  • Supports service mesh
• Disadvantages:
  • Steep learning curve
  • Relatively high resource usage
• Applicable Scenarios: Scenarios requiring multi-feature integration

4. Nacos

• Features: Service discovery and configuration management platform open-sourced by Alibaba
• Advantages:
  • Comprehensive features (service discovery, configuration management, DNS)
  • Supports AP and CP mode switching
  • Good integration with Spring Cloud, Dubbo
  • Supports dynamic configuration push
  • Complete Chinese documentation
• Disadvantages:
  • Relatively new, ecosystem not as mature as Consul
• Applicable Scenarios: Domestic microservice architecture, especially using Spring Cloud Alibaba

5. Etcd

• Features: Distributed key-value storage developed by CoreOS
• Advantages:
  • Based on Raft protocol, strong consistency
  • Excellent performance
  • Supports gRPC interface
  • Core component of Kubernetes
• Disadvantages:
  • Relatively single function
  • High operation complexity
• Applicable Scenarios: Kubernetes environment, scenarios with high consistency requirements

Service Discovery Patterns:

1. Client-Side Discovery Pattern

• Client obtains service list from registry
• Client selects service instance itself
• Advantages: Reduces registry pressure, fast response
• Disadvantages: Complex client logic
• Representatives: Eureka, Consul

2. Server-Side Discovery Pattern

• Client calls service through load balancer
• Load balancer obtains service list from registry
• Advantages: Simple client logic
• Disadvantages: Adds proxy layer, may affect performance
• Representatives: Kubernetes Service, Nginx

Implementation Example (Nacos):

Service Provider:

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

// Configuration
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

Service Consumer:

java
@RestController
public class ConsumerController {
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    
    @GetMapping("/call")
    public String callService() {
        ServiceInstance instance = loadBalancerClient.choose("user-service");
        String url = String.format("http://%s:%s/api/user", 
            instance.getHost(), instance.getPort());
        return restTemplate.getForObject(url, String.class);
    }
}

Selection Recommendations:

• Spring Cloud Ecosystem: Prioritize Nacos or Eureka
• Kubernetes Environment: Use Etcd or CoreDNS
• Need Multi-feature Integration: Choose Consul
• High Consistency Requirements: Choose Zookeeper or Etcd
• Domestic Projects: Prioritize Nacos