Головна / Статті

Панель керування схваленнями для агента виправлення Kubernetes: FastAPI та React

Створіть бекенд на FastAPI зі списком дозволів kubectl та панеллю керування схваленням у React, щоб агент для усунення проблем з ШІ міг виправляти інциденти лише після того, як людина натисне «Схвалити».

Видавець: REACTAPP.TOP11 хв читання2452 слів

Джерела: Self-Healing Kubernetes: Wiring OpenTelemetry, SigNoz, and a Groq-Powered Remediation Agent (PART 6)

Агент виправлення з попередньої стадії вже може виявляти три типи інцидентів та просити у Groq діагноз. Потім він намагається опублікувати картку інциденту у бекенді, якого ще немає. На цій стадії створюється цей бекенд разом із панеллю керування React перед ним, що завершує цикл. Виникає інцидент, SigNoz його фіксує, агент ставить діагноз, на панелі керування з’являється картка, оператор натискає «Затвердити», і процедура виправлення запускається на кластері. Після початкової налаштування термінал не потрібен.

Як пов’язані елементи

Агент виправлення надсилає картки інцидентів на бекенд за допомогою POST /api/incidents. Сервіс FastAPI зберігає ці картки, перевіряє команди kubectl та застосовує схвалені виправлення через інструменти Kubernetes. Панель керування React читає список за допомогою GET /api/incidents та вживає дій щодо кожної картки через POST /api/incidents/{id}/approve або /reject. На екрані відображаються картки інцидентів, кнопки «Схвалити» та «Відхилити», індикатор рівня впевненості та журнал аудиту.

Усередині кластера працюють два контейнери. Додаток React — це статична версія, яку обслуговує nginx, а бекенд FastAPI є єдиним компонентом, якому дозволено взаємодіяти з API Kubernetes.

Крок 1: Створення папок

Обидві частини знаходяться у каталозі dashboard проєкту:

cd ~/k8s-aiops-blog
mkdir -p dashboard/backend dashboard/frontend

Крок 2: Бекенд FastAPI

Бекенд виконує чотири функції. Він зберігає надіслані картки в пам’яті, що цілком достатньо для демонстрації, оскільки не використовується база даних. Він надсилає ці картки до фронтенду та обробляє кліки «Затвердити» та «Відхилити». При натисканні «Затвердити» він перевіряє запропоновану команду kubectl, а потім її виконує. Почніть у папці бекенду:

cd ~/k8s-aiops-blog/dashboard/backend

Потім створіть main.py:

cat > main.py <<'EOF'
"""
Approval dashboard backend.
Receives incident cards from the remediation agent, serves them to the
React frontend, and applies approved kubectl commands via the Kubernetes
Python client.
"""
import logging
import shlex
import subprocess
import time
from typing import Literal
from uuid import uuid4from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModellogging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s — %(message)s",
)
log = logging.getLogger("dashboard")app = FastAPI(title="Approval Dashboard")app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)# ---------------------------------------------------------------------------
# In-memory store. Fine for a demo; swap for SQLite or Redis in production.
# ---------------------------------------------------------------------------
INCIDENTS: dict[str, dict] = {}# ---------------------------------------------------------------------------
# kubectl command allowlist.
# The LLM proposes a fix. We only execute it if it matches one of these
# safe prefixes. Nothing with delete, drain, or --all gets through.
# ---------------------------------------------------------------------------
ALLOWED_PREFIXES = (
    "kubectl set env",
    "kubectl rollout restart",
    "kubectl scale",
    "kubectl set resources",
)BLOCKED_TERMS = ("delete", "drain", "--all", "cluster-admin", "exec", "cp")
# ---------------------------------------------------------------------------
# Models
# ---------------------------------------------------------------------------
class IncidentCard(BaseModel):
    id: str
    timestamp: int
    service: str
    signals: dict
    diagnosis: dict
    status: Literal["pending", "approved", "rejected"] = "pending"
class ActionRequest(BaseModel):
    actor: str = "operator"
# ---------------------------------------------------------------------------
# Routes
# ---------------------------------------------------------------------------
@app.get("/healthz")
def healthz():
    return {"ok": True}
@app.post("/api/incidents", status_code=201)
def receive_incident(card: IncidentCard):
    INCIDENTS[card.id] = card.dict()
    log.info("incident received: id=%s type=%s", card.id, card.diagnosis.get("incident_type"))
    return {"id": card.id}
@app.get("/api/incidents")
def list_incidents():
    # Most recent first
    return sorted(INCIDENTS.values(), key=lambda c: c["timestamp"], reverse=True)
