Dynatrace-Webhook  →  Agent Builder erhält Alarm  →  Gemini analysiert  →  MCP-Tools führen aus  →  Bedrohung neutralisiert
       1 s                        2 s                      8 s                  15 s                  25 s gesamt

┌──────────────────────────────────────────────────────────────────────┐
│                         SANDBOX-UMGEBUNG                              │
│                                                                      │
│   ┌─────────────┐   100–1000 req/s   ┌──────────────────────────┐   │
│   │  Angreifer  │ ──────────────────►│    victim-service        │   │
│   │ (DDoS/SQLi)  │                    │    Port 8080             │   │
│   └─────────────┘                    │    /admin/* Kontroll-API │   │
│                                      └────────────┬─────────────┘   │
└───────────────────────────────────────────────────│──────────────────┘
                                                    │ Metriken + Anomalie-Webhook
                   ┌────────────────────────────────▼─────────────────┐
                   │         Dynatrace Mock  (Anomalie-Engine)         │
                   │  Bedrohungs-Risiko-Score → sendet POST /alerts/simulate│
                   └────────────────────────┬─────────────────────────┘
                                            │ Webhook
          ┌─────────────────────────────────▼──────────────────────────┐
          │          Google Cloud Agent Builder  (Vertex AI Agent)      │
          │  ┌──────────────────────────────────────────────────────┐  │
          │  │  Gemini 2.0 Flash  ──  analysiert Bedrohungskontext │  │
          │  │  Tool-Manifest  ──  dynamisch von MCP abgerufen      │  │
          │  │  HITL-Schleuse  ──  stoppt bei Konfidenz < Schwelle   │  │
          │  └──────────────────────────────────────────────────────┘  │
          └──────────────┬─────────────────────────┬───────────────────┘
                         │ REST-Aufrufe              │ Prüfpfad schreiben
         ┌───────────────▼──────┐      ┌────────────▼──────────┐
         │  MCP-Server  :8001   │      │  MongoDB 7.0 Atlas    │
         │  11 echte Tools      │      │  Vorfälle + Traces    │
         └───────────┬──────────┘      └───────────────────────┘
                     │ wirkt auf Live-Infrastruktur
         ┌───────────▼──────────┐
         │  FastAPI  :8000      │
         │  victim-service :8080│
         └──────────────────────┘

                   ┌──────────────────────────────────────────────────┐
                   │              OBSERVABILITY-STACK                  │
                   │  OTel Collector ──► Jaeger  (verteilte Traces)    │
                   │  Prometheus ──────────────► Grafana               │
                   └──────────────────────────────────────────────────┘

.\attack.production.ps1 status   # Überprüfen, ob alle Dienste gesund sind
.\attack.production.ps1 ddos     # DDoS — Gemini blockiert IPs + Ratenbegrenzung
.\attack.production.ps1 sql      # SQL-Injection — Gemini aktiviert WAF
.\attack.production.ps1 brute    # Brute Force — Gemini blockiert Quell-IPs
.\attack.production.ps1 stop     # Abwehr zurücksetzen

class SentinelAgent(reasoning_engines.Queryable):

    def set_up(self):
        # MCP-Tools als Vertex AI FunctionDeclarations — Gemini wählt zur Laufzeit aus
        mcp_tools = Tool(function_declarations=[
            FunctionDeclaration(name="block_ip_address", ...),
            FunctionDeclaration(name="activate_waf", ...),
            FunctionDeclaration(name="rate_limit_requests", ...),
            FunctionDeclaration(name="scale_service", ...),
            FunctionDeclaration(name="collect_forensic_logs", ...),
            FunctionDeclaration(name="analyze_attack_pattern", ...),
        ])
        self._model = GenerativeModel("gemini-2.0-flash-001", tools=[mcp_tools])
        self._chat = self._model.start_chat()

    def query(self, *, incident: dict) -> dict:
        # Einstiegspunkt — Agent Builder ruft dies für jeden Dynatrace-Webhook auf
        response = self._chat.send_message(threat_prompt(incident))
        tool_calls = [{"name": p.function_call.name, "args": dict(p.function_call.args)}
                      for p in response.candidates[0].content.parts if p.function_call]
        return {"engine": "agent_builder", "tool_calls": tool_calls, ...}

# Lokal testen (kein GCP erforderlich mit google_ai_studio-Backend)
python scripts/deploy_agent_builder.py --test-only

# Auf verwalteten Agent Builder-Endpunkt bereitstellen
python scripts/deploy_agent_builder.py --project my-gcp-project

# .env
GEMINI_BACKEND=agent_builder
GOOGLE_CLOUD_PROJECT=my-gcp-project
VERTEX_LOCATION=us-central1

GET /mcp/tools  →  gibt 11 Tool-Deskriptoren zurück  →  Gemini wählt Tools aus und ruft sie auf

docker compose up -d --build

cd simulacion
docker compose up -d victim-service
cd ..

docker compose ps
# Erwartet: 8 Dienste laufen/gesund

curl http://localhost:8000/health
# Erwartet: {"status": "healthy", "service": "SentinelMCP", ...}

.\attack.ps1 ddos        # DDoS-Angriff (Standard)
.\attack.ps1 sql         # SQL-Injection
.\attack.ps1 brute       # Brute Force
.\attack.ps1 stop        # Angriff stoppen + Abwehr zurücksetzen
.\attack.ps1 status      # Systemzustand prüfen

http://localhost:8000/dashboard

# .env bearbeiten
GOOGLE_API_KEY=AIza...Ihr_Schlüssel_hier
GEMINI_BACKEND=google_ai_studio

gcloud auth application-default login
.\scripts\setup_gcloud.ps1   # setzt Projekt, erstellt SA-Key, aktualisiert .env automatisch

GET http://localhost:8001/mcp/tools

sentinel_mcp/
├── api/              FastAPI-Kern — Routen, Schemata, Dashboard-UI
├── agent/            Entscheidungs-Engine + LLM-Anbieter (Gemini 2.0 Flash, Vertex AI)
├── mcp_server/       MCP-Server + 11 Tool-Implementierungen
├── services/         Vorfall-Dienst, Remediation-Orchestrator, Bedrohungsrechner
├── observability/    OTel / Dynatrace / SigNoz-Anbieter
└── core/             Konfiguration, Logging, Ausnahmen

simulacion/
├── victim-service/   FastAPI-Zieldienst mit /admin/* Kontrollebene
└── attacker/         Python-Angriffs-Engine (DDoS / SQLi / Brute Force)

docker/
├── prometheus.yml    Scrape-Konfiguration (victim-service alle 5s)
└── grafana/          Automatisch bereitgestelltes Dashboard — 6-Felder-Infrastruktur-Beobachtung