07. 服务注册与发现

// 客户端发现示例：Spring Cloud + Nacos
@Service
public class ClientSideDiscoveryService {
    @Autowired
    private DiscoveryClient discoveryClient;
    @Autowired
    private RestTemplate restTemplate;

    public String invokeOrderService() {
        // 从注册中心拉取 order-service 的所有实例
        List<ServiceInstance> instances = discoveryClient.getInstances("order-service");
        if (instances.isEmpty()) {
            throw new RuntimeException("No available order-service instance");
        }
        // 本地轮询负载均衡
        ServiceInstance instance = instances.get(
            new Random().nextInt(instances.size())
        );
        String url = instance.getUri() + "/orders";
        return restTemplate.getForObject(url, String.class);
    }
}

# Kubernetes Service 服务端发现示例
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service
  ports:
    - port: 8080
      targetPort: 8080
  # ClusterIP 模式：集群内部通过 DNS 解析到虚拟 IP，kube-proxy 做负载均衡
  type: ClusterIP

# 集群内 Pod 只需访问固定的 DNS 名称，完全无需关心后端实例变化
curl http://order-service.default.svc.cluster.local:8080/orders

# Istio DestinationRule：定义服务发现后的负载均衡策略
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    loadBalancer:
      simple: LEAST_CONN
    outlierDetection:
      consecutive5xxErrors: 3
      interval: 10s
      baseEjectionTime: 30s

# application.yml
spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev
        group: DEFAULT_GROUP
        metadata:
          version: v1
          region: cn-beijing

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

@Service
public class OrderService {

    @Autowired
    private LoadBalancerClient loadBalancer;

    @Autowired
    private RestTemplate restTemplate;

    public User getUser(Long userId) {
        // 方式1：使用 LoadBalancerClient
        ServiceInstance instance = loadBalancer.choose("user-service");
        String url = instance.getUri() + "/users/" + userId;
        return restTemplate.getForObject(url, User.class);

        // 方式2：使用 @LoadBalanced RestTemplate
        return restTemplate.getForObject(
            "http://user-service/users/{id}", User.class, userId);
    }
}

# bootstrap.yml
spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        group: DEFAULT_GROUP
        namespace: dev

@RestController
@RefreshScope  // 配置变更自动刷新
public class ConfigController {
    @Value("${app.timeout:3000}")
    private int timeout;
}

// /etc/consul.d/web-api.json （Agent 配置文件方式）
{
  "service": {
    "name": "web-api",
    "tags": ["v1", "primary", "api"],
    "port": 8080,
    "meta": {
      "version": "1.2.3",
      "region": "ap-northeast-1"
    },
    "check": {
      "http": "http://localhost:8080/health",
      "interval": "10s",
      "timeout": "5s",
      "deregister_critical_service_after": "1m"
    }
  }
}

# 重新加载配置使注册生效
consul reload

# 或者通过 HTTP API 动态注册
curl -X PUT http://localhost:8500/v1/agent/service/register \
  -H "Content-Type: application/json" \
  -d '{
    "ID": "web-api-001",
    "Name": "web-api",
    "Tags": ["v1"],
    "Port": 8080,
    "Check": {
      "HTTP": "http://10.0.1.10:8080/health",
      "Interval": "10s"
    }
  }'

# /etc/consul.d/checks.hcl
# 多维度健康检查配置示例
check {
  id       = "web-api-health"
  name     = "Web API HTTP Health"
  http     = "http://localhost:8080/actuator/health"
  method   = "GET"
  interval = "15s"
  timeout  = "5s"
}

check {
  id       = "redis-connectivity"
  name     = "Redis Connection Check"
  script   = "/usr/local/bin/check-redis.sh"
  interval = "30s"
  timeout  = "10s"
}

#!/usr/bin/env bash
# /usr/local/bin/check-redis.sh — Redis 连通性检查脚本
redis-cli -h redis.internal -p 6379 ping | grep -q PONG
if [ $? -eq 0 ]; then
    exit 0
