Überwachen Sie den Ablauf des SSL-Zertifikats mit einer REST-API

Ein abgelaufenes SSL-Zertifikat schaltet Ihre Website offline und zeigt eine Browserwarnung an, die Angst macht weg Kunden. Let's Encrypt-Zertifikate erneuern sich automatisch, aber DNS ist falsch konfiguriert, Cron-Jobs sind fehlgeschlagen, und vergessene manuelle Zertifikate verursachen immer noch Ausfälle. Sie benötigen eine Möglichkeit, den Ablauf zu überwachen Termine für alle Ihre Domains.

Die botoi-API stellt hierfür zwei Endpunkte bereit. Man gibt die Zertifikatsdetails zurück (Aussteller, Gültigkeitsdaten, Tage bis zum Ablauf). Der andere überprüft die HTTPS-Unterstützung und scannt die Sicherheit Kopfzeilen. Zusammen decken sie sowohl die Ablaufüberwachung als auch die Prüfung des Sicherheitsstatus ab.

Zertifikatdetails erhalten Sie mit /v1/ssl-cert/certificate

Dieser Endpunkt stellt eine Verbindung zur Domäne her, liest das TLS-Zertifikat und gibt es strukturiert zurück Daten, die Sie in jeder Sprache analysieren können.

curl -X POST https://api.botoi.com/v1/ssl-cert/certificate \\
  -H "Content-Type: application/json" \\
  -d '{"domain": "stripe.com"}'

Antwort:

{
  "success": true,
  "data": {
    "domain": "stripe.com",
    "subject": "CN=stripe.com",
    "issuer": "C=US, O=Let's Encrypt, CN=E6",
    "valid_from": "2026-02-18T00:00:00.000Z",
    "valid_to": "2026-05-19T00:00:00.000Z",
    "days_until_expiry": 51,
    "serial": "04:A3:9B:7C:2D:1E:8F:00:5A:B2:C4:D6:E8:F0:12:34",
    "fingerprint": "A1:B2:C3:D4:E5:F6:78:90:AB:CD:EF:01:23:45:67:89",
    "san": ["stripe.com", "*.stripe.com"]
  }
}

Der days_until_expiry Das Feld ist das Feld, um das herum Sie Warnungen erstellen. Der san Das Array zeigt alle Domänen an, die das Zertifikat abdeckt, was zur Überprüfung hilfreich ist dass Wildcard-Zertifikate die von Ihnen erwarteten Subdomains enthalten.

Überprüfen Sie die HTTPS-Unterstützung und Sicherheitsheader mit /v1/ssl

Es reicht nicht aus, zu wissen, dass Ihr Zertifikat gültig ist. Sie möchten diese Sicherheit auch bestätigen Header wie HSTS und CSP sind vorhanden. Der /v1/ssl Der Endpunkt kümmert sich darum.

curl -X POST https://api.botoi.com/v1/ssl \\
  -H "Content-Type: application/json" \\
  -d '{"domain": "stripe.com"}'

Antwort:

{
  "success": true,
  "data": {
    "domain": "stripe.com",
    "ssl_supported": true,
    "protocol": "TLSv1.3",
    "headers": {
      "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
      "content-security-policy": "default-src 'self'; script-src 'self' js.stripe.com",
      "x-frame-options": "SAMEORIGIN",
      "x-content-type-options": "nosniff",
      "referrer-policy": "strict-origin-when-cross-origin"
    }
  }
}

Der ssl_supported boolean bestätigt, dass HTTPS funktioniert. Der headers Objektoberflächen HSTS, CSP, X-Frame-Options, X-Content-Type-Options und Referrer-Policy. Fehlende Header weisen auf Lücken in Ihrer Sicherheitskonfiguration hin. Ein TLS-Protokoll unter 1.2 ist eine rote Fahne.

GitHub-Aktionen: wöchentliche SSL-Prüfung mit automatisch erstellten Problemen

Dieser Workflow wird jeden Montag ausgeführt, überprüft eine Liste von Domänen und öffnet ggf. ein GitHub-Problem Jedes Zertifikat läuft innerhalb von 30 Tagen ab. Erstellen .github/workflows/ssl-check.yml:

name: SSL Expiry Check

on:
  schedule:
    # Every Monday at 9:00 UTC
    - cron: '0 9 * * 1'
  workflow_dispatch:

