Skip to main content
Glama

GitOps Drift Remediation Agent

License: Apache 2.0 Node.js Version TypeScript

Ein produktionsreifer autonomer Agent, der sich mit Kubernetes-Clustern und GitOps-Repositories verbindet, unautorisierten Zustandsdrift erkennt, sichere Remediationsstrategien generiert und automatisierte API-Patches oder Pull Requests ausführt.


Inhaltsverzeichnis


Related MCP server: kube-lint-mcp

Überblick

Der GitOps Drift Remediation Agent ist eine autonome, policygesteuerte Plattform, die den Live-Zustand von Kubernetes-Ressourcen kontinuierlich mit ihrer deklarierten GitOps-Quelle der Wahrheit abgleicht. Wenn Drift erkannt wird, bewertet der Agent die anwendbaren Remediationsrichtlinien, berechnet minimale JSON-Patch-Operationen und wendet sie entweder direkt über die Kubernetes-API an oder eröffnet Pull Requests gegen das GitOps-Repository – alles mit vollständigen Audit-Trails.

Kernprinzipien

  • Minimaler Schadensradius: Patches werden als kleinstmöglicher Diff berechnet, niemals als vollständige Ressourcenersetzungen

  • Policy zuerst: Jede Remediationsmaßnahme wird durch konfigurierbare, versionierte Richtlinien mit Risikostufen abgesichert

  • Unveränderliches Audit-Log: Jede Entscheidung, Erkennung und Mutation wird mit kryptografischem Kontext protokolliert

  • GitOps-nativ: Der Agent wird selbst über GitOps verwaltet und gibt PRs an das Repository zurück

  • MCP-bereit: Stellt alle Fähigkeiten als MCP-Tools für die LLM-Agenten-Integration bereit


Architektur

┌─────────────────────────────────────────────────────────────────────┐
│                    GitOps Drift Remediation Agent                   │
│                                                                     │
│  ┌─────────────┐    ┌──────────────┐    ┌────────────────────────┐ │
│  │  AST Differ │───▶│ Policy Engine│───▶│    Patch Engine        │ │
│  │             │    │              │    │                        │ │
│  │ • Deep diff │    │ • Risk tiers │    │ • JSON Patch RFC 6902  │ │
│  │ • Field     │    │ • Allow/deny │    │ • K8s API apply        │ │
│  │   tracking  │    │ • Dry-run    │    │ • PR generation        │ │
│  │ • Severity  │    │ • Approvals  │    │ • Rollback support     │ │
│  └─────────────┘    └──────────────┘    └────────────────────────┘ │
│         │                  │                       │                │
│         └──────────────────┴───────────────────────┘                │
│                            │                                        │
│                   ┌────────▼────────┐                               │
│                   │  Audit Logger   │                               │
│                   │                 │                               │
│                   │ • Structured    │                               │
│                   │   JSON logs     │                               │
│                   │ • Event chain   │                               │
│                   │ • Pino backend  │                               │
│                   └─────────────────┘                               │
│                                                                     │
│  ┌──────────────────────────────────────────────────────────────┐  │
│  │                      MCP Server                              │  │
│  │  detect_drift │ list_policies │ remediate │ get_audit_trail  │  │
│  └──────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────┘
         │                                          │
         ▼                                          ▼
  ┌─────────────┐                          ┌───────────────┐
  │  Kubernetes │                          │  GitOps Repo  │
  │  Cluster(s) │                          │  (Git/GitHub) │
  └─────────────┘                          └───────────────┘

Funktionen

Funktion

Beschreibung

Drift-Erkennung

Tiefgehender AST-basierter Abgleich des Live- vs. Soll-Zustands von Kubernetes-Ressourcen

Risikoklassifizierung

Automatisierte Schweregradbewertung (kritisch / hoch / mittel / niedrig) pro Feldpfad

Policy-Engine

Deklarative, versionierte Richtlinien mit Erlauben/Verweigern-Regeln, Dry-Run und Genehmigungsstufen

Patch-Engine

