发布于 由admin

Java与容器化监控：cAdvisor、Metrics Server在K8s中的数据采集

Java与容器化监控：cAdvisor、Metrics Server在K8s中的数据采集

大家好，今天我们来聊聊Java应用在Kubernetes（K8s）环境中如何进行监控，以及如何利用cAdvisor和Metrics Server进行数据采集。我们将深入探讨这些工具的工作原理，并提供实际的代码示例，帮助大家更好地理解和应用这些技术。

一、容器化监控的必要性

在传统的物理机或虚拟机环境中，监控通常侧重于操作系统层面的指标，例如CPU利用率、内存占用、磁盘I/O等。然而，在容器化环境中，应用运行在独立的容器中，我们需要更加精细化的监控，以了解容器内部应用的运行状态，以及容器资源的使用情况。

容器化监控的必要性体现在以下几个方面：

  • 资源利用率优化： 通过监控容器的资源使用情况，可以及时发现资源瓶颈，并进行相应的优化，例如调整容器的资源限制、优化应用代码等。
  • 故障诊断与排查： 当应用出现问题时，通过监控数据可以快速定位问题根源，例如CPU飙升、内存泄漏等，从而缩短故障恢复时间。
  • 自动伸缩： 基于监控数据，可以实现应用的自动伸缩，例如当CPU利用率超过阈值时，自动增加容器数量，以应对突发流量。
  • 性能分析： 通过监控应用的性能指标，可以分析应用的性能瓶颈，并进行相应的优化，例如优化数据库查询、调整线程池大小等。

二、cAdvisor：容器资源监控的利器

cAdvisor (Container Advisor) 是 Google 开源的容器资源监控工具，它可以自动发现同一节点上的所有容器，并收集容器的 CPU、内存、网络、磁盘等资源使用情况。cAdvisor 不仅支持 Docker，还支持多种容器运行时，例如 containerd 和 CRI-O。

2.1 cAdvisor 的工作原理

cAdvisor 的工作原理比较简单：

  1. 自动发现容器： cAdvisor 通过与容器运行时（例如 Docker Engine）的 API 交互，自动发现节点上的所有容器。
  2. 收集资源指标： cAdvisor 通过读取 /proc 文件系统、cgroups 等方式，收集容器的 CPU、内存、网络、磁盘等资源使用情况。
  3. 暴露监控数据： cAdvisor 将收集到的监控数据以 HTTP API 的形式暴露出来，可以使用 Prometheus 等监控系统进行采集。

2.2 在 K8s 中部署 cAdvisor

在 K8s 中，通常将 cAdvisor 作为 DaemonSet 部署，以确保每个节点上都有一个 cAdvisor 实例运行。以下是一个简单的 DaemonSet 示例：

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: cadvisor
  labels:
    app: cadvisor
spec:
  selector:
    matchLabels:
      app: cadvisor
  template:
    metadata:
      labels:
        app: cadvisor
    spec:
      containers:
      - name: cadvisor
        image: google/cadvisor:v0.47.0
        imagePullPolicy: IfNotPresent
        securityContext:
          privileged: true
        volumeMounts:
        - name: rootfs
          mountPath: /rootfs
          readOnly: true
        - name: var-run
          mountPath: /var/run
          readOnly: true
        - name: sys
          mountPath: /sys
          readOnly: true
        - name: var-lib-docker
          mountPath: /var/lib/docker
          readOnly: true
        ports:
        - containerPort: 8080
          name: http
          protocol: TCP
      hostNetwork: true
      volumes:
      - name: rootfs
        hostPath:
          path: /
      - name: var-run
        hostPath:
          path: /var/run
      - name: sys
        hostPath:
          path: /sys
      - name: var-lib-docker
        hostPath:
          path: /var/lib/docker

这个 DaemonSet 会在每个节点上创建一个 cAdvisor Pod，并将宿主机的根目录、/var/run、/sys、/var/lib/docker 目录挂载到容器中。cAdvisor 通过这些目录访问宿主机的资源信息。

