从0到1掌握Kuberhealthy：自定义健康检查(khcheck)全攻略

最新推荐文章于 2025-06-25 09:26:17 发布
原创 最新推荐文章于 2025-06-25 09:26:17 发布 · 402 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

从0到1掌握Kuberhealthy：自定义健康检查(khcheck)全攻略

【免费下载链接】kuberhealthy A Kubernetes operator for running synthetic checks as pods. Works great with Prometheus! 【免费下载链接】kuberhealthy 项目地址: https://gitcode.com/gh_mirrors/ku/kuberhealthy

引言：告别Kubernetes监控盲区

你是否还在为Kubernetes集群中的隐藏故障而烦恼？节点健康检查不及时？应用可用性监控不到位？Kuberhealthy作为CNCF旗下的开源项目，提供了一种革命性的合成监控(Synthetic Monitoring)方案，让你能够主动验证集群功能和应用健康状态。本文将带你深入理解Kuberhealthy的核心机制，从零开始构建自定义健康检查(khcheck)，并通过实战案例掌握高级配置技巧，最终实现全方位的集群监控覆盖。

读完本文，你将能够：

  • 理解Kuberhealthy的工作原理及核心组件
  • 使用Go、JavaScript和Python编写自定义健康检查
  • 掌握khcheck资源配置的最佳实践
  • 实现检查结果的Prometheus监控与Grafana可视化
  • 解决常见的检查开发与部署问题

Kuberhealthy核心概念与架构

什么是Kuberhealthy？

Kuberhealthy是一个Kubernetes操作员(Operator)，用于运行合成检查(Synthetic Checks)和持续过程验证(Continuous Process Verification)。它通过在集群中部署检查Pod，模拟真实用户行为或内部组件交互，从而主动发现潜在问题。与被动监控不同，Kuberhealthy能够在故障影响用户之前进行预警，大大提高了系统的可靠性。

核心组件与工作流程

Kuberhealthy的核心组件包括：

  • Kuberhealthy Operator：管理检查生命周期的控制器
  • 检查客户端(Check Client)：用于编写检查逻辑的库
  • khcheck自定义资源：定义检查参数和调度规则的YAML配置
  • 状态报告服务：收集和展示检查结果的API服务
  • Prometheus指标导出器：提供检查结果的指标接口

其工作流程如下：

mermaid

内置检查类型

Kuberhealthy提供了多种内置检查，覆盖了Kubernetes集群的核心功能验证：

检查类型功能描述适用场景
Deployment Check验证部署、滚动更新和服务可达性应用部署流程验证
Daemonset Check验证Daemonset在所有节点的部署节点可用性检查
DNS Resolution Check验证内部和外部DNS解析网络功能验证
HTTP Check验证HTTP端点可用性应用健康检查
SSL Expiry Check监控SSL证书过期时间安全合规检查
Pod Restarts Check监控Pod重启次数应用稳定性监控

开发环境准备

前置要求

在开始开发自定义检查前，请确保你的环境满足以下要求：

  • Kubernetes集群(v1.16+)
  • kubectl命令行工具(已配置集群访问)
  • Go开发环境(v1.16+，如使用Go编写检查)
  • Node.js环境(v14+，如使用JavaScript编写检查)
  • Python环境(v3.6+，如使用Python编写检查)
  • Docker环境(用于构建检查镜像)
  • Git(用于代码管理)

安装Kuberhealthy

使用以下命令在Kubernetes集群中安装Kuberhealthy：

# 克隆仓库
git clone https://gitcode.com/gh_mirrors/ku/kuberhealthy.git
cd kuberhealthy

# 使用Helm安装(推荐)
cd deploy/helm/kuberhealthy
helm install kuberhealthy . --namespace kuberhealthy --create-namespace

# 或使用YAML清单安装
kubectl apply -f deploy/kuberhealthy.yaml

验证安装是否成功：

kubectl get pods -n kuberhealthy
kubectl get svc kuberhealthy -n kuberhealthy

检查开发工具集

根据你选择的开发语言，安装相应的检查客户端库：

Go客户端：

go get github.com/kuberhealthy/kuberhealthy/v2/pkg/checks/external/checkclient

JavaScript客户端：