@app.get("/api/incidents/{incident_id}")
def get_incident(incident_id: str):
    if incident_id not in INCIDENTS:
        raise HTTPException(status_code=404, detail="not found")
    return INCIDENTS[incident_id]
@app.post("/api/incidents/{incident_id}/approve")
def approve_incident(incident_id: str, req: ActionRequest):
    card = INCIDENTS.get(incident_id)
    if not card:
        raise HTTPException(status_code=404, detail="not found")
    if card["status"] != "pending":
        raise HTTPException(status_code=409, detail=f"incident already {card['status']}")    proposed = card["diagnosis"].get("proposed_fix", "")
    log.info("approve requested: id=%s fix=%r actor=%s", incident_id, proposed, req.actor)    # Validate against allowlist
    allowed = any(proposed.startswith(p) for p in ALLOWED_PREFIXES)
    blocked = any(term in proposed for term in BLOCKED_TERMS)    if not allowed or blocked:
        log.error("REJECTED by allowlist: %r", proposed)
        raise HTTPException(
            status_code=400,
            detail=f"proposed command did not pass allowlist validation: {proposed!r}",
        )    # Apply the fix
    try:
        args = shlex.split(proposed)
        result = subprocess.run(
            args,
            capture_output=True,
            text=True,
            timeout=30,
        )
        if result.returncode != 0:
            log.error("kubectl failed: %s", result.stderr)
            raise HTTPException(status_code=500, detail=f"kubectl error: {result.stderr}")        log.info("kubectl succeeded: %s", result.stdout.strip())
        card["status"] = "approved"
        card["applied_at"] = int(time.time())
        card["applied_by"] = req.actor
        card["kubectl_output"] = result.stdout.strip()
        INCIDENTS[incident_id] = card
        return {"status": "approved", "kubectl_output": result.stdout.strip()}    except subprocess.TimeoutExpired:
        raise HTTPException(status_code=504, detail="kubectl timed out")
@app.post("/api/incidents/{incident_id}/reject")
def reject_incident(incident_id: str, req: ActionRequest):
    card = INCIDENTS.get(incident_id)
    if not card:
        raise HTTPException(status_code=404, detail="not found")
    if card["status"] != "pending":
        raise HTTPException(status_code=409, detail=f"incident already {card['status']}")    card["status"] = "rejected"
    card["rejected_at"] = int(time.time())
    card["rejected_by"] = req.actor
    INCIDENTS[incident_id] = card
    log.info("incident rejected: id=%s actor=%s", incident_id, req.actor)
    return {"status": "rejected"}
EOF

Перевірку списку дозволених команд варто розглянути уважніше. ALLOWED_PREFIXES переконується, що команда починається з однієї з схвалених безпечних операцій. BLOCKED_TERMS — це другий фільтр, який відхиляє все, що містить слова, які ніколи не повинні виконуватися, незалежно від префікса. Обидва фільтри мають пройти, тому команда, яка починається з kubectl set env але містить параметр --all, все одно відхиляється.

Для простоти та можливості аудиту код використовує subprocess.run замість Python SDK Kubernetes, що полегшує запис точної команди, яка була виконана. У продакшн-середовищі краще використовувати CoreV1Api або AppsV1Api з SDK, оскільки вони не створюють підпроцес та повертають структуровані помилки.

Крок 3: Фіксація залежностей

Точні версії вказуються у файлі requirements.txt:

cat > requirements.txt <<'EOF'
fastapi==0.115.0
uvicorn[standard]==0.32.0
pydantic==2.9.2
httpx==0.27.2
EOF

Крок 4: Dockerfile для бекенду

Він починається зі зменшеної образу Python:

cat > Dockerfile <<'EOF'
FROM python:3.11-slim

Решта процесу встановлює kubectl, щоб сервер міг застосувати виправлення, а потім налаштовує додаток:

# Install kubectl so the backend can apply fixes
RUN apt-get update && apt-get install -y curl && \
    curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" && \
    install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl && \
    rm kubectl && \
    apt-get cleanWORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY main.py .EXPOSE 9000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "9000"]
EOF

Крок 5: Фронтенд React

Фронтенд — це звичайний HTML-файл, який завантажує React та Tailwind з CDN, тому немає потреби в компіляції, і Dockerfile залишається простим. Спочатку перейдіть у папку фронтенду:

cd ~/k8s-aiops-blog/dashboard/frontend

Потім напишіть index.html:

cat > index.html <<'EOF'
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>SRE Approval Dashboard</title>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.2.0/umd/react.production.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.2.0/umd/react-dom.production.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/7.23.2/babel.min.js"></script>
  <link href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet"/>
