dubbo-k8s-demo/
├── pom.xml                          # 根 POM，定義統(tǒng)一版本
├── common/                          # 共享 DTO、接口定義
│   └── src/main/java/com/example/dubbo/common/
│       ├── dto/OrderDTO.java
│       ├── dto/UserDTO.java
│       └── service/OrderService.java     ← Dubbo 服務(wù)接口（無實(shí)現(xiàn)）
├── order-service/                     # Provider 1
│   └── src/main/java/... 
├── user-service/                      # Provider 2
│   └── src/main/java/...
└── web-api/                           # Consumer + REST API
    └── src/main/java/...

// common/src/main/java/com/example/dubbo/common/dto/UserDTO.java
package com.example.dubbo.common.dto;

import java.io.Serializable;

public record UserDTO(Long id, String username, String email) implements Serializable {
    private static final long serialVersionUID = 1L;
}

// common/src/main/java/com/example/dubbo/common/dto/OrderDTO.java
package com.example.dubbo.common.dto;

import java.io.Serializable;
import java.math.BigDecimal;

public record OrderDTO(
    Long id,
    Long userId,
    String productCode,
    BigDecimal amount,
    String status // CREATED, PAID, SHIPPED
) implements Serializable {
    private static final long serialVersionUID = 1L;
}

// common/src/main/java/com/example/dubbo/common/service/OrderService.java
package com.example.dubbo.common.service;

import com.example.dubbo.common.dto.OrderDTO;
import com.example.dubbo.common.dto.UserDTO;
import org.apache.dubbo.config.annotation.DubboService;

/**
 * 訂單服務(wù)接口 —— Dubbo 服務(wù)契約
 * 注意：此接口僅定義方法簽名，不包含實(shí)現(xiàn)
 */
@DubboService
public interface OrderService {

    /**
     * 創(chuàng)建訂單（內(nèi)部調(diào)用 UserService 獲取用戶信息）
     * @param userId 用戶 ID
     * @param productCode 商品編碼
     * @return 創(chuàng)建成功的訂單
     */
    OrderDTO createOrder(Long userId, String productCode);

    /**
     * 查詢訂單（僅用于演示，實(shí)際應(yīng)走獨(dú)立 OrderRepository）
     */
    OrderDTO getOrderById(Long id);
}

// common/src/main/java/com/example/dubbo/common/service/UserService.java
package com.example.dubbo.common.service;

import com.example.dubbo.common.dto.UserDTO;
import org.apache.dubbo.config.annotation.DubboService;

@DubboService
public interface UserService {

    /**
     * 根據(jù) ID 查詢用戶
     */
    UserDTO getUserById(Long id);
}

// order-service/src/main/java/com/example/dubbo/order/impl/OrderServiceImpl.java
package com.example.dubbo.order.impl;

import com.example.dubbo.common.dto.OrderDTO;
import com.example.dubbo.common.dto.UserDTO;
import com.example.dubbo.common.service.OrderService;
import com.example.dubbo.common.service.UserService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.concurrent.atomic.AtomicLong;

@Service // Spring Bean，用于注入依賴
public class OrderServiceImpl implements OrderService {

    private static final Logger log = LoggerFactory.getLogger(OrderServiceImpl.class);
    private final AtomicLong orderIdGenerator = new AtomicLong(10000L);

    // Dubbo 遠(yuǎn)程引用 UserService（跨服務(wù)調(diào)用）
    @DubboReference(check = false, timeout = 3000, retries = 1)
    private UserService userService;

    @Override
    public OrderDTO createOrder(Long userId, String productCode) {
        log.info("Creating order for userId: {}, product: {}", userId, productCode);

        // 調(diào)用 UserService 獲取用戶信息（Dubbo RPC）
        UserDTO user = userService.getUserById(userId);
        if (user == null) {
            throw new IllegalArgumentException("User not found: " + userId);
        }

        Long orderId = orderIdGenerator.getAndIncrement();
        OrderDTO order = new OrderDTO(
            orderId,
            userId,
            productCode,
            new BigDecimal("99.99"),
            "CREATED"
        );

        log.info("Order created: {}", order);
        return order;
    }

    @Override
    public OrderDTO getOrderById(Long id) {
        // 模擬數(shù)據(jù)庫查詢（實(shí)際應(yīng)接入 JPA/MyBatis）
        return new OrderDTO(id, 1L, "SKU-001", new BigDecimal("99.99"), "CREATED");
    }
}

// user-service/src/main/java/com/example/dubbo/user/impl/UserServiceImpl.java
package com.example.dubbo.user.impl;

import com.example.dubbo.common.dto.UserDTO;
import com.example.dubbo.common.service.UserService;
import org.apache.dubbo.config.annotation.DubboService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Service
@DubboService // 顯式導(dǎo)出為 Dubbo 服務(wù)
public class UserServiceImpl implements UserService {