npm install kuberhealthy

Python客户端：

# Python客户端位于clients/python目录下
git clone https://gitcode.com/gh_mirrors/ku/kuberhealthy.git
cd kuberhealthy/clients/python
pip install -r requirements.txt

自定义检查开发指南

检查开发核心原则

开发自定义检查时，应遵循以下核心原则：

  1. 原子性：每个检查应专注于验证单一功能点
  2. 确定性：相同条件下应产生相同结果
  3. 高效性：检查应快速执行，避免资源浪费
  4. 安全性：最小权限原则，避免敏感操作
  5. 可观测性：提供详细的成功/失败信息
  6. 容错性：处理临时故障，避免误报

环境变量与报告机制

Kuberhealthy会为每个检查Pod注入以下环境变量，用于结果报告：

环境变量描述示例值
KH_REPORTING_URL报告检查结果的URLhttp://kuberhealthy.kuberhealthy.svc.cluster.local/externalCheckStatus
KH_CHECK_RUN_DEADLINE检查截止时间(Unix时间戳)1620000000
KH_RUN_UUID检查运行的唯一标识符550e8400-e29b-41d4-a716-446655440000
KH_POD_NAMESPACE检查Pod所在命名空间kuberhealthy

检查结果通过HTTP POST请求发送到KH_REPORTING_URL，请求体格式如下：

{
  "OK": true,
  "Errors": ["错误信息1", "错误信息2"]
}
  • 当检查成功时，OK设为true，Errors为空数组
  • 当检查失败时，OK设为false，Errors包含详细错误信息

使用Go开发检查

Go是开发Kuberhealthy检查的首选语言，提供了完整的客户端库支持。

步骤1：创建项目结构

mkdir -p $GOPATH/src/github.com/yourusername/kuberhealthy-checks/hello-check
cd $GOPATH/src/github.com/yourusername/kuberhealthy-checks/hello-check
go mod init github.com/yourusername/kuberhealthy-checks/hello-check

步骤2：编写检查代码

创建main.go文件：

package main

import (
	"os"
	"time"

	"github.com/kuberhealthy/kuberhealthy/v2/pkg/checks/external/checkclient"
	log "github.com/sirupsen/logrus"
)

func main() {
	// 启用调试日志
	checkclient.Debug = true
	
	// 获取检查超时时间
	deadline, err := checkclient.GetDeadline()
	if err != nil {
		log.Errorln("无法获取检查截止时间:", err)
		checkclient.ReportFailure([]string{"无法获取检查截止时间: " + err.Error()})
		return
	}
	
	// 设置检查超时控制
	timeLimit := deadline.Sub(time.Now().Add(5 * time.Second))
	timeoutChan := time.After(timeLimit)
	
	// 启动检查逻辑协程
	resultChan := make(chan error)
	go func() {
		resultChan <- performCheck()
	}()
	
	// 等待检查完成或超时
	select {
	case <-timeoutChan:
		errMsg := "检查超时"
		log.Errorln(errMsg)
		checkclient.ReportFailure([]string{errMsg})
	case err := <-resultChan:
		if err != nil {
			log.Errorln("检查失败:", err)
			checkclient.ReportFailure([]string{err.Error()})
		} else {
			log.Infoln("检查成功")
			checkclient.ReportSuccess()
		}
	}
}

// performCheck 执行实际的检查逻辑
func performCheck() error {
	// 获取自定义环境变量
	expectedMessage := os.Getenv("EXPECTED_MESSAGE")
	if expectedMessage == "" {
		expectedMessage = "Hello, Kuberhealthy!"
	}
	
	// 模拟检查逻辑
	log.Infof("验证消息: %s", expectedMessage)
	
	// 这里可以添加实际的检查逻辑，例如：
	// - HTTP端点检查
	// - 数据库连接测试
	// - 外部服务可用性验证
	
	// 模拟随机失败(仅用于测试)
	// if rand.Float32() < 0.1 {
	// 	return fmt.Errorf("随机检查失败")
	// }
	
	return nil
}

步骤3：创建Dockerfile

FROM golang:1.16-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o hello-check .