</head>
<body class="bg-gray-950 text-gray-100 min-h-screen">
<div id="root"></div><script type="text/babel">
const API = "http://localhost:9000";const SEVERITY_COLOR = {
  critical: "bg-red-600",
  high:     "bg-orange-500",
  medium:   "bg-yellow-500",
  low:      "bg-blue-500",
};const TYPE_LABEL = {
  crash_loop:    "Crash Loop",
  oom_kill:      "OOM Kill",
  latency_spike: "Latency Spike",
  token_spike:   "Token Spike",
  unknown:       "Unknown",
};function ConfidenceBadge({ value }) {
  const pct = Math.round((value || 0) * 100);
  const color = pct >= 80 ? "text-green-400" : pct >= 50 ? "text-yellow-400" : "text-red-400";
  return (
    <span className={`text-xs font-mono font-bold ${color}`}>
      {pct}% confidence
    </span>
  );
}function IncidentCard({ card, onAction }) {
  const d = card.diagnosis || {};
  const sev = d.severity || "low";
  const isPending = card.status === "pending";  return (
    <div className="bg-gray-900 border border-gray-700 rounded-xl p-5 mb-4 shadow-lg">
      {/* Header row */}
      <div className="flex items-center justify-between mb-3">
        <div className="flex items-center gap-2">
          <span className={`text-xs font-bold px-2 py-0.5 rounded-full text-white ${SEVERITY_COLOR[sev] || "bg-gray-600"}`}>
            {sev.toUpperCase()}
          </span>
          <span className="font-semibold text-white">
            {TYPE_LABEL[d.incident_type] || d.incident_type}
          </span>
          <span className="text-gray-400 text-sm">— {card.service}</span>
        </div>
        <div className="flex items-center gap-3">
          <ConfidenceBadge value={d.confidence} />
          <span className="text-xs text-gray-500">
            {new Date(card.timestamp * 1000).toLocaleTimeString()}
          </span>
        </div>
      </div>      {/* Root cause */}
      <p className="text-sm text-gray-300 mb-3">
        <span className="text-gray-500 mr-1">Root cause:</span>
        {d.root_cause}
      </p>      {/* Proposed fix */}
      <div className="bg-gray-800 rounded-lg px-4 py-2 mb-4 font-mono text-sm text-green-300 flex items-center gap-2">
        <span className="text-gray-500 select-none">lt;/span>
        {d.proposed_fix}
      </div>      {/* Low confidence warning */}
      {(d.confidence || 0) < 0.6 && isPending && (
        <div className="bg-yellow-900 border border-yellow-600 rounded-lg px-3 py-2 mb-3 text-yellow-300 text-xs">
          ⚠ Low confidence — review signals carefully before approving.
        </div>
      )}      {/* Action buttons or status badge */}
      {isPending ? (
        <div className="flex gap-3 mt-2">
          <button
            onClick={() => onAction(card.id, "approve")}
            className="bg-green-600 hover:bg-green-500 text-white text-sm font-semibold px-5 py-2 rounded-lg transition"
          >
            ✓ Approve
          </button>
          <button
            onClick={() => onAction(card.id, "reject")}
            className="bg-red-700 hover:bg-red-600 text-white text-sm font-semibold px-5 py-2 rounded-lg transition"
          >
            ✗ Reject
          </button>
        </div>
      ) : (
        <div className={`inline-block text-xs font-bold px-3 py-1 rounded-full mt-1 ${
          card.status === "approved" ? "bg-green-800 text-green-300" : "bg-red-900 text-red-300"
        }`}>
          {card.status === "approved" ? "✓ Approved" : "✗ Rejected"}
          {card.applied_by && ` by ${card.applied_by}`}
        </div>
      )}      {/* kubectl output on approved cards */}
      {card.kubectl_output && (
        <div className="mt-3 bg-gray-800 rounded-lg px-4 py-2 font-mono text-xs text-gray-400">
          {card.kubectl_output}
        </div>
      )}
    </div>
  );
}function App() {
  const [incidents, setIncidents] = React.useState([]);
  const [loading, setLoading] = React.useState(true);
  const [error, setError] = React.useState(null);
  const [acting, setActing] = React.useState(null);  const fetchIncidents = () => {
    fetch(`${API}/api/incidents`)
      .then(r => r.json())
      .then(data => { setIncidents(data); setLoading(false); setError(null); })
      .catch(e => { setError(e.message); setLoading(false); });
  };  React.useEffect(() => {
    fetchIncidents();
    const id = setInterval(fetchIncidents, 10000); // poll every 10s
    return () => clearInterval(id);
  }, []);  const handleAction = async (id, action) => {
    setActing(id);
    try {
      const r = await fetch(`${API}/api/incidents/${id}/${action}`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ actor: "operator" }),
      });
      if (!r.ok) {
        const err = await r.json();
        alert(`Action failed: ${err.detail}`);
      }
      fetchIncidents();
    } catch (e) {
      alert(`Network error: ${e.message}`);
    } finally {
      setActing(null);
    }
  };  const pending   = incidents.filter(c => c.status === "pending");
  const resolved  = incidents.filter(c => c.status !== "pending");  return (
    <div className="max-w-3xl mx-auto px-4 py-8">
      {/* Header */}
      <div className="mb-8">
        <h1 className="text-2xl font-bold text-white">SRE Approval Dashboard</h1>
        <p className="text-gray-400 text-sm mt-1">
          Human-in-the-loop remediation — review every fix before it runs
        </p>
      </div>      {loading && <p className="text-gray-500">Loading incidents…</p>}
      {error   && <p className="text-red-400">Could not reach backend: {error}</p>}      {/* Pending */}
      {pending.length > 0 && (
        <section className="mb-8">
          <h2 className="text-sm font-semibold text-gray-400 uppercase tracking-widest mb-3">
            Awaiting Review ({pending.length})
          </h2>
          {pending.map(c => (
            <IncidentCard key={c.id} card={c} onAction={handleAction} />
          ))}
        </section>
      )}      {pending.length === 0 && !loading && (
        <div className="bg-gray-900 border border-gray-700 rounded-xl p-8 text-center text-gray-500 mb-8">
          No pending incidents. The cluster looks healthy.
        </div>
      )}      {/* Resolved */}
      {resolved.length > 0 && (
        <section>
          <h2 className="text-sm font-semibold text-gray-400 uppercase tracking-widest mb-3">
            Resolved ({resolved.length})
          </h2>
          {resolved.map(c => (
            <IncidentCard key={c.id} card={c} onAction={handleAction} />
          ))}
        </section>
      )}
    </div>
  );
}ReactDOM.createRoot(document.getElementById("root")).render(<App />);
</script>
</body>
</html>
EOF