    private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);

    // 模擬內(nèi)存用戶庫（僅用于演示）
    private final Map<Long, UserDTO> userDB = new ConcurrentHashMap<>();

    public UserServiceImpl() {
        userDB.put(1L, new UserDTO(1L, "zhangsan", "zhangsan@example.com"));
        userDB.put(2L, new UserDTO(2L, "lisi", "lisi@example.com"));
        log.info("Loaded {} mock users", userDB.size());
    }

    @Override
    public UserDTO getUserById(Long id) {
        log.debug("Querying user by id: {}", id);
        return userDB.get(id);
    }
}

// web-api/src/main/java/com/example/dubbo/web/controller/OrderController.java
package com.example.dubbo.web.controller;

import com.example.dubbo.common.dto.OrderDTO;
import com.example.dubbo.common.dto.UserDTO;
import com.example.dubbo.common.service.OrderService;
import com.example.dubbo.common.service.UserService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    // 同時引用兩個 Dubbo 服務(wù)
    @DubboReference(check = false, timeout = 5000, retries = 2)
    private OrderService orderService;

    @DubboReference(check = false, timeout = 3000, retries = 1)
    private UserService userService;

    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(
            @RequestParam Long userId,
            @RequestParam String productCode) {

        OrderDTO order = orderService.createOrder(userId, productCode);
        return ResponseEntity.ok(order);
    }

    @GetMapping("/{id}")
    public ResponseEntity<OrderDTO> getOrder(@PathVariable Long id) {
        OrderDTO order = orderService.getOrderById(id);
        return ResponseEntity.ok(order);
    }

    @GetMapping("/user/{id}")
    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
        UserDTO user = userService.getUserById(id);
        return ResponseEntity.ok(user);
    }
}

# 構(gòu)建階段：使用官方 Maven 鏡像編譯
FROM maven:3.9.6-openjdk-17-slim AS builder

# 設(shè)置時區(qū)（避免日志時間錯亂）
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 復(fù)制 pom.xml 優(yōu)先（利用 Docker 緩存加速）
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B

# 復(fù)制源碼并編譯
COPY . .
RUN mvn clean package -DskipTests -B

# 運(yùn)行階段：使用極簡 JRE 鏡像（Alpine + JRE 17）
FROM eclipse-jre:17-jre-slim

# 創(chuàng)建非 root 用戶（安全最佳實(shí)踐）
RUN addgroup -g 1001 -f appgroup && \
    adduser -S appuser -u 1001

# 設(shè)置工作目錄
WORKDIR /app

# 復(fù)制構(gòu)建產(chǎn)物（fat jar）
COPY --from=builder /app/order-service/target/order-service-1.0.0.jar app.jar

# 暴露 Dubbo 默認(rèn)端口（20880）和 Actuator 端口（8080）
EXPOSE 20880 8080

# 以非 root 用戶運(yùn)行
USER appuser

# 啟動命令（支持 JVM 參數(shù)覆蓋）
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app/app.jar"]

# 在 order-service 目錄下執(zhí)行
docker build -t dubbo-order-service:1.0.0 .

# 啟動（臨時連接 ZooKeeper）
docker run -d \
  --name order-dev \
  -p 20880:20880 \
  -p 8080:8080 \
  --network host \  # 便于訪問本機(jī) ZooKeeper（127.0.0.1:2181）
  -e DUBBO_REGISTRY_ADDRESS=zookeeper://127.0.0.1:2181 \
  dubbo-order-service:1.0.0

# 添加 Helm 倉庫
helm repo add nacos https://nacos-group.github.io/nacos-k8s/

# 安裝（單機(jī)版，適合測試）
helm install nacos nacos/nacos \
  --set mode=standalone \
  --set replicaCount=1 \
  --set service.type=ClusterIP

# order-service/src/main/resources/application.yml
spring:
  application:
    name: order-service

dubbo:
  application:
    name: ${spring.application.name}
    # 關(guān)鍵：啟用 K8s Service 發(fā)現(xiàn)（Nacos 2.2+）
    metadata-type: remote
  protocol:
    name: tri  # 推薦 Triple 協(xié)議（gRPC 兼容，HTTP/2）
    port: 20880
  registry:
    address: nacos://nacos.default.svc.cluster.local:8848
    # 啟用 K8s Service 模式（Nacos 特性）
    parameters:
      namespace: public
      group: DEFAULT_GROUP
  config-center:
    address: nacos://nacos.default.svc.cluster.local:8848
  metadata-report:
    address: nacos://nacos.default.svc.cluster.local:8848

# Actuator 配置（用于健康檢查）
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus,info
  endpoint:
    health:
      show-details: always

# web-api/src/main/resources/application.yml
spring:
  application:
    name: web-api

dubbo:
  application:
    name: ${spring.application.name}
  registry:
    address: nacos://nacos.default.svc.cluster.local:8848
  consumer:
    check: false  # 啟動時不強(qiáng)制檢查依賴服務(wù)
    timeout: 5000
    retries: 2