RFC-6902-JSON-Patch-Berechnung mit Unterstützung für K8s-Server-Side-Apply

GitOps-PRs

Automatisierte Pull-Request-Erstellung mit Drift-Diff und Remediationsbegründung

Audit-Trail

Unveränderliche strukturierte Audit-Logs mit vollständigen Entscheidungsketten

MCP-Server

Alle Agentenfähigkeiten als MCP-Tools für die KI-Agenten-Orchestrierung

CLI

Voll ausgestattete CLI für interaktiven und automatisierten Betrieb


Installation

Voraussetzungen

  • Node.js >= 20.0.0

  • kubectl mit Zugriff auf den Zielcluster konfiguriert

  • Git-Anmeldedaten für das GitOps-Repository (für den PR-Modus)

Installation aus dem Quellcode

git clone https://github.com/your-org/gitops-drift-remediation-agent.git
cd gitops-drift-remediation-agent
npm install
npm run build
npm link   # optional: makes `drift-agent` available globally

Konfiguration

Die gesamte Konfiguration erfolgt über Umgebungsvariablen oder eine Konfigurationsdatei.

Umgebungsvariablen

Variable

Erforderlich

Standard

Beschreibung

KUBECONFIG

Nein

~/.kube/config

Pfad zur Kubeconfig-Datei

KUBECONTEXT

Nein

current-context

Zu verwendender Kubernetes-Kontext

GITOPS_REPO_URL

Nein

—

GitOps-Repository-URL für den PR-Modus

GITOPS_BRANCH

Nein

main

Zielbranch für PRs

GITOPS_TOKEN

Nein

—

Git-Provider-Token (GitHub/GitLab)

POLICY_CONFIG_PATH

Nein

./policies.yaml

Pfad zur Remediationsrichtlinien-Konfiguration

AUDIT_LOG_PATH

Nein

./audit.log

Ausgabepfad für das Audit-Log

AUDIT_LOG_LEVEL

Nein

info

Log-Level (debug/info/warn/error)

DRY_RUN

Nein

false

Globaler Dry-Run-Modus

MCP_PORT

Nein

3000

HTTP-Port des MCP-Servers

NAMESPACE_FILTER

Nein

*

Kommagetrennter Namespace-Filter


Verwendung

CLI-Befehle

# Detect drift across all namespaces
drift-agent detect --namespace production --output json

# Detect and auto-remediate with policy gate
drift-agent remediate --namespace production --policy strict --dry-run

# List active policies
drift-agent policy list

# Show audit trail for a resource
drift-agent audit --resource deployments/my-app --namespace production

# Start MCP server
drift-agent mcp-server --port 3000

Programmierschnittstelle (API)

import { AstDiffer } from './src/detector/ast-differ';
import { RemediationPolicy } from './src/policy/remediation-policy';
import { PatchEngine } from './src/remediator/patch-engine';

const differ = new AstDiffer();
const drifts = await differ.detectDrift(liveResource, desiredResource);

const policy = new RemediationPolicy(policyConfig);
const decision = await policy.evaluate(drifts, resourceContext);

if (decision.approved) {
  const engine = new PatchEngine(k8sClient);
  await engine.applyRemediation(decision.patches, resourceRef);
}

MCP-Server

Der Agent stellt einen MCP-Server (Model Context Protocol) bereit, der alle Agentenfähigkeiten als Tools für LLM-basierte Agenten (Claude, GPT-4 usw.) verfügbar macht.

Starten des Servers

drift-agent mcp-server --port 3000
# or
npm run mcp:server

Verfügbare MCP-Tools

Tool

Beschreibung

detect_drift

Drift für eine Ressource oder einen Namespace erkennen

list_policies

Alle konfigurierten Remediationsrichtlinien auflisten

evaluate_policy

Drift gegen eine bestimmte Richtlinie bewerten

apply_remediation

Berechnete Remediationspatches anwenden

get_audit_trail

Audit-Ereignisse für eine Ressource abrufen

generate_pr

GitOps-PR für die Driftbehebung generieren

rollback_remediation