2.3 使用 Prometheus 采集 cAdvisor 数据

Prometheus 是一个流行的开源监控系统，它可以从 cAdvisor 采集容器的资源使用情况。以下是一个简单的 Prometheus 配置示例：

scrape_configs:
  - job_name: 'cadvisor'
    static_configs:
      - targets: ['<node_ip>:8080'] # 替换为你的节点 IP

这个配置告诉 Prometheus 从每个节点的 8080 端口采集 cAdvisor 的数据。Prometheus 会定期访问 cAdvisor 的 HTTP API，获取容器的 CPU、内存、网络、磁盘等资源使用情况，并将这些数据存储在 Prometheus 的时序数据库中。

2.4 cAdvisor 的监控指标

cAdvisor 提供了丰富的监控指标，以下是一些常用的指标：

指标名称 描述
container_cpu_usage_seconds_total 容器 CPU 使用的总时间（秒）
container_memory_usage_bytes 容器内存使用量（字节）
container_network_receive_bytes_total 容器网络接收的总字节数
container_network_transmit_bytes_total 容器网络发送的总字节数
container_fs_usage_bytes 容器文件系统使用量（字节）
container_cpu_load_average_10s 容器 10 秒内的 CPU 平均负载

这些指标可以帮助我们了解容器的资源使用情况，并进行相应的优化。

三、Metrics Server：K8s 内置的资源指标 API

Metrics Server 是 K8s 集群中的一个组件，它提供了一组标准的资源指标 API，可以用于获取节点和 Pod 的 CPU、内存等资源使用情况。Metrics Server 主要用于 K8s 的自动伸缩 (Horizontal Pod Autoscaler, HPA) 和资源调度等功能。

3.1 Metrics Server 的工作原理

Metrics Server 的工作原理如下：

  1. 采集资源指标： Metrics Server 通过与 Kubelet 的 Summary API 交互，采集节点和 Pod 的 CPU、内存等资源使用情况。
  2. 存储资源指标： Metrics Server 将采集到的资源指标存储在内存中，并提供 API 供其他组件访问。
  3. 提供资源指标 API： Metrics Server 提供了一组标准的资源指标 API，例如 /apis/metrics.k8s.io/v1beta1/nodes 和 /apis/metrics.k8s.io/v1beta1/pods，可以使用 kubectl top 命令或 K8s API 客户端访问这些 API。

3.2 安装 Metrics Server

Metrics Server 的安装方式比较简单，可以使用 Helm 或 YAML 文件进行安装。以下是一个简单的 YAML 文件示例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: metrics-server
  namespace: kube-system
  labels:
    k8s-app: metrics-server
spec:
  selector:
    matchLabels:
      k8s-app: metrics-server
  template:
    metadata:
      name: metrics-server
      labels:
        k8s-app: metrics-server
    spec:
      serviceAccountName: metrics-server
      volumes:
      - name: tmpfs
        emptyDir:
          medium: Memory
      containers:
      - name: metrics-server
        image: registry.k8s.io/metrics-server/metrics-server:v0.6.3
        imagePullPolicy: IfNotPresent
        args:
          - --cert-dir=/tmp
          - --secure-port=4443
          - --kubelet-insecure-tls
        ports:
        - containerPort: 4443
          protocol: TCP
        livenessProbe:
          httpGet:
            path: /livez
            port: 4443
            scheme: HTTPS
          initialDelaySeconds: 20
          timeoutSeconds: 3
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /readyz
            port: 4443
            scheme: HTTPS
          initialDelaySeconds: 20
          timeoutSeconds: 3
          failureThreshold: 3
        volumeMounts:
        - name: tmpfs
          mountPath: /tmp
      nodeSelector:
        kubernetes.io/os: linux

这个 YAML 文件会创建一个 Deployment，并在 kube-system 命名空间中运行 Metrics Server。

3.3 使用 Metrics Server 获取资源指标