Крок 6: Dockerfile фронтенду

Образ nginx обслуговує статичну сторінку:

cat > Dockerfile <<'EOF'
FROM nginx:alpine
COPY index.html /usr/share/nginx/html/index.html
EXPOSE 80
EOF

Крок 7: Створення зображень та їх завантаження до Kind

Кожне зображення створюється, а потім завантажується до локального кластера, починаючи з бекенду:

cd ~/k8s-aiops-blog/dashboard/backend
docker build -t approval-backend:v1 .
kind load docker-image approval-backend:v1 --name aiops

а потім фронтенд:

cd ~/k8s-aiops-blog/dashboard/frontend
docker build -t approval-frontend:v1 .
kind load docker-image approval-frontend:v1 --name aiops

Крок 8: Маніфести Kubernetes

Один файл dashboard.yaml містить інформацію про Deployments та Services для обох частин:

cat > ~/k8s-aiops-blog/k8s/dashboard.yaml <<'EOF'
# ── Backend ────────────────────────────────────────────────────────────────
apiVersion: apps/v1
kind: Deployment
metadata:
  name: approval-backend
  namespace: apps
spec:
  replicas: 1
  selector:
    matchLabels:
      app: approval-backend
  template:
    metadata:
      labels:
        app: approval-backend
    spec:
      containers:
        - name: backend
          image: approval-backend:v1
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 9000
          readinessProbe:
            httpGet:
              path: /healthz
              port: 9000
            initialDelaySeconds: 5
            periodSeconds: 10
          resources:
            requests:
              memory: "128Mi"
              cpu: "100m"
            limits:
              memory: "256Mi"
              cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: approval-dashboard
  namespace: apps
spec:
  selector:
    app: approval-backend
  ports:
    - port: 9000
      targetPort: 9000
---
# ── Frontend ───────────────────────────────────────────────────────────────
apiVersion: apps/v1
kind: Deployment
metadata:
  name: approval-frontend
  namespace: apps
spec:
  replicas: 1
  selector:
    matchLabels:
      app: approval-frontend
  template:
    metadata:
      labels:
        app: approval-frontend
    spec:
      containers:
        - name: frontend
          image: approval-frontend:v1
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
          resources:
            requests:
              memory: "64Mi"
              cpu: "50m"
            limits:
              memory: "128Mi"
              cpu: "200m"