FROM alpine:3.13
WORKDIR /app
COPY --from=builder /app/hello-check .
RUN apk --no-cache add ca-certificates
USER 999
ENTRYPOINT ["/app/hello-check"]

步骤4：构建并推送镜像

# 构建镜像
docker build -t your-registry/hello-check:v1.0.0 .

# 推送镜像
docker push your-registry/hello-check:v1.0.0

使用JavaScript开发检查

对于前端开发者，可以使用JavaScript编写Kuberhealthy检查：

步骤1：创建项目并安装依赖

mkdir kh-hello-check-js
cd kh-hello-check-js
npm init -y
npm install kuberhealthy

步骤2：编写检查代码

创建check.js文件：

const kh = require('kuberhealthy');
const fs = require('fs');

// 启用调试日志
kh.debug = true;

async function performCheck() {
  try {
    // 获取环境变量
    const expectedMessage = process.env.EXPECTED_MESSAGE || 'Hello, Kuberhealthy!';
    console.log(`验证消息: ${expectedMessage}`);
    
    // 获取检查超时时间
    const deadlineStr = process.env.KH_CHECK_RUN_DEADLINE;
    if (!deadlineStr) {
      throw new Error('KH_CHECK_RUN_DEADLINE环境变量未设置');
    }
    
    const deadline = parseInt(deadlineStr, 10);
    const now = Math.floor(Date.now() / 1000);
    const timeLimit = deadline - now - 5; // 保留5秒缓冲时间
    
    console.log(`检查将在${timeLimit}秒后超时`);
    
    // 模拟检查逻辑
    // 这里可以添加实际的检查逻辑
    await new Promise(resolve => setTimeout(resolve, 1000));
    
    // 模拟随机失败(仅用于测试)
    // if (Math.random() < 0.1) {
    //   throw new Error('随机检查失败');
    // }
    
    return true;
  } catch (error) {
    console.error('检查失败:', error.message);
    throw error;
  }
}

async function main() {
  try {
    const success = await performCheck();
    if (success) {
      console.log('检查成功，报告结果给Kuberhealthy');
      await kh.ReportSuccess();
    } else {
      console.log('检查失败，报告结果给Kuberhealthy');
      await kh.ReportFailure(['检查未通过']);
    }
  } catch (error) {
    console.error('检查发生错误:', error);
    try {
      await kh.ReportFailure([error.message]);
    } catch (reportError) {
      console.error('报告失败结果时出错:', reportError);
      process.exit(1);
    }
  }
}

main();

步骤3：创建Dockerfile

FROM node:14-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY check.js .
USER node
ENTRYPOINT ["node", "check.js"]

步骤4：构建并推送镜像

docker build -t your-registry/hello-check-js:v1.0.0 .
docker push your-registry/hello-check-js:v1.0.0

使用Python开发检查

Python开发者可以使用以下方式创建自定义检查：

步骤1：创建项目并安装依赖

mkdir kh-hello-check-py
cd kh-hello-check-py
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
# 复制Python客户端文件
cp ../../clients/python/kh_client.py .
pip install requests python-dotenv

步骤2：编写检查代码

创建check.py文件：

import os
import time
import requests
import json
from datetime import datetime
from kh_client import report_success, report_failure

def get_deadline():
    """获取检查截止时间"""
    deadline_str = os.getenv("KH_CHECK_RUN_DEADLINE")
    if not deadline_str:
        raise ValueError("KH_CHECK_RUN_DEADLINE环境变量未设置")
    return int(deadline_str)

def perform_check():
    """执行检查逻辑"""
    # 获取环境变量
    expected_message = os.getenv("EXPECTED_MESSAGE", "Hello, Kuberhealthy!")
    print(f"验证消息: {expected_message}")
    
    # 获取检查超时时间
    deadline = get_deadline()
    now = int(time.time())
    time_limit = deadline - now - 5  # 保留5秒缓冲时间
    
    print(f"检查将在{time_limit}秒后超时")
    
    # 模拟检查逻辑
    # 这里可以添加实际的检查逻辑
    time.sleep(1)
    
    # 模拟随机失败(仅用于测试)
    # import random
    # if random.random() < 0.1:
    #     raise Exception("随机检查失败")
    
    return True

