4
0
0
SSL和k8s证书检测
2026-09-07
2026-09-07
文章摘要
|
SSL和k8s证书检测
背景
随着证书和集群的增多,只靠人工巡检有点局限,最好每天跑一个证书检测的定时日报
方案
使用python脚本结合docker-compose的定时任务,实现每天9点自动跑一次证书巡检任务。
开始实现
准备工作
1.做好当前机器与集群的免密
2.准备好6个文件之后,依次执行:
bash build
bash start
一共6个文件,如下所示:
.
├── build
├── cert_monitor.py
├── docker-compose.yml
├── Dockerfile
├── entrypoint.sh
└── start
cert_monitor.py
#cat cert_monitor.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
证书到期监控脚本
------------------------------------------------------------
功能:
1. 检测指定域名的 SSL 证书(通过 TCP+TLS 握手获取证书,不校验信任链,
因此自签名证书也能正常读取到期时间)。
2. 检测 K8s 集群证书,支持两种方式(任选其一或都配置):
a) 通过 SSH 登录到 master 节点执行 `kubeadm certs check-expiration`
—— 推荐,能看到 apiserver / etcd / front-proxy 等全部证书。
b) 直接读取本地 /etc/kubernetes/pki 下的证书文件(脚本在 master 节点上跑时用)。
3. 汇总所有证书的到期时间、剩余天数,生成钉钉 Markdown 消息。
4. 剩余天数 <= WARN_DAYS 时,消息中该项会高亮标记为"⚠️即将到期",
并支持 @所有人 / @指定手机号。
5. 建议用 crontab 每天定时执行一次。
依赖: 系统需安装 openssl 命令行工具;如使用 SSH 方式检测 K8s,
需要提前配置好免密登录(ssh-copy-id),且目标机器上装有 kubeadm。
Python 只用标准库,无需 pip install 任何东西。
"""
import subprocess
import datetime
import json
import hmac
import hashlib
import base64
import urllib.request
import urllib.parse
import time
import re
import sys
# ============================== 配置区 ==============================
# 1) 需要监控的域名 SSL 证书
# name: 展示名称 host: 域名 port: 端口 servername: SNI(一般等于host即可)
DOMAIN_TARGETS = [
{"name": "google.cn 官网", "host": "www.google.cn", "port": 443},
{"name": "baidu.com 官网", "host": "www.baidu.com", "port": 443},
{"name": "weibo.com 官网", "host": "www.weibo.com","port": 443},
]
# 2) 需要监控的 K8s 集群(自签名证书)
# method: "ssh" -> 通过 SSH 到 master 节点跑 kubeadm certs check-expiration
# method: "local"-> 脚本本身就跑在该 master 节点上,直接读文件(host/user留空即可)
K8S_CLUSTERS = [
{
"name": "生产集群",
"method": "ssh",
"ssh_user": "root",
"ssh_host": "cert-mon-prod-master", # 对应 docker-compose.yml extra_hosts 里的 10.0.0.1
"ssh_port": 22,
},
{
"name": "测试集群",
"method": "ssh_pki", # RKE2 没有 kubeadm,直接远程读取证书文件
"ssh_user": "root",
"ssh_host": "cert-mon-qat-master", # 对应 docker-compose.yml extra_hosts 里的 10.0.0.2
"ssh_port": 22,
"pki_globs": [
"/var/lib/rancher/rke2/server/tls/*.crt",
"/var/lib/rancher/rke2/server/tls/etcd/*.crt",
],
},
]
# 如果不方便用 SSH,想直接读本地证书文件(适合把脚本部署在 master 节点上跑),
# 用下面这种写法代替 K8S_CLUSTERS 中对应项(method 设为 "local"),脚本会自动
# 扫描这个目录下所有 .crt 文件:
K8S_LOCAL_PKI_DIR = "/etc/kubernetes/pki"
# 3) 到期提醒阈值(天)
WARN_DAYS = 30
# 4) 钉钉机器人 Webhook 配置
# 在钉钉群 -> 群设置 -> 智能群助手 -> 添加机器人 -> 自定义机器人 里创建,
# 安全设置建议选"加签",拿到 access_token 和 secret 填在下面。
DINGTALK_WEBHOOK = "https://oapi.dingtalk.com/robot/send?access_token=youraccesstoken"
DINGTALK_SECRET = "SEC*******" # 如果安全设置选的是"自定义关键词",这里留空字符串 ""
# 到期告警时是否 @所有人
AT_ALL_ON_WARNING = False
# 到期告警时 @ 指定手机号(留空列表则不@任何人),仅当 AT_ALL_ON_WARNING=False 时生效
AT_MOBILES_ON_WARNING = [] # 例如 ["13800000000"]
# 每次网络请求超时时间(秒)
TIMEOUT = 8
# ============================== 核心逻辑 ==============================
def run_cmd(cmd, timeout=TIMEOUT, input_text=None):
"""执行 shell 命令,返回 (stdout, stderr, returncode)"""
try:
p = subprocess.run(
cmd, shell=True, capture_output=True, text=True,
timeout=timeout, input=input_text
)
return p.stdout, p.stderr, p.returncode
except subprocess.TimeoutExpired:
return "", "命令执行超时", -1
except Exception as e:
return "", str(e), -1
def parse_openssl_enddate(enddate_line):
"""把 openssl 输出的 notAfter=Mar 1 00:00:00 2027 GMT 解析成 datetime"""
raw = enddate_line.split("=", 1)[1].strip()
raw = raw.replace(" GMT", "").strip()
return datetime.datetime.strptime(raw, "%b %d %H:%M:%S %Y")
def check_domain_cert(name, host, port, servername=None):
"""通过 openssl s_client 获取远端证书并计算剩余天数。自签名证书也能读到,
因为这里不校验证书链,只是把证书内容读出来。"""
servername = servername or host
cmd = (
f"echo | timeout {TIMEOUT} openssl s_client -connect {host}:{port} "
f"-servername {servername} 2>/dev/null"
)
out, err, rc = run_cmd(cmd, timeout=TIMEOUT + 5)
if "BEGIN CERTIFICATE" not in out:
return {
"name": name, "type": "域名SSL", "target": f"{host}:{port}",
"ok": False, "error": "无法获取证书(连接失败或超时)",
}
info_out, info_err, info_rc = run_cmd(
"openssl x509 -noout -enddate -subject -issuer", input_text=out
)
try:
enddate_line = [l for l in info_out.splitlines() if l.startswith("notAfter=")][0]
end_dt = parse_openssl_enddate(enddate_line)
days_left = (end_dt - datetime.datetime.utcnow()).days
return {
"name": name, "type": "域名SSL", "target": f"{host}:{port}",
"ok": True, "end_date": end_dt.strftime("%Y-%m-%d"),
"days_left": days_left,
}
except Exception as e:
return {
"name": name, "type": "域名SSL", "target": f"{host}:{port}",
"ok": False, "error": f"解析证书失败: {e}",
}
def check_remote_pki_via_ssh(cluster_name, ssh_user, ssh_host, ssh_port, pki_globs):
"""SSH 到节点上,用 openssl 直接读取证书文件的到期时间。
适用于 RKE2 / K3s / 二进制部署等没有 kubeadm 汇总命令的集群。
pki_globs: 证书文件的通配符路径列表,如 ["/var/lib/rancher/rke2/server/tls/*.crt"]
"""
globs_expr = " ".join(pki_globs)
remote_script = (
f"for f in {globs_expr}; do "
f"[ -f \"$f\" ] && echo \"===$f===\" && openssl x509 -noout -enddate -in \"$f\" 2>/dev/null; "
f"done"
)
ssh_cmd = (
f"ssh -o StrictHostKeyChecking=no -o ConnectTimeout={TIMEOUT} "
f"-p {ssh_port} {ssh_user}@{ssh_host} '{remote_script}'"
)
out, err, rc = run_cmd(ssh_cmd, timeout=TIMEOUT + 10)
if not out.strip():
print(f"[DEBUG] {cluster_name} 远程读取证书失败:\n{err}\n{'-'*40}")
short_err = " ".join(err.strip().splitlines())[:150]
return [{
"name": cluster_name, "type": "K8s证书", "target": ssh_host,
"ok": False, "error": f"SSH执行失败或无输出: {short_err}",
}]
results = []
current_file = None
for line in out.splitlines():
line = line.strip()
if line.startswith("===") and line.endswith("==="):
current_file = line.strip("=")
continue
if line.startswith("notAfter=") and current_file:
try:
end_dt = parse_openssl_enddate(line)
days_left = (end_dt - datetime.datetime.utcnow()).days
results.append({
"name": f"{cluster_name} / {current_file.split('/')[-1]}",
"type": "K8s证书", "target": ssh_host,
"ok": True, "end_date": end_dt.strftime("%Y-%m-%d"),
"days_left": days_left,
})
except Exception as e:
results.append({
"name": f"{cluster_name} / {current_file.split('/')[-1]}",
"type": "K8s证书", "target": ssh_host,
"ok": False, "error": f"解析失败: {e}",
})
current_file = None
if not results:
results.append({
"name": cluster_name, "type": "K8s证书", "target": ssh_host,
"ok": False, "error": "未找到证书文件,请检查 pki_globs 路径是否正确",
})
return results
def check_k8s_via_ssh(cluster_name, ssh_user, ssh_host, ssh_port=22):
"""SSH 到 master 节点执行 kubeadm certs check-expiration 并解析结果"""
ssh_cmd = (
f"ssh -o StrictHostKeyChecking=no -o ConnectTimeout={TIMEOUT} "
f"-p {ssh_port} {ssh_user}@{ssh_host} "
f"'kubeadm certs check-expiration 2>/dev/null || "
f"kubeadm alpha certs check-expiration 2>/dev/null'"
)
out, err, rc = run_cmd(ssh_cmd, timeout=TIMEOUT + 10)
results = []
if not out.strip():
print(f"[DEBUG] {cluster_name} SSH 完整报错信息:\n{err}\n{'-'*40}")
short_err = " ".join(err.strip().splitlines())[:150]
return [{
"name": f"{cluster_name}", "type": "K8s证书", "target": ssh_host,
"ok": False, "error": f"SSH执行失败或无输出: {short_err}",
}]
# kubeadm 输出形如:
# CERTIFICATE EXPIRES RESIDUAL TIME ...
# admin.conf Sep 07, 2027 08:00 UTC 364d ...
for line in out.splitlines():
line = line.strip()
if not line or line.startswith("CERTIFICATE") or line.startswith("CERTIFICATE AUTHORITY"):
continue
m = re.match(
r"^(\S+)\s+(\w{3}\s+\d{1,2},\s+\d{4}\s+\d{2}:\d{2}\s+\w+)\s+(-?\d+)d",
line
)
if not m:
continue
cert_name, expire_str, residual_days = m.group(1), m.group(2), int(m.group(3))
try:
end_dt = datetime.datetime.strptime(expire_str, "%b %d, %Y %H:%M %Z")
except Exception:
end_dt = None
results.append({
"name": f"{cluster_name} / {cert_name}",
"type": "K8s证书",
"target": ssh_host,
"ok": True,
"end_date": end_dt.strftime("%Y-%m-%d") if end_dt else expire_str,
"days_left": residual_days,
})
if not results:
results.append({
"name": f"{cluster_name}", "type": "K8s证书", "target": ssh_host,
"ok": False, "error": "未能解析到证书信息,请检查kubeadm输出格式",
})
return results
def check_k8s_local_pki(cluster_name, pki_dir=K8S_LOCAL_PKI_DIR):
"""脚本直接跑在 master 节点上时,遍历 pki 目录下的 .crt 文件"""
out, err, rc = run_cmd(f"ls {pki_dir}/*.crt {pki_dir}/etcd/*.crt 2>/dev/null")
files = [f for f in out.splitlines() if f.strip()]
results = []
if not files:
return [{
"name": cluster_name, "type": "K8s证书", "target": pki_dir,
"ok": False, "error": f"未在 {pki_dir} 找到证书文件",
}]
for f in files:
info_out, info_err, info_rc = run_cmd(f"openssl x509 -noout -enddate -in {f}")
try:
enddate_line = [l for l in info_out.splitlines() if l.startswith("notAfter=")][0]
end_dt = parse_openssl_enddate(enddate_line)
days_left = (end_dt - datetime.datetime.utcnow()).days
results.append({
"name": f"{cluster_name} / {f.split('/')[-1]}",
"type": "K8s证书", "target": pki_dir,
"ok": True, "end_date": end_dt.strftime("%Y-%m-%d"),
"days_left": days_left,
})
except Exception as e:
results.append({
"name": f"{cluster_name} / {f.split('/')[-1]}",
"type": "K8s证书", "target": pki_dir,
"ok": False, "error": f"解析失败: {e}",
})
return results
def collect_all_results():
results = []
for d in DOMAIN_TARGETS:
results.append(check_domain_cert(d["name"], d["host"], d["port"], d.get("servername")))
for c in K8S_CLUSTERS:
method = c.get("method", "ssh")
if method == "local":
results.extend(check_k8s_local_pki(c["name"]))
elif method == "ssh_pki":
results.extend(check_remote_pki_via_ssh(
c["name"], c["ssh_user"], c["ssh_host"], c.get("ssh_port", 22),
c.get("pki_globs", [])
))
else: # method == "ssh" -> kubeadm certs check-expiration
results.extend(check_k8s_via_ssh(
c["name"], c["ssh_user"], c["ssh_host"], c.get("ssh_port", 22)
))
return results
# ============================== 消息格式化 ==============================
def status_icon(item):
if not item.get("ok"):
return "❌"
if item["days_left"] <= 0:
return "🔴"
if item["days_left"] <= WARN_DAYS:
return "⚠️"
return "✅"
def _group_key(item):
"""K8s证书的 name 形如 '生产集群 / apiserver',按 / 前面的集群名分组;
域名证书没有 / ,自成一组(用 name 本身当分组key,相当于每个域名单独一组)"""
if item["type"] == "K8s证书" and " / " in item["name"]:
return item["name"].split(" / ")[0]
return item["name"]
def build_markdown(results):
today = datetime.date.today().strftime("%Y-%m-%d")
lines = [f"#### 🔒 证书监控日报 ({today})", ""]
warn_items = [r for r in results if r.get("ok") and r["days_left"] <= WARN_DAYS]
err_items = [r for r in results if not r.get("ok")]
if warn_items or err_items:
lines.append(f"> **⚠️ 共有 {len(warn_items)} 个证书即将到期或已到期,"
f"{len(err_items)} 个检测异常,请关注!**")
lines.append("")
# 按分组归并:域名证书每个各自一组,K8s证书按集群名归为一组
groups = {}
order = []
for r in results:
key = _group_key(r)
if key not in groups:
groups[key] = []
order.append(key)
groups[key].append(r)
def group_sort_key(key):
items = groups[key]
has_problem = any((not it.get("ok")) or it.get("days_left", 99999) <= WARN_DAYS for it in items)
min_days = min((it.get("days_left", 99999) for it in items if it.get("ok")), default=99999)
return (not has_problem, min_days)
order.sort(key=group_sort_key)
domain_lines = []
k8s_lines = []
for key in order:
items = groups[key]
is_k8s = items[0]["type"] == "K8s证书"
ok_items = [it for it in items if it.get("ok")]
bad_items = [it for it in items if not it.get("ok")]
warn_sub = [it for it in ok_items if it["days_left"] <= WARN_DAYS]
if not is_k8s:
# 域名证书:一行搞定
it = items[0]
icon = status_icon(it)
if it.get("ok"):
days = it["days_left"]
days_str = f"{days}天" if days >= 0 else f"已过期{abs(days)}天"
domain_lines.append(f"- {icon} **{key}** 剩余{days_str}(到期 {it['end_date']})")
else:
domain_lines.append(f"- {icon} **{key}** 获取失败: {it.get('error','')}")
continue
# K8s证书:同集群的多个证书折叠成一行摘要
total = len(items)
if bad_items:
icon = "❌"
summary = f"- {icon} **{key}**({total}个证书,{len(bad_items)}个检测异常)"
elif warn_sub:
icon = "⚠️"
summary = f"- {icon} **{key}**({total}个证书,{len(warn_sub)}个即将到期)"
else:
icon = "✅"
min_days = min(it["days_left"] for it in ok_items)
min_date = min(it["end_date"] for it in ok_items)
summary = f"- {icon} **{key}**({total}个证书)最短剩余{min_days}天(最早到期 {min_date})"
k8s_lines.append(summary)
# 只有异常/临期的才展开明细,正常的不展开,避免刷屏
for it in bad_items:
sub_name = it["name"].split(" / ", 1)[-1]
k8s_lines.append(f" - ❌ {sub_name} 获取失败: {it.get('error','')}")
for it in warn_sub:
sub_name = it["name"].split(" / ", 1)[-1]
days = it["days_left"]
days_str = f"{days}天" if days >= 0 else f"已过期{abs(days)}天"
k8s_lines.append(f" - ⚠️ {sub_name} 剩余{days_str}(到期 {it['end_date']})")
if domain_lines:
lines.append("**域名 SSL**")
lines.extend(domain_lines)
lines.append("")
if k8s_lines:
lines.append("**K8s 证书**")
lines.extend(k8s_lines)
lines.append("")
lines.append(f"共检测 {len(results)} 个证书 | 告警阈值: 剩余≤{WARN_DAYS}天")
return "\n".join(lines)
# ============================== 钉钉发送 ==============================
def dingtalk_sign(secret):
timestamp = str(round(time.time() * 1000))
string_to_sign = f"{timestamp}\n{secret}"
hmac_code = hmac.new(
secret.encode("utf-8"), string_to_sign.encode("utf-8"), digestmod=hashlib.sha256
).digest()
sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
return timestamp, sign
def send_dingtalk(markdown_text, title="证书监控日报", at_all=False, at_mobiles=None):
url = DINGTALK_WEBHOOK
if DINGTALK_SECRET:
timestamp, sign = dingtalk_sign(DINGTALK_SECRET)
url = f"{url}×tamp={timestamp}&sign={sign}"
payload = {
"msgtype": "markdown",
"markdown": {"title": title, "text": markdown_text},
"at": {"atMobiles": at_mobiles or [], "isAtAll": bool(at_all)},
}
data = json.dumps(payload).encode("utf-8")
req = urllib.request.Request(
url, data=data, headers={"Content-Type": "application/json"}, method="POST"
)
try:
with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
body = resp.read().decode("utf-8")
print("钉钉返回:", body)
return json.loads(body).get("errcode") == 0
except Exception as e:
print("发送钉钉失败:", e)
return False
# ============================== 主流程 ==============================
def main():
results = collect_all_results()
markdown_text = build_markdown(results)
print(markdown_text) # 同时打印到日志,方便 crontab 排查
warn_items = [r for r in results if r.get("ok") and r["days_left"] <= WARN_DAYS]
at_all = AT_ALL_ON_WARNING and len(warn_items) > 0
at_mobiles = AT_MOBILES_ON_WARNING if warn_items else []
ok = send_dingtalk(markdown_text, at_all=at_all, at_mobiles=at_mobiles)
sys.exit(0 if ok else 1)
if __name__ == "__main__":
main()
docker-compose.yml
#cat docker-compose.yml
version: "3.8"
services:
cert-monitor:
build: .
image: register.abc.cn/tools/cert-monitor:v1-20260907
container_name: cert-monitor
restart: unless-stopped
environment:
CRON_SCHEDULE: "0 9 * * *"
RUN_ONCE: "true"
volumes:
- /root/.ssh:/root/.ssh-source:ro
- cert-monitor-logs:/var/log
extra_hosts:
- "cert-mon-qat-master:10.0.0.2"
- "cert-mon-prod-master:10.0.0.1"
volumes:
cert-monitor-logs:
entrypoint.sh
#cat entrypoint.sh
#!/bin/bash
set -e
# 允许通过环境变量 CRON_SCHEDULE 自定义执行时间,默认每天9点
# 例如: docker run -e CRON_SCHEDULE="0 8 * * *" ...
CRON_SCHEDULE="${CRON_SCHEDULE:-0 9 * * *}"
echo "${CRON_SCHEDULE} root cd /app && /usr/local/bin/python3 /app/cert_monitor.py >> /var/log/cert_monitor.log 2>&1" > /etc/cron.d/cert-monitor
chmod 0644 /etc/cron.d/cert-monitor
crontab /etc/cron.d/cert-monitor
# SSH 私钥通过只读挂载点 /root/.ssh-source 传进来(docker-compose.yml 中配置),
# 这里只复制我们真正需要的几个文件到容器自己可写的 /root/.ssh,
# 不整目录复制 —— 避免 authorized_keys / known_hosts.old 等无关文件
# 权限、属主异常时导致 cp 报错,进而在 set -e 下中断整个启动流程。
if [ -d /root/.ssh-source ]; then
mkdir -p /root/.ssh
for f in id_rsa id_rsa.pub id_ed25519 id_ed25519.pub id_ecdsa id_ecdsa.pub known_hosts config; do
if [ -f "/root/.ssh-source/$f" ]; then
cp -f "/root/.ssh-source/$f" "/root/.ssh/$f" || echo ">>> 警告: 复制 $f 失败,跳过"
fi
done
chmod 700 /root/.ssh
find /root/.ssh -maxdepth 1 -type f -name "id_*" -not -name "*.pub" -exec chmod 600 {} \; || true
find /root/.ssh -maxdepth 1 -type f -name "*.pub" -exec chmod 644 {} \; || true
[ -f /root/.ssh/known_hosts ] && chmod 644 /root/.ssh/known_hosts
[ -f /root/.ssh/config ] && chmod 600 /root/.ssh/config
echo ">>> SSH 密钥已就绪:"
ls -la /root/.ssh
fi
touch /var/log/cert_monitor.log
# 如果传入了 RUN_ONCE=true,启动时先立即跑一次,方便验证配置是否正确
if [ "${RUN_ONCE}" = "true" ]; then
echo ">>> RUN_ONCE=true, 立即执行一次检测..."
cd /app && /usr/local/bin/python3 /app/cert_monitor.py || true
fi
echo ">>> 启动 cron,定时任务: ${CRON_SCHEDULE}"
cron -f &
CRON_PID=$!
# 持续输出日志到容器标准输出,方便 docker logs 查看
tail -F /var/log/cert_monitor.log &
wait ${CRON_PID}
Dockerfile
# 证书监控 - 每日检测域名SSL证书 + K8s集群证书,到期提醒推送钉钉
FROM register.hrttest.cn/tools/python:3.11.9-slim-bookworm
# 替换为华为云镜像源,加速国内构建时的 apt 下载
RUN sed -i 's/deb.debian.org/mirrors.huaweicloud.com/g' /etc/apt/sources.list.d/debian.sources && \
sed -i "s@http://security.debian.org@https://mirrors.huaweicloud.com@g" /etc/apt/sources.list.d/debian.sources
# openssl:检测证书用 openssh-client:SSH到k8s master执行kubeadm命令
# cron:定时任务 tini:优雅处理信号,避免僵尸进程
RUN apt-get update && apt-get install -y --no-install-recommends \
openssl \
openssh-client \
cron \
tini \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY cert_monitor.py /app/cert_monitor.py
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh /app/cert_monitor.py
# 时区设为上海,保证 cron 按国内时间执行、日志时间也对得上
ENV TZ=Asia/Shanghai
# 默认每天9点执行一次,可在 docker run / k8s 中通过环境变量覆盖
ENV CRON_SCHEDULE="0 9 * * *"
ENV RUN_ONCE="false"
VOLUME ["/var/log"]
ENTRYPOINT ["/usr/bin/tini", "--", "/entrypoint.sh"]
启动和构建
build
docker buildx build . -t register.hrttest.cn/tools/cert-monitor:v1-20260907
start
#[root@devin sslcheck]#
docker-compose up -d
结果展示

文档信息
- 文章作者:运维技术团队 - Devin
- 发布日期:2026-09-07
- 适用平台:linux
本文脚本全程使用chatGPT 5 sonnet生成,已经验证可用。
如果本文对你有帮助,欢迎点赞、在看、转发,让更多开发、运维同学们看到!
SSL和k8s证书检测
/archives/sslhe-k8szheng-shu-jian-ce