---
apiVersion: v1
kind: Service
metadata:
  name: approval-frontend-svc
  namespace: apps
spec:
  selector:
    app: approval-frontend
  ports:
    - port: 3000
      targetPort: 80
EOF

Застосуйте його, а потім почекайте, поки завершаться обидві розгортання:

kubectl apply -f ~/k8s-aiops-blog/k8s/dashboard.yaml
kubectl rollout status deployment/approval-backend -n apps
kubectl rollout status deployment/approval-frontend -n apps

Крок 9: Відкрийте панель керування

Потрібно ще два перенаправлення портів, кожне у новій вкладці терміналу. Перше з них робить доступним бекенд:

kubectl port-forward -n apps svc/approval-dashboard 9000:9000

Другий показує фронтенд:

kubectl port-forward -n apps svc/approval-frontend-svc 3000:3000

Перейдіть за адресою http://localhost:3000. На сторінці відображається порожній стан «No pending incidents», що наразі є правильним.

Крок 10: Запустіть весь цикл

Саме тут все зустрічається, тому використайте чотири вкладки терміналу поруч одна з одною. Перша відстежує журнали агента:

kubectl logs -n apps deployment/remediation-agent --tail=5 -f

Другий стежить за пакетами сервісу підсумовування:

kubectl get pods -n apps -w

Третій запускає цикл збоїв:

kubectl set env deployment/summarizer -n apps KILL_ME=true
curl -s http://localhost:8000/crash

Четвертий — це браузер на http://localhost:3000.

Протягом приблизно тридцяти секунд агент фіксує сигнал про цикл збоїв, позначає аномалію, викликає Groq та записує діагноз із пропозицією виправлення:

... WARNING  crash loop signal: error_rate=1.00
... INFO     anomaly detected: crash_loop — calling Groq for diagnosis
... INFO     diagnosis: type=crash_loop severity=critical confidence=0.91
              fix=kubectl set env deployment/summarizer -n apps KILL_ME-
... INFO     incident posted: id=<uuid> type=crash_loop

Панель керування оновлюється сама кожні десять секунд, і з’являється картка інциденту:

CRITICAL  Crash Loop — summarizer               91% confidence
Root cause: The KILL_ME environment variable is set to true, causing the process to exit immediately on each start.
$ kubectl set env deployment/summarizer -n apps KILL_ME-
[ ✓ Approve ]  [ ✗ Reject ]

Клацання на «Затвердити» змушує сервер перевірити команду за списком дозволених, виконати її та оновити картку:

✓ Approved by operator
deployment.apps/summarizer env updated

У вкладці спостереження за підами сумаризатор запускається без проблем та доходить до стану «Running 1/1», не переходячи у режим CrashLoopBackOff. Цикл завершено.

Збереження чесності списку дозволів

Цей список є навмисно консервативним. У реальному середовищі його можна розширити на основі інструкцій, яких вже дотримується команда. Якщо стандартним рішенням проблеми витоку пам’яті завжди є kubectl rollout restart, додайте його. Якщо іноді потрібен kubectl scale, додайте його також.

Не додавайте нічого руйнівного. Штучний інтелект ніколи не є достатньо надійним, щоб доручати йому виконання команди kubectl delete. Крок схвалення існує тому, що саме 9 відсотків випадків, коли модель робить помилку зі 91 відсотком впевненості, змушують когось прокинутися о 3 годині ранку.

Що залишилося

Далі йдуть кілька додатків. Повний огляд циклу збоїв, процесу завершення роботи через нестачу пам’яті та різкого зростання кількості токенів покаже часові шкали SigNoz для кожного з них. Сховище інцидентів у оперативній пам’яті має бути замінене справжньою базою даних, Slack може повідомляти про кожну нову картку, а екосистема CNCF містить проекти, які варто вивчити для використання в промислових умовах.

Пов’язана література

  • Self-Healing Kubernetes in Action: Three Failures, SigNoz Signals and Approved Fixes — Детальний огляд циклу збоїв, процесу завершення роботи через нестачу пам’яті та різкого зростання кількості токенів у кластері Kind, показ того, що показує SigNoz для кожного випадку, та порад щодо посилення захисту перед використанням AI-агента для усунення проблем.
  • Самовідновлювана команда багатьох агентів у LangGraph: архітектор, тестувальник, дебагер — створіть машину станів LangGraph на Python, де архітектор, розробник, сандбокс pytest, дебагер та рецензент співпрацюють та продовжують роботу, поки тести не пройдуть.