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}&timestamp={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
Author
Administrator
Published at
2026-09-07

欢迎来到我的博客!