def main():
    try:
        success = perform_check()
        if success:
            print("检查成功，报告结果给Kuberhealthy")
            report_success()
        else:
            print("检查失败，报告结果给Kuberhealthy")
            report_failure(["检查未通过"])
    except Exception as e:
        print(f"检查发生错误: {str(e)}")
        try:
            report_failure([str(e)])
        except Exception as report_error:
            print(f"报告失败结果时出错: {str(report_error)}")
            exit(1)

if __name__ == "__main__":
    main()

步骤3：创建Dockerfile

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY kh_client.py .
COPY check.py .
USER 1000
ENTRYPOINT ["python", "check.py"]

步骤4：创建requirements.txt

requests>=2.25.1
python-dotenv>=0.19.0

步骤5：构建并推送镜像

docker build -t your-registry/hello-check-py:v1.0.0 .
docker push your-registry/hello-check-py:v1.0.0

khcheck资源配置详解

基本结构

khcheck是Kuberhealthy的自定义资源定义(Custom Resource Definition)，用于配置和管理检查。一个基本的khcheck资源文件结构如下：

apiVersion: comcast.github.io/v1
kind: KuberhealthyCheck
metadata:
  name: hello-check
  namespace: kuberhealthy
spec:
  runInterval: 30s        # 检查运行间隔
  timeout: 2m             # 检查超时时间
  podSpec:                # 检查Pod的规格定义
    containers:
    - name: main
      image: your-registry/hello-check:v1.0.0
      resources:
        requests:
          cpu: 10m
          memory: 50Mi
      env:
      - name: EXPECTED_MESSAGE
        value: "Hello from Kuberhealthy!"

核心参数说明

元数据(Metadata)

参数描述示例值
name检查名称，必须唯一hello-check
namespace部署命名空间，通常为kuberhealthykuberhealthy
labels资源标签，用于筛选和分类app: kh-check, type: custom
annotations资源注解，可用于存储额外信息comcast.com/check-owner: team-devops

规格(Spec)

参数描述示例值建议值
runInterval检查运行间隔30s根据检查重要性调整，关键检查可设为1-5分钟
timeout检查超时时间2m应大于检查实际执行时间，通常设为预期执行时间的2倍
podSpec检查Pod的规格定义详见下方说明-
extraAnnotations附加到检查Pod的注解{"sidecar.istio.io/inject": "false"}根据需要添加
extraLabels附加到检查Pod的标签{"env": "production"}根据需要添加

PodSpec配置

PodSpec遵循Kubernetes Pod规格定义，常用配置包括：

  • containers：容器列表，通常只需要一个容器
    • image：检查镜像地址
    • imagePullPolicy：镜像拉取策略，开发时可设为Always
    • env：环境变量配置
    • resources：资源请求和限制
    • securityContext：安全上下文配置
  • restartPolicy：重启策略，建议设为Never
  • nodeSelector：节点选择器，用于指定检查运行的节点
  • tolerations：容忍度配置，用于在特殊节点上运行检查
  • affinity：亲和性配置，控制检查Pod的调度

高级配置示例

带有节点选择和资源限制的配置：

apiVersion: comcast.github.io/v1
kind: KuberhealthyCheck
metadata:
  name: production-endpoint-check
  namespace: kuberhealthy
  labels:
    critical: "true"
  annotations:
    comcast.com/check-owner: "team-sre"
spec:
  runInterval: 1m
  timeout: 30s
  extraAnnotations:
    prometheus.io/scrape: "false"
  extraLabels:
    environment: production
  podSpec:
    restartPolicy: Never
    nodeSelector:
      role: monitoring
    tolerations:
    - key: "monitoring"
      operator: "Equal"
      value: "true"
      effect: "NoSchedule"
    containers:
    - name: main
      image: your-registry/http-check:v2.1.0
      imagePullPolicy: Always
      resources:
        requests:
          cpu: 20m
          memory: 80Mi
        limits:
          cpu: 100m
          memory: 128Mi
      env:
      - name: CHECK_URL
        value: "https://api.example.com/health"
      - name: EXPECTED_STATUS_CODE
        value: "200"
      - name: REQUEST_TIMEOUT
        value: "5s"
      - name: COUNT
        value: "3"
      - name: SECONDS
        value: "1"
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true