安装完成后，可以使用 kubectl top 命令获取节点和 Pod 的资源指标：

kubectl top node
kubectl top pod

还可以使用 K8s API 客户端访问 Metrics Server 的 API，例如：

from kubernetes import client, config

# 加载 K8s 配置
config.load_kube_config()

# 创建 API 客户端
metrics_api = client.CustomObjectsApi()

# 获取节点指标
node_metrics = metrics_api.list_cluster_custom_object(
    group="metrics.k8s.io",
    version="v1beta1",
    plural="nodes",
)

# 打印节点指标
for item in node_metrics['items']:
    node_name = item['metadata']['name']
    cpu_usage = item['usage']['cpu']
    memory_usage = item['usage']['memory']
    print(f"Node: {node_name}, CPU: {cpu_usage}, Memory: {memory_usage}")

# 获取 Pod 指标
pod_metrics = metrics_api.list_namespaced_custom_object(
    group="metrics.k8s.io",
    version="v1beta1",
    name="pods",
    namespace="default", # 替换为你的命名空间
    plural="pods",
)

# 打印 Pod 指标
for item in pod_metrics['items']:
    pod_name = item['metadata']['name']
    cpu_usage = item['usage']['cpu']
    memory_usage = item['usage']['memory']
    print(f"Pod: {pod_name}, CPU: {cpu_usage}, Memory: {memory_usage}")

这段代码使用 Python 的 K8s 客户端库，访问 Metrics Server 的 API，获取节点和 Pod 的 CPU、内存使用情况，并打印出来。

3.4 Metrics Server 的局限性

Metrics Server 的主要局限性在于：

  • 数据存储在内存中： Metrics Server 将数据存储在内存中，因此数据是临时的，重启后数据会丢失。
  • 只提供简单的资源指标： Metrics Server 只提供 CPU 和内存等简单的资源指标，无法提供更精细化的监控数据。
  • 只用于 K8s 内部组件： Metrics Server 主要用于 K8s 的自动伸缩和资源调度等功能，不适合用于通用的监控场景。

四、Java 应用监控：JMX 与 Micrometer

对于 Java 应用，除了容器层面的监控，还需要关注应用内部的运行状态，例如 JVM 的内存使用情况、线程池的运行状态、HTTP 请求的响应时间等。Java 应用可以使用 JMX (Java Management Extensions) 或 Micrometer 等技术暴露监控指标。

4.1 JMX：Java 内置的监控接口

JMX 是 Java 平台内置的监控接口，它可以将 Java 应用的内部状态暴露为 MBean (Managed Bean)，可以使用 JConsole、VisualVM 等工具查看 MBean 的属性和操作。

4.2 Micrometer：Java 应用监控的现代解决方案

Micrometer 是一个 Java 应用监控的现代解决方案，它提供了一组标准的 API，可以用于收集应用的各种指标，并将这些指标导出到不同的监控系统，例如 Prometheus、InfluxDB、Graphite 等。

4.3 使用 Micrometer 暴露 Java 应用指标

以下是一个简单的示例，演示如何使用 Micrometer 暴露 Java 应用的指标：

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.prometheus.PrometheusConfig;
import io.micrometer.prometheus.PrometheusMeterRegistry;

public class MyApp {

    private static final Counter requestCounter;

    static {
        // 创建 Prometheus 注册表
        PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);

        // 创建一个名为 "myapp.requests" 的计数器
        requestCounter = Counter.builder("myapp.requests")
                .description("Total number of requests")
                .register(registry);

        // 暴露 Prometheus 端点
        // 可以使用 Spring Boot Actuator 或其他方式暴露
        // 例如，使用 Spring Boot Actuator，添加以下依赖：
        // <dependency>
        //     <groupId>org.springframework.boot</groupId>
        //     <artifactId>spring-boot-starter-actuator</artifactId>
        // </dependency>
        // 然后在 application.properties 中配置：
        // management.endpoints.web.exposure.include=*
        // management.metrics.export.prometheus.enabled=true

