Галоўная / Артыкулы

Панель керування затверджэнням для агента выкарыстоўвання Kubernetes: FastAPI і React

Створыце бэкэнд на FastAPI з каліктулом allowlist і панеллю кантролю на React, каб агент для выліквавання проблем з LLM мог усунуць інцыдэнты толькі пасля таго, як чалавек нажме «Затвердзіць».

Выдавец: 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. На старонцы паказана порожняя станцыя «Няма чакаючых інцыдэнтав», што наразе ўсуне.

Шаг 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, дэбаггер і рэвізор сааверцуюць і продовжаюць работу, пакуль тэсты не пройдуць.