带有持久卷的配置（适用于需要存储的检查）：

apiVersion: comcast.github.io/v1
kind: KuberhealthyCheck
metadata:
  name: storage-performance-check
  namespace: kuberhealthy
spec:
  runInterval: 15m
  timeout: 5m
  podSpec:
    restartPolicy: Never
    containers:
    - name: main
      image: your-registry/storage-check:v1.2.0
      resources:
        requests:
          cpu: 100m
          memory: 256Mi
        limits:
          cpu: 500m
          memory: 512Mi
      env:
      - name: TEST_FILE_SIZE
        value: "100M"
      - name: TEST_DURATION
        value: "60s"
      volumeMounts:
      - name: test-volume
        mountPath: /test
    volumes:
    - name: test-volume
      persistentVolumeClaim:
        claimName: kh-storage-test-pvc

部署与验证自定义检查

部署步骤

  1. 创建khcheck资源文件

创建文件hello-check.yaml，内容如下：

apiVersion: comcast.github.io/v1
kind: KuberhealthyCheck
metadata:
  name: hello-check
  namespace: kuberhealthy
spec:
  runInterval: 30s
  timeout: 2m
  podSpec:
    containers:
    - name: main
      image: your-registry/hello-check:v1.0.0
      resources:
        requests:
          cpu: 10m
          memory: 50Mi
      env:
      - name: EXPECTED_MESSAGE
        value: "Hello from Kuberhealthy!"
  1. 应用资源配置
kubectl apply -f hello-check.yaml -n kuberhealthy
  1. 验证部署结果
# 查看khcheck资源
kubectl get khchecks -n kuberhealthy
kubectl describe khcheck hello-check -n kuberhealthy

# 查看检查Pod
kubectl get pods -n kuberhealthy -l kuberhealthy-check-name=hello-check

# 查看检查日志
kubectl logs -n kuberhealthy <check-pod-name>

检查状态监控

Kuberhealthy提供了多种方式监控检查状态：

1. JSON状态页面

Kuberhealthy服务提供了JSON格式的状态页面，可以通过以下方式访问：

# 端口转发
kubectl port-forward -n kuberhealthy svc/kuberhealthy 8080:80

# 访问状态页面
curl http://localhost:8080/health

状态页面返回示例：

{
  "OK": true,
  "Errors": [],
  "CheckDetails": {
    "hello-check": {
      "OK": true,
      "Errors": [],
      "LastRun": "2023-06-15T10:30:45Z",
      "RunDuration": "1.23s"
    },
    "deployment-check": {
      "OK": true,
      "Errors": [],
      "LastRun": "2023-06-15T10:30:15Z",
      "RunDuration": "5.47s"
    }
  },
  "LastUpdated": "2023-06-15T10:30:45Z"
}

2. Prometheus指标

Kuberhealthy暴露Prometheus指标接口，可以通过以下方式集成：

# 指标端点
curl http://localhost:8080/metrics

关键指标包括：

kuberhealthy_check{check="hello-check",namespace="kuberhealthy"} 1
kuberhealthy_check_duration_seconds{check="hello-check",namespace="kuberhealthy"} 1.23
kuberhealthy_check_run_count{check="hello-check",namespace="kuberhealthy"} 42
kuberhealthy_cluster_state 1
kuberhealthy_running 1

3. Grafana可视化

Kuberhealthy提供了Grafana仪表板模板，可以导入使用：

  1. 从项目中获取仪表板定义：deploy/grafana/dashboard.json
  2. 在Grafana中导入仪表板
  3. 配置Prometheus数据源

仪表板将展示检查状态、执行时间、成功率等关键指标的可视化图表。

调试与故障排除

常见问题及解决方案

检查Pod无法启动

可能原因排查方法解决方案
镜像拉取失败kubectl describe pod <pod-name> -n kuberhealthy 查看事件检查镜像地址是否正确，确保镜像仓库可访问，配置镜像拉取密钥
资源限制不足查看Pod事件和日志调整resources.requests和resources.limits配置
安全上下文问题查看Pod事件和日志检查securityContext配置，确保运行用户有权限执行必要操作
配置错误验证khcheck资源定义使用kubectl validate验证YAML，检查语法错误