# k8s/order-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  labels:
    app: order-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
      annotations:
        # 注入版本號，便于追蹤
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
    spec:
      # 安全上下文：禁止 root，只讀根文件系統(tǒng)
      securityContext:
        runAsNonRoot: true
        readOnlyRootFilesystem: true
        # 最小必要權(quán)限
        capabilities:
          drop:
            - ALL

      # 容器定義
      containers:
      - name: app
        image: dubbo-order-service:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 20880  # Dubbo Triple 協(xié)議
          name: dubbo
        - containerPort: 8080   # Actuator / Health
          name: http
        env:
        - name: JAVA_TOOL_OPTIONS
          value: "-Dfile.encoding=UTF-8 -XX:+UseG1GC"
        # 就緒探針：確保 Dubbo 服務(wù)已注冊成功
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        # 存活探針：檢測 JVM 是否卡死
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 30
          timeoutSeconds: 5
        # 優(yōu)雅停機(jī)：收到 SIGTERM 后等待 30 秒再終止
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 30"]

      # 資源限制（防止單 Pod 吃光節(jié)點(diǎn)資源）
      resources:
        requests:
          memory: "512Mi"
          cpu: "250m"
        limits:
          memory: "1Gi"
          cpu: "500m"

---
# Service：為 Dubbo 流量提供 ClusterIP（Consumer 通過 DNS 調(diào)用）
apiVersion: v1
kind: Service
metadata:
  name: order-service
  labels:
    app: order-service
spec:
  selector:
    app: order-service
  ports:
  - name: dubbo
    port: 20880
    targetPort: 20880
  - name: http
    port: 8080
    targetPort: 8080

# k8s/web-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-api
  labels:
    app: web-api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-api
  template:
    metadata:
      labels:
        app: web-api
    spec:
      containers:
      - name: app
        image: dubbo-web-api:1.0.0
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 15
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 45
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "200m"

---
# Service：暴露給 Ingress 或外部負(fù)載均衡器
apiVersion: v1
kind: Service
metadata:
  name: web-api
  labels:
    app: web-api
spec:
  type: ClusterIP  # 生產(chǎn)建議用 LoadBalancer 或 NodePort
  selector:
    app: web-api
  ports:
  - port: 80
    targetPort: 8080

---
# HPA：當(dāng) CPU > 60% 時自動擴(kuò)容（最多 5 個副本）
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-api
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60

# 1. 部署 Nacos（如未部署）
kubectl apply -f k8s/nacos-deployment.yaml

# 2. 部署三個服務(wù)
kubectl apply -f k8s/order-deployment.yaml
kubectl apply -f k8s/user-deployment.yaml
kubectl apply -f k8s/web-deployment.yaml

# 3. 查看 Pod 狀態(tài)
kubectl get pods -l app in (order-service,user-service,web-api)
# 輸出應(yīng)類似：
# NAME                              READY   STATUS    RESTARTS   AGE
# order-service-7c8f9b4d5-2xq9p     1/1     Running   0          45s
# user-service-5d7b8c9a1-pv4k2      1/1     Running   0          42s
# web-api-6b4f8d7c9-9zr8m          1/1     Running   0          38s

# 獲取 web-api Service 的 ClusterIP
WEB_IP=$(kubectl get service web-api -o jsonpath='{.spec.clusterIP}')

# 通過 kubectl port-forward 本地訪問（或配置 Ingress）
kubectl port-forward service/web-api 8080:80 &

# 創(chuàng)建訂單（觸發(fā) OrderService → UserService 調(diào)用）
curl -X POST "http://localhost:8080/api/orders?userId=1&productCode=SKU-001"
# 返回示例：
# {"id":10000,"userId":1,"productCode":"SKU-001","amount":"99.99","status":"CREATED"}

# 手動刪除一個 order-service Pod，觀察是否自動重建
kubectl delete pod -l app=order-service --field-selector=status.phase=Running

# 查看事件（確認(rèn)重建）
kubectl get events --sort-by=.lastTimestamp | tail -10

# 檢查 Nacos 控制臺：實(shí)例數(shù)是否短暫降為 1，后恢復(fù)為 2 ?

dubbo:
  protocol:
    name: tri  # Triple 協(xié)議（gRPC over HTTP/2）
    port: 20880

# istio-dubbo-policy.yaml
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: dubbo-triple-dr
spec:
  host: "*.default.svc.cluster.local"
  trafficPolicy:
    connectionPool:
      http:
        http2MaxRequests: 1000
        maxRequestsPerConnection: 100
    outlierDetection:
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s

// 在 order-service 的主類中添加
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(OrderApplication.class);
        // 啟用優(yōu)雅停機(jī)（等待 Dubbo 服務(wù)注銷完成）
        app.setRegisterShutdownHook(true);
        app.run(args);
    }
}

# 啟用 Spring Boot 3 原生優(yōu)雅停機(jī)（等待 30 秒）
server:
  shutdown: graceful
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s
# Dubbo 優(yōu)雅注銷超時（默認(rèn) 10s，建議延長）
dubbo:
  shutdown:
    wait: 20000  # 20 秒

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>