else
    exit 2
fi

# 写入配置
consul kv put app/config/database_url "postgres://db.internal:5432/myapp"
consul kv put app/config/max_connections "100"

# 读取配置
consul kv get app/config/database_url

# 以 JSON 格式获取完整元数据（含 CreateIndex、ModifyIndex）
consul kv get -detailed app/config/database_url

# 批量查询前缀
consul kv get -recurse app/config/

# 删除
consul kv delete app/config/max_connections

# Python 使用 consul 库操作 KV
import consul

c = consul.Consul(host='localhost', port=8500)

# 写入
c.kv.put('app/feature/enable_new_ui', 'true')

# 带 Cas 参数的安全更新（防止并发写覆盖）
index, data = c.kv.get('app/feature/enable_new_ui')
c.kv.put('app/feature/enable_new_ui', 'false', cas=index['ModifyIndex'])

# Watch 监听变更
index = None
while True:
    index, data = c.kv.get('app/feature/enable_new_ui', index=index, wait='30s')
    if data:
        print(f"Config changed: {data['Value'].decode()}")

# acl-policy.hcl — 定义只允许读取 web-api 服务的策略
service_prefix "web-api" {
  policy = "read"
}

node_prefix "" {
  policy = "read"
}

key_prefix "app/config/" {
  policy = "read"
}

# 启用 ACL（Consul 主配置）
cat <<EOF >> /etc/consul/consul.hcl
acl {
  enabled = true
  default_policy = "deny"
  enable_token_persistence = true
}
EOF

# 创建策略
consul acl policy create -name "web-api-reader" -rules @acl-policy.hcl \
  -token "your-bootstrap-token"

# 创建 Token 并绑定策略
consul acl token create -description "Web API Service Token" \
  -policy-name "web-api-reader" \
  -token "your-bootstrap-token"

import etcd3
import json
import time

client = etcd3.Client(host='localhost', port=2379)

# 创建 10 秒租约
lease = client.lease(ttl=10)

# 注册服务（键带服务名前缀，值存 JSON 元数据）
client.put(
    '/services/user-service/10.0.1.1:8080',
    json.dumps({
        'host': '10.0.1.1',
        'port': 8080,
        'weight': 1,
        'version': 'v1',
        'health_path': '/health'
    }),
    lease=lease
)

# 在独立线程中维持心跳（续租）
def keep_alive():
    while True:
        try:
            lease.refresh()
            time.sleep(5)
        except Exception:
            break

# 发现服务
instances = client.get_prefix('/services/user-service/')
for value, metadata in instances:
    info = json.loads(value.decode())
    addr = f"{info['host']}:{info['port']}"
    print(f"Found instance: {addr}")

# Watch 实时监听变更
watch_iter, cancel = client.watch_prefix('/services/user-service/')
for event in watch_iter:
    key = event.key.decode()
    if isinstance(event, etcd3.events.PutEvent):
        print(f"[ADD/UPDATE] {key}")
    elif isinstance(event, etcd3.events.DeleteEvent):
        print(f"[REMOVE] {key}")

# 完整的 K8s 服务发现示例
apiVersion: v1
kind: Service
metadata:
  name: order-service
  namespace: default
spec:
  selector:
    app: order-service
  ports:
    - name: http
      port: 8080
      targetPort: 8080
  type: ClusterIP
---
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: order-service-abc
  namespace: default
  labels:
    kubernetes.io/service-name: order-service
addressType: IPv4
ports:
  - name: http
    protocol: TCP
    port: 8080
endpoints:
  - addresses:
      - "10.1.2.3"
    conditions:
      ready: true
  - addresses:
      - "10.1.2.4"
    conditions:
      ready: true

# Pod 内查看 DNS 解析结果
nslookup order-service.default.svc.cluster.local