检查报告失败

可能原因排查方法解决方案
检查逻辑错误查看检查Pod日志修复检查代码中的错误，增加调试日志
目标服务不可达查看网络策略，测试网络连通性调整网络策略，确保检查Pod可以访问目标服务
环境变量配置错误检查Pod环境变量修正khcheck中的env配置
权限不足查看Pod日志中的权限错误配置适当的RBAC权限，使用serviceAccount
超时设置过短检查runInterval和timeout配置延长timeout时间，优化检查逻辑性能

高级调试技巧

使用调试模式运行检查

在开发阶段，可以通过以下方式直接运行检查代码进行调试：

# 设置必要的环境变量
export KH_REPORTING_URL=http://localhost:8080/externalCheckStatus
export KH_RUN_UUID=debug-test-123
export KH_CHECK_RUN_DEADLINE=$(($(date +%s) + 300))

# 直接运行检查代码
go run main.go
# 或
node check.js
# 或
python check.py

启用Kuberhealthy调试日志

修改Kuberhealthy部署，增加调试日志级别：

kubectl edit deployment kuberhealthy -n kuberhealthy

在容器命令中添加--debug参数：

spec:
  containers:
  - name: kuberhealthy
    command:
    - /app/kuberhealthy
    - --debug

查看详细日志：

kubectl logs -n kuberhealthy deployment/kuberhealthy -f

使用临时检查Pod进行测试

创建一个临时Pod，使用与检查相同的镜像和配置进行测试：

apiVersion: v1
kind: Pod
metadata:
  name: check-test-pod
  namespace: kuberhealthy
spec:
  containers:
  - name: main
    image: your-registry/hello-check:v1.0.0
    command: ["sleep", "3600"]
    env:
    - name: EXPECTED_MESSAGE
      value: "Hello from test pod!"
  restartPolicy: Never

进入Pod进行调试：

kubectl exec -it check-test-pod -n kuberhealthy -- /bin/sh
# 在Pod内手动运行检查
/app/hello-check

高级主题

检查结果持久化与告警集成

Prometheus告警规则

结合Prometheus和Alertmanager，可以基于Kuberhealthy指标创建告警规则：

groups:
- name: kuberhealthy.rules
  rules:
  - alert: KuberhealthyCheckFailed
    expr: kuberhealthy_check == 0
    for: 5m
    labels:
      severity: critical
      source: kuberhealthy
    annotations:
      summary: "Kuberhealthy检查失败"
      description: "检查 {{ $labels.check }} 已失败超过5分钟。详细信息：{{ $labels.error }}"
      runbook_url: "https://wiki.example.com/runbooks/kuberhealthy-check-failure"

  - alert: KuberhealthyNotRunning
    expr: kuberhealthy_running == 0
    for: 2m
    labels:
      severity: critical
      source: kuberhealthy
    annotations:
      summary: "Kuberhealthy未运行"
      description: "Kuberhealthy服务已停止运行超过2分钟"
      runbook_url: "https://wiki.example.com/runbooks/kuberhealthy-not-running"

InfluxDB集成

Kuberhealthy支持将检查结果发送到InfluxDB，配置方法如下：

  1. 修改Kuberhealthy配置：
apiVersion: v1
kind: ConfigMap
metadata:
  name: kuberhealthy
  namespace: kuberhealthy
data:
  kuberhealthy.yaml: |-
    enableInflux: true
    influxUsername: "your-username"
    influxPassword: "your-password"
    influxURL: "http://influxdb.influxdb.svc.cluster.local:8086"
    influxDB: "kuberhealthy"
  1. 重启Kuberhealthy：
kubectl rollout restart deployment kuberhealthy -n kuberhealthy

检查权限管理

使用Service Account

为检查Pod配置专用的Service Account，实现最小权限原则：

  1. 创建Service Account：