jobs:
  check-ssl:
    runs-on: ubuntu-latest
    steps:
      - name: Check SSL certificates
        run: |
          DOMAINS=("stripe.com" "api.stripe.com" "dashboard.stripe.com")
          THRESHOLD=30
          FAILURES=""

          for DOMAIN in "\\\${DOMAINS[@]}"; do
            RESPONSE=\$(curl -s -X POST https://api.botoi.com/v1/ssl-cert/certificate \\
              -H "Content-Type: application/json" \\
              -d "{\\"domain\\": \\"\$DOMAIN\\"}")

            DAYS=\$(echo "\$RESPONSE" | jq -r '.data.days_until_expiry')
            ISSUER=\$(echo "\$RESPONSE" | jq -r '.data.issuer')
            EXPIRY=\$(echo "\$RESPONSE" | jq -r '.data.valid_to')

            echo "## \$DOMAIN" >> \$GITHUB_STEP_SUMMARY
            echo "- Expires: \$EXPIRY" >> \$GITHUB_STEP_SUMMARY
            echo "- Days left: \$DAYS" >> \$GITHUB_STEP_SUMMARY
            echo "- Issuer: \$ISSUER" >> \$GITHUB_STEP_SUMMARY
            echo "" >> \$GITHUB_STEP_SUMMARY

            if [ "\$DAYS" -lt "\$THRESHOLD" ]; then
              FAILURES="\$FAILURES\\n- \$DOMAIN expires in \$DAYS days (\$EXPIRY)"
            fi
          done

          if [ -n "\$FAILURES" ]; then
            echo "::error::Certificates expiring within \$THRESHOLD days:\$FAILURES"
            exit 1
          fi

          echo "All certificates have more than \$THRESHOLD days remaining."

      - name: Open GitHub issue on failure
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            await github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: 'SSL certificate expiring soon',
              body: 'The weekly SSL check found certificates expiring within 30 days. See the [workflow run](' + context.serverUrl + '/' + context.repo.owner + '/' + context.repo.repo + '/actions/runs/' + context.runId + ') for details.',
              labels: ['infrastructure', 'urgent']
            });

Der Workflow durchläuft jede Domäne, fragt die API ab und sammelt Fehler. Wenn Fällt jedes Zertifikat unter den 30-Tage-Schwellenwert, schlägt der Job fehl und es wird ein GitHub erstellt Problem markiert infrastructure Und urgent. Die Jobzusammenfassung wird angezeigt den vollständigen Bericht für jede Domain.

Anpassen DOMAINS Und THRESHOLD passend zu Ihrem Setup. Das Freie Die Stufe verarbeitet bis zu 100 Anfragen pro Tag, was etwa 14 wöchentlich überprüfte Domains abdeckt.

Node.js: Überwachen Sie mehrere Domänen in einem Skript

Für die Integration in Ihren eigenen Überwachungsstapel finden Sie hier ein Node.js-Skript, das die Prüfung durchführt ein Array von Domänen parallel und markiert Zertifikate, die kurz vor dem Ablauf stehen:

const DOMAINS = [
  "stripe.com",
  "api.stripe.com",
  "dashboard.stripe.com",
  "docs.stripe.com",
];

const THRESHOLD_DAYS = 30;

async function checkCert(domain) {
  const res = await fetch("https://api.botoi.com/v1/ssl-cert/certificate", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": process.env.BOTOI_API_KEY,
    },
    body: JSON.stringify({ domain }),
  });
  const { data } = await res.json();
  return { domain, ...data };
}

