如何在SpringBoot的ServiceA中获取Kubernetes内ServiceB的Pod运行时长？

方案一：通过Kubernetes Java Client直接查询K8s API #

这种方式直接调用K8s集群的API获取ServiceB关联Pod的启动时间，计算运行时长，适合需要批量获取所有ServiceB Pod运行数据的场景。

步骤1：给ServiceA配置K8s权限 #

创建Role和RoleBinding，允许ServiceA的ServiceAccount读取Pod资源：

# role.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: your-namespace
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list"]

# role-binding.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  namespace: your-namespace
  name: service-a-pod-reader
subjects:
- kind: ServiceAccount
  name: service-a-sa # ServiceA使用的ServiceAccount
  namespace: your-namespace
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

步骤2：在ServiceA中引入依赖 #

如果用Spring Cloud Kubernetes，直接引入：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes-client</artifactId>
</dependency>

或者用原生K8s Java Client：

<dependency>
    <groupId>io.kubernetes</groupId>
    <artifactId>client-java</artifactId>
    <version>19.0.0</version>
</dependency>

步骤3：编写查询代码 #

import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.ApiException;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodList;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;
import java.util.List;

@Component
public class PodRuntimeService {

    private final CoreV1Api coreV1Api;

    public PodRuntimeService(ApiClient apiClient) {
        this.coreV1Api = new CoreV1Api(apiClient);
    }

    // 传入ServiceB的标签选择器，比如"app=service-b"
    public List<Duration> getServiceBPodRuntimes(String labelSelector) throws ApiException {
        V1PodList podList = coreV1Api.listPodForAllNamespaces(null, null, null, labelSelector, null, null, null, null, null, null);
        return podList.getItems().stream()
                .map(V1Pod::getStatus)
                .map(status -> status.getStartTime())
                .map(startTime -> Duration.between(Instant.parse(startTime), Instant.now()))
                .toList();
    }
}

方案二：让ServiceB暴露自身运行时长接口 #

这种方式无需K8s权限，由ServiceB自己计算并暴露运行时长接口，ServiceA直接调用即可，实现最简单。

步骤1：在ServiceB中注入Pod启动时间 #

通过K8s Downward API将Pod的启动时间注入为环境变量，修改ServiceB的Deployment：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: service-b
spec:
  template:
    spec:
      containers:
      - name: service-b
        image: your-service-b-image
        env:
        - name: POD_START_TIME
          valueFrom:
            fieldRef:
              fieldPath: status.startTime

步骤2：ServiceB编写接口 #

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Duration;
import java.time.Instant;

@RestController
public class PodInfoController {

    @GetMapping("/pod/runtime")
    public String getPodRuntime() {
        String startTimeStr = System.getenv("POD_START_TIME");
        if (startTimeStr == null) {
            //  fallback到JVM启动时间（近似值）
            Instant jvmStartTime = Instant.ofEpochMilli(System.currentTimeMillis() - Runtime.getRuntime().uptime());
            Duration runtime = Duration.between(jvmStartTime, Instant.now());
            return runtime.toString();
        }
        Instant podStartTime = Instant.parse(startTimeStr);
        Duration runtime = Duration.between(podStartTime, Instant.now());
        return runtime.toString();
    }
}

步骤3：ServiceA调用接口 #

用RestTemplate或Feign调用ServiceB的/pod/runtime接口，即可获取对应实例的运行时长。

方案三：改进Spring Cloud Kubernetes LoadBalancer方式 #

如果你坚持用spring-cloud-starter-kubernetes-client-loadbalancer，需要确保能从ServiceInstance中拿到Pod的启动时间元数据。

步骤1：配置application.yml #

spring:
  cloud:
    kubernetes:
      client:
        loadbalancer:
          enabled: true
        discovery:
          enabled: true
          metadata:
            pod:
              labels: true
              annotations: true
              fields: true # 开启Pod字段元数据获取

步骤2：编写代码获取运行时长 #

import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.client.loadbalancer.ServiceInstance;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;

@Component
public class LoadBalancerPodRuntimeService {

    private final LoadBalancerClient loadBalancerClient;

    public LoadBalancerPodRuntimeService(LoadBalancerClient loadBalancerClient) {
        this.loadBalancerClient = loadBalancerClient;
    }

    public Duration getServiceBPodRuntime() {
        ServiceInstance instance = loadBalancerClient.choose("service-b");
        if (instance == null) {
            throw new RuntimeException("No ServiceB instance available");
        }
        // 从实例元数据中获取Pod启动时间
        String startTimeStr = instance.getMetadata().get("status.startTime");
        if (startTimeStr == null) {
            throw new RuntimeException("Pod start time not found in metadata");
        }
        Instant podStartTime = Instant.parse(startTimeStr);
        return Duration.between(podStartTime, Instant.now());
    }
}

如果元数据中没有status.startTime，可以自定义ServiceInstanceMapper，手动将Pod的启动时间添加到ServiceInstance的元数据中。

内容的提问来源于stack exchange，提问作者ali