Eine zuvor angewendete Remediation zurückrollen

MCP-Client-Konfiguration

{
  "mcpServers": {
    "gitops-drift-agent": {
      "url": "http://localhost:3000/mcp",
      "transport": "http"
    }
  }
}

Policy-Engine

Richtlinien werden deklarativ definiert und steuern jeden Aspekt des Remediationslebenszyklus.

Richtlinienstruktur

apiVersion: drift.gitops.io/v1
kind: RemediationPolicy
metadata:
  name: production-strict
spec:
  riskTier: high
  autoRemediate: false
  requireApproval: true
  dryRunFirst: true
  rules:
    - field: "spec.replicas"
      action: restore
      severity: high
    - field: "spec.template.spec.containers[*].image"
      action: block
      severity: critical
  excludeFields:
    - "metadata.annotations['kubectl.kubernetes.io/last-applied-configuration']"
    - "metadata.resourceVersion"
    - "metadata.uid"

Audit & Telemetrie

Jede Agentenaktion wird in strukturiertem JSON-Format protokolliert:

{
  "timestamp": "2024-06-01T12:00:00.000Z",
  "eventId": "evt_01J0ABC123",
  "eventType": "DRIFT_DETECTED",
  "severity": "high",
  "resource": {
    "kind": "Deployment",
    "name": "my-app",
    "namespace": "production",
    "apiVersion": "apps/v1"
  },
  "drift": {
    "field": "spec.replicas",
    "desired": 3,
    "live": 1,
    "changeType": "edited"
  },
  "policy": {
    "name": "production-strict",
    "decision": "remediate",
    "riskTier": "high"
  },
  "actor": {
    "agentVersion": "1.0.0",
    "kubeContext": "prod-cluster"
  }
}

Entwicklung

# Install dependencies
npm install

# Run in development mode (ts-node)
npm run dev -- detect --namespace default

# Type check only
npm run typecheck

# Lint
npm run lint

# Format
npm run format

# Build
npm run build

Tests

# Run all tests
npm test

# Run with coverage
npm run test:coverage

# Run in watch mode
npm run test:watch

Die Tests sind unter tests/ organisiert und verwenden Jest mit ts-jest. Für den Kubernetes-Client und Dateisystemoperationen werden Mocks bereitgestellt.


Sicherheitshinweise

  1. Minimalrechte: Der Agent benötigt nur get-, list-, watch- und patch-Berechtigungen für Zielressourcen – niemals delete oder create

  2. Dry-Run standardmäßig: Alle Richtlinienstufen sind standardmäßig im Dry-Run-Modus, bis sie explizit aktiviert werden

  3. Genehmigungsstufen: Änderungen mit hohem und kritischem Risiko erfordern eine explizite Genehmigung über die Richtlinie

  4. Audit-Unveränderlichkeit: Audit-Logs sind append-only; die Log-Rotation erfolgt extern

  5. Secret-Maskierung: Werte von Secret-Ressourcen werden in Logs und PRs immer geschwärzt

  6. Kubeconfig-Isolation: Der Agent verändert die Kubeconfig niemals


Mitwirken

Siehe CONTRIBUTING.md. Alle Beiträge erfordern:

  • Bestehende Testsuite mit >= 80 % Abdeckung

  • Keine neuen Lint-Warnungen

  • Audit-Log-Einträge für alle neuen Mutationspfade

  • Richtlinienbewertung für alle neuen Remediationsmaßnahmen


Lizenz

Apache 2.0 – siehe LICENSE.

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Provides MCP multi-cluster Kubernetes management and operations. It can be integrated as an SDK into your own project and includes nearly 50 built-in tools covering common DevOps and development scenarios. Supports both standard and CRD resources.
    151
    MIT
  • A
    license
    C
    quality
    B
    maintenance
    A policy-aware MCP server for GitHub and GitHub Actions that enables safe AI-assisted infrastructure workflows—inspecting repositories, preparing branches and pull requests, and constrained remote mutations behind explicit preview-bound approval tokens.
    18
    MIT