apiVersion: v1
kind: ServiceAccount
metadata:
  name: custom-check-sa
  namespace: kuberhealthy
  1. 创建RBAC权限：
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: custom-check-role
rules:
- apiGroups: [""]
  resources: ["pods", "services"]
  verbs: ["get", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: custom-check-binding
subjects:
- kind: ServiceAccount
  name: custom-check-sa
  namespace: kuberhealthy
roleRef:
  kind: ClusterRole
  name: custom-check-role
  apiGroup: rbac.authorization.k8s.io
  1. 在khcheck中使用Service Account：
apiVersion: comcast.github.io/v1
kind: KuberhealthyCheck
metadata:
  name: secure-endpoint-check
  namespace: kuberhealthy
spec:
  runInterval: 1m
  timeout: 30s
  podSpec:
    serviceAccountName: custom-check-sa
    containers:
    - name: main
      image: your-registry/secure-endpoint-check:v1.0.0
      # ...其他配置

检查调度与资源优化

节点亲和性配置

控制检查Pod在特定节点上运行：

spec:
  podSpec:
    affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: kubernetes.io/os
              operator: In
              values:
              - linux
        preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 100
          preference:
            matchExpressions:
            - key: node-role.kubernetes.io/monitoring
              operator: Exists

Pod拓扑分布约束

对于需要在多个节点上运行的检查，使用拓扑分布约束：

spec:
  podSpec:
    topologySpreadConstraints:
    - maxSkew: 1
      topologyKey: topology.kubernetes.io/zone
      whenUnsatisfiable: ScheduleAnyway
      labelSelector:
        matchLabels:
          app: kh-check

资源自动伸缩

对于资源需求变化的检查，可以结合Horizontal Pod Autoscaler(HPA)使用，但由于Kuberhealthy检查通常按固定间隔运行，更推荐根据实际需求调整资源配置。

最佳实践与性能优化

检查设计原则

单一职责原则

每个检查应专注于验证单一功能点，避免创建"全能"检查。例如，不要在一个检查中同时验证数据库连接、API可用性和缓存性能，而应拆分为三个独立的检查。

幂等性设计

检查应该是幂等的，多次运行不会产生副作用。例如，创建测试资源后应确保在检查结束时清理，避免资源泄漏。

性能优化

  • 减少不必要的网络请求和计算
  • 使用适当的超时设置避免长时间阻塞
  • 批量处理多个检查目标，减少资源开销
  • 缓存重复计算的结果

容错设计

  • 实现重试机制处理临时故障
  • 添加超时控制避免无限等待
  • 对敏感操作进行限流保护
  • 提供降级机制处理部分故障

部署策略

金丝雀发布

新的检查版本可以先在非生产环境测试，然后通过修改khcheck的image字段进行灰度发布：

# 逐步更新检查版本
kubectl patch khcheck hello-check -n kuberhealthy -p '{"spec":{"podSpec":{"containers":[{"name":"main","image":"your-registry/hello-check:v1.1.0"}]}}}' --type=merge

版本控制

始终在镜像标签中使用明确的版本号，避免使用latest标签，便于回滚和版本追踪：

# 推荐
image: your-registry/hello-check:v1.2.3

# 不推荐
image: your-registry/hello-check:latest

资源规划

根据检查的资源需求合理配置资源请求和限制：

  • CPU请求：根据检查的CPU密集程度设置，通常为10-100m
  • 内存请求：根据检查的内存使用情况设置，通常为50-256Mi
  • 资源限制：建议设置为请求的2-4倍，防止资源滥用

监控与可观测性

检查健康度指标

除了Kuberhealthy本身提供的指标外，还可以在自定义检查中暴露额外的Prometheus指标：

// 在Go检查中添加自定义指标
import (
  "github.com/prometheus/client_golang/prometheus"
  "github.com/prometheus/client_golang/prometheus/promhttp"
  "net/http"
)

var requestDuration = prometheus.NewHistogramVec(
  prometheus.HistogramOpts{
    Name:    "check_request_duration_seconds",
    Help:    "Duration of HTTP requests in seconds",
    Buckets: prometheus.DefBuckets,
  },
  []string{"endpoint", "status_code"},
)

func init() {
  prometheus.MustRegister(requestDuration)
  go func() {
    http.Handle("/metrics", promhttp.Handler())

【免费下载链接】kuberhealthy A Kubernetes operator for running synthetic checks as pods. Works great with Prometheus! 【免费下载链接】kuberhealthy 项目地址: https://gitcode.com/gh_mirrors/ku/kuberhealthy

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值