async function checkAll() {
  const results = await Promise.all(DOMAINS.map(checkCert));
  const expiring = results.filter(
    (r) => r.days_until_expiry < THRESHOLD_DAYS
  );

  console.log("SSL Certificate Report");
  console.log("=".repeat(50));

  for (const r of results) {
    const status =
      r.days_until_expiry < THRESHOLD_DAYS ? "WARNING" : "OK";
    console.log(
      \`[\\\${status}] \\\${r.domain} - \\\${r.days_until_expiry} days left (expires \\\${r.valid_to})\`
    );
  }

  if (expiring.length > 0) {
    console.log(
      \`\\n\\\${expiring.length} certificate(s) expiring within \\\${THRESHOLD_DAYS} days.\`
    );
  }

  return { results, expiring };
}

checkAll();

Führen Sie dies nach einem Cron-Zeitplan aus oder integrieren Sie es in Ihre bestehende Health-Check-Pipeline. Der Promise.all Der Aufruf prüft alle Domänen gleichzeitig, also die Gesamtsumme Die Ausführungszeit bleibt nahe an der Latenz eines einzelnen API-Aufrufs.

Slack-Webhook-Benachrichtigung, wenn ein Zertifikat bald abläuft

Koppeln Sie die Zertifikatsprüfung mit einem eingehenden Slack-Webhook, um Ihr Team zu benachrichtigen, wenn a Zertifikat braucht Aufmerksamkeit:

async function sendSlackAlert(domain, daysLeft, validTo) {
  const webhookUrl = process.env.SLACK_WEBHOOK_URL;

  await fetch(webhookUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      text: \`:rotating_light: SSL certificate for \\\${domain} expires in \\\${daysLeft} days\`,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: [
              "*SSL Certificate Expiry Warning*",
              \`Domain: \\\`\\\${domain}\\\`\`,
              \`Days remaining: *\\\${daysLeft}*\`,
              \`Expires: \\\${validTo}\`,
            ].join("\\n"),
          },
        },
      ],
    }),
  });
}

// After running the certificate check
async function checkAndAlert() {
  const DOMAINS = ["stripe.com", "api.stripe.com"];

  for (const domain of DOMAINS) {
    const res = await fetch(
      "https://api.botoi.com/v1/ssl-cert/certificate",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-Api-Key": process.env.BOTOI_API_KEY,
        },
        body: JSON.stringify({ domain }),
      }
    );
    const { data } = await res.json();

    if (data.days_until_expiry < 30) {
      await sendSlackAlert(domain, data.days_until_expiry, data.valid_to);
    }
  }
}

checkAndAlert();

Die Nachricht enthält die Domain, die verbleibenden Tage und das Ablaufdatum. Ihr Team sieht das Benachrichtigung in Slack und kann nachforschen, bevor das Zertifikat abläuft.

Vollständige Sicherheitsüberprüfung: Kombinieren Sie beide Endpunkte

Um ein vollständiges Bild zu erhalten, führen Sie beide Endpunkte pro Domäne parallel aus. Das gibt Ihnen Zertifikatsablaufdaten und Sicherheits-Header-Abdeckung in einem einzigen Durchgang:

async function auditSsl(domain) {
  const [cert, ssl] = await Promise.all([
    fetch("https://api.botoi.com/v1/ssl-cert/certificate", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-Api-Key": process.env.BOTOI_API_KEY,
      },
      body: JSON.stringify({ domain }),
    }).then((r) => r.json()),

    fetch("https://api.botoi.com/v1/ssl", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-Api-Key": process.env.BOTOI_API_KEY,
      },
      body: JSON.stringify({ domain }),
    }).then((r) => r.json()),
  ]);

  const issues = [];

  // Certificate checks
  if (cert.data.days_until_expiry < 30) {
    issues.push(\`Certificate expires in \\\${cert.data.days_until_expiry} days\`);
  }

  // Security header checks
  const headers = ssl.data.headers || {};
  if (!headers["strict-transport-security"]) {
    issues.push("Missing HSTS header");
  }
  if (!headers["content-security-policy"]) {
    issues.push("Missing Content-Security-Policy header");
  }
  if (!headers["x-frame-options"]) {
    issues.push("Missing X-Frame-Options header");
  }

  return { domain, cert: cert.data, ssl: ssl.data, issues };
}

// Run audit across all domains
const domains = ["stripe.com", "api.stripe.com"];
Promise.all(domains.map(auditSsl)).then((results) => {
  for (const r of results) {
    console.log(\`\\n\\\${r.domain}:\`);
    console.log(\`  Certificate: \\\${r.cert.days_until_expiry} days left\`);
    console.log(\`  TLS: \\\${r.ssl.protocol}\`);
    console.log(\`  Issues: \\\${r.issues.length === 0 ? "None" : r.issues.join(", ")}\`);
  }
});

Dieses Skript meldet den Ablauf des Zertifikats, die TLS-Protokollversion und fehlende Sicherheit Header für jede Domain. Fügen Sie es Ihrer wöchentlichen Sicherheitsüberprüfung hinzu oder verknüpfen Sie es mit Ihrer Dashboard zur Reaktion auf Vorfälle.

Wichtige Punkte

• /v1/ssl-cert/certificate gibt den Emittenten, Gültigkeitsdaten, days_until_expiry, Seriennummer, Fingerabdruck und SAN-Liste für alle TLS-Zertifikat der Domäne.
• /v1/ssl prüft die HTTPS-Unterstützung, meldet die TLS-Protokollversion und sucht nach HSTS, CSP, X-Frame-Options, X-Content-Type-Options und Referrer-Policy Kopfzeilen.
• Beide Endpunkte arbeiten anonym mit 5 Anfragen pro Minute. Übergeben Sie eine X-Api-Key Überschrift für höhere Grenzwerte.
• Ein wöchentlicher GitHub Actions-Cronjob mit einem 30-Tage-Schwellenwert fängt Verlängerungsfehler ab bevor es zu Ausfällen kommt.
• Kombinieren Sie beide Endpunkte, um die Überwachung des Zertifikatsablaufs und den Sicherheitsheader auszuführen Audits in einem einzigen Skript.