        // 或者，手动创建一个 HTTP 端点
        // 详见后续代码示例
    }

    public void handleRequest() {
        // 处理请求
        System.out.println("Handling request...");

        // 增加请求计数器
        requestCounter.increment();
    }

    public static void main(String[] args) throws InterruptedException {
        MyApp app = new MyApp();
        while (true) {
            app.handleRequest();
            Thread.sleep(1000);
        }
    }
}

这段代码使用 Micrometer 创建了一个名为 myapp.requests 的计数器，每次调用 handleRequest() 方法时，计数器都会增加。要将这些指标暴露给 Prometheus，可以使用 Spring Boot Actuator 或手动创建一个 HTTP 端点。

4.4 手动创建 HTTP 端点暴露 Micrometer 指标

如果不想使用 Spring Boot Actuator，可以手动创建一个 HTTP 端点来暴露 Micrometer 指标。以下是一个简单的示例：

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.prometheus.PrometheusConfig;
import io.micrometer.prometheus.PrometheusMeterRegistry;
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class MyApp {

    private static final Counter requestCounter;
    private static final PrometheusMeterRegistry registry;

    static {
        // 创建 Prometheus 注册表
        registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);

        // 创建一个名为 "myapp.requests" 的计数器
        requestCounter = Counter.builder("myapp.requests")
                .description("Total number of requests")
                .register(registry);
    }

    public void handleRequest() {
        // 处理请求
        System.out.println("Handling request...");

        // 增加请求计数器
        requestCounter.increment();
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        MyApp app = new MyApp();

        // 创建 HTTP 服务器
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);

        // 创建 HTTP 处理程序
        HttpHandler handler = new HttpHandler() {
            @Override
            public void handle(HttpExchange exchange) throws IOException {
                String response = registry.scrape();
                exchange.sendResponseHeaders(200, response.getBytes().length);
                OutputStream os = exchange.getResponseBody();
                os.write(response.getBytes());
                os.close();
            }
        };

        // 注册 HTTP 处理程序
        server.createContext("/prometheus", handler);

        // 启动 HTTP 服务器
        server.start();

        System.out.println("Prometheus endpoint started on port 8080");

        while (true) {
            app.handleRequest();
            Thread.sleep(1000);
        }
    }
}

这段代码使用 Java 内置的 HttpServer 创建了一个 HTTP 端点 /prometheus，当访问该端点时，会返回 Prometheus 格式的指标数据。

4.5 使用 Prometheus 采集 Micrometer 指标

要使用 Prometheus 采集 Micrometer 指标，需要在 Prometheus 的配置文件中添加以下配置：

scrape_configs:
  - job_name: 'myapp'
    static_configs:
      - targets: ['<pod_ip>:8080'] # 替换为你的 Pod IP

这个配置告诉 Prometheus 从每个 Pod 的 8080 端口采集指标数据。

五、整合 cAdvisor、Metrics Server 和 Micrometer

为了实现全面的容器化监控，可以将 cAdvisor、Metrics Server 和 Micrometer 整合起来使用。

  • cAdvisor： 用于监控容器的资源使用情况，例如 CPU、内存、网络、磁盘等。
  • Metrics Server： 用于 K8s 的自动伸缩和资源调度等功能。
  • Micrometer： 用于监控 Java 应用的内部运行状态，例如 JVM 的内存使用情况、线程池的运行状态、HTTP 请求的响应时间等。

通过整合这些工具，可以实现对 Java 应用的全面监控，从而更好地了解应用的运行状态，并进行相应的优化。

六、总结：全面监控，优化应用

我们讨论了如何利用 cAdvisor 和 Metrics Server 在 Kubernetes 环境中监控 Java 应用。cAdvisor 提供了容器级别的资源监控，Metrics Server 则提供了 K8s 集群级别的资源指标 API。结合 Micrometer，我们可以实现对 Java 应用内部运行状态的监控。通过整合这些工具，我们可以更好地了解应用的运行状态，并进行相应的优化。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注