# 查看 Service 对应的 EndpointSlice（K8s 1.21+ 默认）
kubectl get endpointslices -l kubernetes.io/service-name=order-service

# 查看 kube-proxy 的 iptables 规则（使用 iptables 模式时）
iptables -t nat -L KUBE-SVC-XXXXXXXXXX -n --line-numbers

// Eureka Client 自定义注册元数据示例
@EnableEurekaClient
@SpringBootApplication
public class LegacyServiceApp {
    public static void main(String[] args) {
        SpringApplication.run(LegacyServiceApp.class, args);
    }

    @Bean
    public EurekaInstanceConfigBean eurekaInstanceConfig() {
        EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(
            new InetUtils(new InetUtilsProperties()));
        config.getMetadataMap().put("team", "platform");
        config.getMetadataMap().put("version", "1.4.0");
        return config;
    }
}

# application.yml — Spring Cloud Consul 配置
spring:
  application:
    name: payment-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        enabled: true
        register: true
        health-check-path: /actuator/health
        health-check-interval: 15s
        tags:
          - version=2.0
          - env=production
        metadata:
          management.context-path: /actuator

@FeignClient(name = "inventory-service")
public interface InventoryClient {
    @GetMapping("/inventory/{sku}")
    Inventory getInventory(@PathVariable("sku") String sku);
}

@Service
public class PaymentService {
    @Autowired
    private InventoryClient inventoryClient;

    public void processPayment(String sku) {
        Inventory inv = inventoryClient.getInventory(sku);
        // 逻辑处理...
    }
}

# Consul DNS 查询（Consul Agent 默认在 8600 端口提供 DNS 服务）
dig @127.0.0.1 -p 8600 web-api.service.consul

# SRV 记录返回服务地址 + 端口 + 权重
dig @127.0.0.1 -p 8600 web-api.service.consul SRV

# 带数据中心的跨 DC 查询
dig @127.0.0.1 -p 8600 web-api.service.dc2.consul

# CoreDNS + etcd 实现 DNS 服务发现的典型配置
# Corefile 片段
etcd {
    fallthrough
    path /skydns
    endpoint http://localhost:2379
}

# dc1 主数据中心 Server 配置
datacenter = "dc1"
server     = true
bootstrap_expect = 3

retry_join_wan = ["10.1.0.1", "10.2.0.1", "10.3.0.1"]

# 启用跨 DC  ACL 复制
acl {
  enabled                  = true
  default_policy           = "deny"
  enable_token_replication = true
}

# 查询 dc2 数据中心中的 web-api 服务
curl "http://localhost:8500/v1/catalog/service/web-api?dc=dc2"

# DNS 方式跨 DC 查询
dig @127.0.0.1 -p 8600 web-api.service.dc2.consul

# nacos/conf/cluster.conf — Nacos 集群节点列表
10.0.1.1:8848
10.0.1.2:8848
10.0.1.3:8848

# Spring Boot — 通过 endpoint 多集群配置
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 10.0.1.1:8848,10.0.1.2:8848,10.0.1.3:8848
        cluster-name: SH  # 指定本服务所属集群，优先同集群路由

// Spring Boot Actuator 自定义健康检查
@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    @Autowired
    private DataSource dataSource;

    @Override
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            if (conn.isValid(3)) {
                return Health.up()
                    .withDetail("db", "connected")
                    .withDetail("validationQuery", "SELECT 1")
                    .build();
            }
        } catch (SQLException e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
        return Health.down().build();
    }
}

@Component
public class RedisHealthIndicator implements HealthIndicator {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Override
    public Health health() {
        try {
            String pong = redisTemplate.getConnectionFactory()
                .getConnection().ping();
            if ("PONG".equals(pong)) {
                return Health.up().withDetail("redis", "connected").build();
            }
        } catch (Exception e) {
            return Health.down().withDetail("error", e.getMessage()).build();
        }
        return Health.down().build();
    }
}