# **StyloBot.:, so einfach wie möglich und kein einfacheres Teil**
*Enterprise Bot-Detektion sollte erforderlich sein, um einen PhD in der Infrastruktur zu verwenden.(oder tausende pro Monat in Ausgaben für die Verwendung von zwei Zeilen Code, ,, Null externe Dienste, , und you, 're laufen bis zu ), MSC8, Detektoren in Millisekunden auf jede Anfrage an jeden Endpunkt.*
**[Lesen Sie Teil StyloBot:® Kampf gegen Scrapers](https://www.mostlylucid.net/blog/botdetection-introduction)**
**[Lesen Sie Teil, wie Bots Smarter bekam](https://www.mostlylucid.net/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture)**
**[StyloBot®.®net](https://stylobot.net)** Das reale Produktionssystem, das früh läuft.-.Exit-Detektion inline am Gateway.
2026-02-16T10:30
[](https://www.nuget.org/packages/mostlylucid.botdetection/)
[](https://github.com/scottgal/stylobot)
[](https://hub.docker.com/r/scottgal/stylobot-gateway)
---
[TOC]
---
## Die Idee
Einstein sagte angeblich: , Alles sollte so einfach wie möglich gemacht werden.,, aber kein einfacheres, dass das Design-Prinzip von StyloBot's Integrationsmodell ist.
Teile, die mit einem Fassungsvermögen von mehr als 1 kg oder weniger abgedeckt sind *warum* Bot-Detektionsfragen und *wie die Detektionspipeline funktioniert*Dieser Beitrag umfasst *wie wenig Code man eigentlich braucht* - und wie das gleiche System von einer Single---Datei-App zu einem vollständigen Produktionsgateway mit TimescaleDBC2, Qdrant-Vektorsuche ,, CPU, nur LLM-Klassifikation . skaliert
Die wichtigsten Erkenntnisse **jede Ebene verwendet die gleiche Detektionspipeline**Du schaltest die Rahmen nicht, während du anbaust. Du mischst Speicher und Bereicherung um denselben Kern.
---
## Zwei Codezeilen
Dies ist das absolute Minimum.... keine Konfigurationsdatei... keine Datenbankeinstellung... keine API-Schlüssel... keine Docker-Container...
```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection(); // ← that's line 1
var app = builder.Build();
app.UseBotDetection(); // ← that's line 2
app.Run();
```
Was gerade passiert ist
- **Detektoren** registriert: : userAgent pattern matching – , header consistency – , UP Datacenter Detection –, bushual analysis – MSC4 TPLS Fingerprinting – MCSK5 TP3/ TPCP-/ TP-Fingerabdruckanalyse – , HTTP-/2 ftexprinting - , chate-Verhaltensanalytik – MKS12 antwortsverhaltensfeedback – MSA13 – multi---Schichtkorrelation – MSSK15 und mehr – MSR16
- **Wave---basierte Pipeline**Detektoren, die in Abhängigkeitswellen laufen, ., Welle, 0, keine Abhängigkeiten, parallel ausgeführte ), spätere Wellen lösen nur dann aus, wenn frühere Signale eine tiefere Analyse rechtfertigen..,
- **SQLite-Speicher**:" A `botdetection.db` Datei auto--Creates für gelernte Muster und Gewichte-.Created No setup
- **In---Prozess-Ähnlichkeitssuche**HNSW Index für die Suche nach ähnlichen Bot-Signaturen
- **Heuristische Wertung**Eigenschaften, die pro Anfrage extrahiert wurden, werden durch ein leichtes im --Prozessmodell gewertet.
All dies läuft in **unter „1" Millisekunde** pro Anfrage auf Rohstoff-Hardware... nur für die CPU... keine GPU...
Jede Anfrage hat jetzt Erkennungsergebnisse über `HttpContext` erweiterungen
```csharp
app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
isBot = ctx.IsBot(),
probability = ctx.GetBotProbability(), // 0.0-1.0: how likely it's a bot
confidence = ctx.GetDetectionConfidence(), // 0.0-1.0: how certain the system is
type = ctx.GetBotType()?.ToString(),
name = ctx.GetBotName()
}));
```
Detektion läuft, aber nichts blockiert – .-Sie entscheiden, was mit den Ergebnissen zu tun ist.
---
## Blockieren Sie alle Bots.,. Ganze App
Wenn Sie gerade Bots von Ihrer gesamten Anwendung sperren möchten, keine per-per--endpoint config-, keine Attribute - es ist eine Zeile JSON-:.
```json
{
"BotDetection": {
"BlockDetectedBots": true
}
}
```
Dass ,' , es , . , Detektierte Bots über Ihrem Block , - , Vertrauensschwelle erhalten ein , ,403 , ( ,`MinConfidenceToBlock` Standardwerte für `0.8`Googlebot,Bingbot),C Social Media Previews Facebook,C Twitter/CXC),C und Überwachung Bots UberwachungszeitRoboter,C Pingdom)C sind per Default erlaubt -, weil Sie fast sicher wollen, dass diese
Oder die gleiche Sache im Code-Code, keine Konfigurationsdatei benötigt
```csharp
builder.Services.Configure(o =>
{
o.BlockDetectedBots = true;
o.MinConfidenceToBlock = 0.8; // only block when confident
o.AllowVerifiedSearchEngines = true; // Googlebot, Bingbot through
o.AllowSocialMediaBots = true; // Facebook, Twitter previews through
o.AllowMonitoringBots = true; // UptimeRobot, Pingdom through
});
```
Dies ist die ." .Ich möchte nicht daran denken , dass es " . . . . Detektion läuft . , . Bots werden blockiert , . gute Raupen erhalten durch . . . Bewegen Sie sich zu per .- .endpoint-Steuerung, wenn Sie es brauchen
---
## Minimales API-Beispiel Das komplette Beispiel
Hier ist ein komplettes ,, , Arbeits API mit Per-- , Endpoint Bot Schutz , . , Dies ist die gesamte `Program.cs`:
```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();
var app = builder.Build();
app.UseBotDetection();
// Detection results available, no blocking
app.MapGet("/", (HttpContext ctx) => Results.Ok(new
{
isBot = ctx.IsBot(),
probability = ctx.GetBotProbability(),
confidence = ctx.GetDetectionConfidence(),
type = ctx.GetBotType()?.ToString(),
name = ctx.GetBotName()
}));
// Block all bots
app.MapGet("/api/data", () => Results.Ok(new { data = "sensitive" }))
.BlockBots();
// Allow search engines (Googlebot, Bingbot, Yandex)
app.MapGet("/products", () => Results.Ok(new { catalog = "public" }))
.BlockBots(allowSearchEngines: true);
// Allow search engines + social media previews (Facebook, Twitter/X)
app.MapGet("/blog/{slug}", (string slug) => Results.Ok(new { post = slug }))
.BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);
// Health check: monitoring bots allowed (UptimeRobot, Pingdom)
app.MapGet("/health", () => Results.Ok("healthy"))
.BlockBots(allowMonitoringBots: true);
// Humans only - blocks ALL bots including verified crawlers
app.MapPost("/api/submit", () => Results.Ok(new { submitted = true }))
.RequireHuman();
// High-confidence blocking only (reduces false positives)
app.MapGet("/api/lenient", () => Results.Ok("data"))
.BlockBots(minConfidence: 0.9);
// Geo + network blocking (needs GeoDetection contributor)
app.MapPost("/api/payment", () => Results.Ok("ok"))
.BlockBots(blockCountries: "CN,RU", blockVpn: true, blockDatacenter: true);
// Honeypot: deliberately allow scrapers in
app.MapGet("/honeypot", () => Results.Ok("welcome"))
.BlockBots(allowScrapers: true, allowMaliciousBots: true);
// Dev diagnostics
app.MapBotDetectionEndpoints();
app.Run();
```
Jede `.BlockBots()` Anrufblöcke **alle** Bot-Typen per Default – .-Sie entscheiden sich für bestimmte Typen *in der* mit der `Allow*` Parameter: Die Idee wird verweigert-von:-Default: , Weiße Liste der guten
### Bot-Typen, die Sie zulassen können
Parameter für das, was es erlaubt, warum Sie es verwenden
|-----------|---------------|-----------------|
| `allowSearchEngines` Googlebot: ,Bingbot:,BYNDEX SEO – -Sie möchten indexiert werden
| `allowSocialMediaBots` Facebook Twitter Twitter LinkedIn Vorschau auf den Link , Offene Graphenkarten |
| `allowMonitoringBots` BetriebszeitRoboter,B Pingdom,B StatusCake Gesundheitskontrollen,B Betriebszeitüberwachung
| `allowAiBots` GPTBot, ClaudeBot, ClaudeBotMSK2 , Google, - , Erweitert , MSC4 , Opt-- , um AI-Training , | ,
| `allowGoodBots` Zuführungsleser ,-Link-Checker Benachteiligte Automatisierung
| `allowVerifiedBots` Verifizierte Crawler von -Verstärkter Automatisierung
| `allowScrapers` SemrushBot - Honeypots - SEO-Forschung
| `allowMaliciousBots` Bekannte schlechte Akteure
| `minConfidence` | *(-Schwellenwert* Nur blockieren, wenn das System sehr sicher ist.
---
## MVC-Steuerungsmerkmale
Gleiche Detektions-Pipeline - Schutz durch Attribute - .
```csharp
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddBotDetection();
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.UseBotDetection();
app.MapControllers();
app.Run();
```
### Die Attribute
```csharp
[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
// No protection - detection runs but nothing blocks
[HttpGet]
public IActionResult List() => Ok(new { products = "all" });
// Block all bots, allow search engines
[HttpGet("catalog")]
[BlockBots(AllowSearchEngines = true)]
public IActionResult Catalog() => Ok(new { catalog = "indexed" });
// Block all bots, allow search engines + social previews
[HttpGet("{id:int}")]
[BlockBots(AllowSearchEngines = true, AllowSocialMediaBots = true)]
public IActionResult Detail(int id) => Ok(new { id });
}
// Entire controller: humans only
[ApiController]
[Route("[controller]")]
[RequireHuman]
public class CheckoutController : ControllerBase
{
[HttpPost("cart")]
public IActionResult AddToCart() => Ok();
[HttpPost("pay")]
public IActionResult Pay() => Ok();
}
// Infrastructure endpoints
[ApiController]
[Route("[controller]")]
public class InfraController : ControllerBase
{
// Skip detection entirely
[HttpGet("health")]
[SkipBotDetection]
public IActionResult Health() => Ok("ok");
// Monitoring bots allowed
[HttpGet("status")]
[BlockBots(AllowMonitoringBots = true)]
public IActionResult Status() => Ok(new { uptime = "99.9%" });
}
```
### Geografisches Blockieren des Netzwerks
Diese arbeiten sowohl an MVC-Attributen als auch an Minimal API-Filtern.Sie benötigen den GeoDetection Contributor für Signaldaten.
```csharp
// Block countries
[BlockBots(BlockCountries = "CN,RU,KP")]
public IActionResult SensitiveApi() => Ok();
// Country whitelist - only these allowed
[BlockBots(AllowCountries = "US,GB,DE,FR")]
public IActionResult DomesticOnly() => Ok();
// Block VPNs + proxies (anti-fraud)
[BlockBots(BlockVpn = true, BlockProxy = true)]
public IActionResult Payment() => Ok();
// Block datacenter IPs + Tor
[BlockBots(BlockDatacenter = true, BlockTor = true)]
public IActionResult FormSubmission() => Ok();
// Combine: SEO-friendly + geo block + VPN block
[BlockBots(AllowSearchEngines = true, BlockCountries = "CN,RU", BlockVpn = true)]
public IActionResult ProtectedContent() => Ok();
```
---
## Jenseits von Block-/-Aktionspolitiken
Binärblock – /-allow ist einfach, aber begrenzt –.-Aktionspolitik getrennt *was Sie entdecken* von *Wie Sie reagieren*Definieren Sie die Antwortstrategien in config.,.orden Sie sie den Endpunkten zu.
### Appsettings.-json
```json
{
"BotDetection": {
"BotThreshold": 0.7,
"ActionPolicies": {
"api-block": {
"Type": "Block",
"StatusCode": 403,
"Message": "Bot traffic is not allowed."
},
"api-throttle": {
"Type": "Throttle",
"BaseDelayMs": 500,
"MaxDelayMs": 5000,
"ScaleByRisk": true,
"JitterPercent": 0.3
},
"shadow-mode": {
"Type": "LogOnly",
"AddResponseHeaders": true,
"LogFullEvidence": true
}
}
}
}
```
### Richtlinien den Endpunkten zuweisen
```csharp
// Bots get progressively slower responses (they don't know they're being throttled)
[BotPolicy("default", ActionPolicy = "api-throttle")]
public IActionResult Browse() => Ok();
// Hard block
[BotPolicy("default", ActionPolicy = "api-block")]
public IActionResult Confirm() => Ok();
// Shadow mode: log everything, block nothing (deploy first, tune later)
[BotPolicy("default", ActionPolicy = "shadow-mode")]
public IActionResult PublicApi() => Ok();
```
Fünf Richtlinientypen `Block` ,(,HTTP , 403),, `Throttle` (-Verzögerungen des Stealths `Challenge` (-CAPTCHA-/-proof---of---work-MSC4- `Redirect` Honeypot-Falle `LogOnly` Der Schatten-Modus von (, siehe [Maßnahmenpolitiken](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/action-policies.md) für die vollständige Referenz
Shadow-Modus ist der empfohlene Startpunkt...Deploy Detection.,.Beobachten Sie die Ergebnisse.MSC2. *dann* Sperren beginnen
---
## Was man umsonst bekommt
Jede Anfrage nach `UseBotDetection()` hat diese Erweiterungen verfügbar auf `HttpContext`:
```csharp
// Am I talking to a bot?
context.IsBot() // true if probability >= threshold
context.IsHuman() // inverse
context.IsSearchEngineBot() // Googlebot, Bingbot, etc.
context.IsVerifiedBot() // DNS-verified bots
context.IsMaliciousBot() // known bad actors
// How bad is it?
context.GetBotProbability() // 0.0-1.0: likelihood of being a bot
context.GetDetectionConfidence() // 0.0-1.0: how certain the system is
context.GetRiskBand() // Low, Elevated, Medium, High
context.GetRecommendedAction() // Allow, Challenge, Throttle, Block
// What is it?
context.GetBotType() // BotType enum
context.GetBotName() // "Googlebot", "Scrapy", etc.
// Full breakdown
var result = context.GetBotDetectionResult();
```
Zwei unabhängige Partituren sind hier von Bedeutung. **Bot-Wahrscheinlichkeit** Wie wahrscheinlich ist dies ein Bot-?) und **Detektionssicherheit** Wie sicher ist das System? *Mensch* Oder Sie können eine verdächtige Anfrage sehen, aber niedriges Vertrauen haben, weil nur ein Detektor ran.
---
## Signal---basierte Filterung
Über Bot-Typen hinaus: ,-StyloBot setzt Signale von seinen Detektoren frei..-Sie können Endpunkte auf der Grundlage spezifischer Signalwerte filtern.-- für Minimal API und MVC-.-
### Minimale API
```csharp
// Block VPN traffic
app.MapPost("/api/payment", () => Results.Ok())
.BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True");
// Block datacenter IPs
app.MapPost("/api/submit", () => Results.Ok())
.BlockIfSignal(SignalKeys.IpIsDatacenter, SignalOperator.Equals, "True");
// Only allow US traffic
app.MapGet("/api/domestic", () => Results.Ok())
.RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US");
// Block high-confidence bots by heuristic score
app.MapGet("/api/premium", () => Results.Ok())
.BlockIfSignal(SignalKeys.HeuristicConfidence, SignalOperator.GreaterThan, "0.9");
```
### MVC
```csharp
[BlockIfSignal(SignalKeys.GeoIsVpn, SignalOperator.Equals, "True")]
public IActionResult Payment() => Ok();
[RequireSignal(SignalKeys.GeoCountryCode, SignalOperator.Equals, "US")]
public IActionResult DomesticOnly() => Ok();
```
### Einlesen von Signalen
```csharp
app.MapGet("/debug", (HttpContext ctx) =>
{
var country = ctx.GetSignal(SignalKeys.GeoCountryCode);
var isVpn = ctx.GetSignal(SignalKeys.GeoIsVpn);
var isDc = ctx.IsDatacenter();
var heuristic = ctx.GetSignal(SignalKeys.HeuristicConfidence);
return Results.Ok(new { country, isVpn, isDc, heuristic });
});
```
Vollständige Signalreferenz [Signale und benutzerdefinierte Filter](https://github.com/scottgal/LLMApi/blob/main/Mostlylucid.BotDetection/docs/signals-and-custom-filters.md).
---
## Es zu testen
```bash
# Normal browser request → low bot score
curl -H "Accept: text/html" -H "Accept-Language: en-US" \
-A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
http://localhost:5090/
# Googlebot → allowed where AllowSearchEngines=true
curl -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
http://localhost:5090/products
# Scraper → blocked by .BlockBots()
curl -A "Scrapy/2.7" http://localhost:5090/api/data
# Full detection breakdown → shows all signals and per-detector contributions
curl http://localhost:5090/bot-detection/check
# Simulate bot types via test mode header
curl -H "ml-bot-test-mode: malicious" http://localhost:5090/bot-detection/check
curl -H "ml-bot-test-mode: scraper" http://localhost:5090/api/data
```
Das `/bot-detection/check` Endpoint ist dein Entwicklungsfreund. Es gibt jedes Signal von jedem Detektor zurück.
---
## Wie es skaliert von Datei zum vollen Stack
Dies ist das Design-Prinzip, das am meisten zählt **jede Ebene verwendet die gleiche Detektionspipeline**Sie werden niemals den Schutzcode neu schreiben, indem Sie die Infrastruktur um denselben Kern herum hinzufügen.
### Tier Tier, wo Sie beginnen
```
Your App + AddBotDetection()
└── SQLite (auto-created botdetection.db)
└── In-process [HNSW](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world_graphs) similarity search
└── 21 detectors, <1ms per request
└── No external services
```
Alle MSK-Detektoren laufen in einer Welle.-, die auf Pipeline basiert ist.., Fast--, Path Detektoren, UserAgent,, Header,, IP-,, Behavioral,, TLS Fingerabdruck, ), parallel in Wave ausführen.MSC10, Heuristische Scoring-Extrakte, Features und führt ein leichtes Scorings-Modell aus.MSSK12, Erlernte Muster bestehen weiterhin bei SQLite über Neustarts hinweg aus.
**Gut für** Einzel-App ,, , , <100 , K-Anfragen , / , Tag , , , Beginnen ,.
### Tier .2:-Geoerkennung hinzufügen
Fügen Sie Geo-Routing plus die geo contributor.
```csharp
builder.Services.AddBotDetection();
builder.Services.AddGeoRoutingWithDataHub(); // free local GeoIP DB (no account)
builder.Services.AddGeoDetectionContributor(options =>
{
options.FlagVpnIps = true;
options.FlagHostingIps = true;
});
```
Wenn IP-Geolokalisierung neu ist [Hintergrund der GeoIP](https://en.wikipedia.org/wiki/Geolocation_software#IP_address) und [DataHub GeoIP-Datensatz](https://datahub.io/core/geoip2-ipv4) sind gute Ausgangspunkte ,. , DataHubCsv lädt eine kostenlose .~27 ,MB IP-Datenbank auf den ersten Lauf und hält es wöchentlich aktualisiert , . , Alle Lookups sind lokal , - , keine per...- , HTTP-Anrufe anfordern ,. , Für die Stadt ,- , Levelpräzision , , , verwenden [MaxMind GeoLite-2](https://dev.maxmind.com/geoip/geolite2-free-geolocation-data/).
Jetzt erhalten Sie geo-Signale (Ausland,Ausland VPN,Ausgangspunkt,Auszugspunkt ,Ausrichtungspunkt-Erkennung)Ausrichtung und Bot Herkunftsnachweis (Ausführungspunkt eines chinesischen Rechenzentrums `BlockCountries`, `BlockVpn`, `BlockDatacenter`, `BlockTor` Parameter aktivieren - .-
### Tier Kategorie: PostgreSQL ZeitskalaDB
SQLite durch PostgreSQL für Multi---Server-Shared Learning ersetzen und hinzufügen [ZeitskalaDB](https://docs.timescale.com/) (-A PostgreSQL-Erweiterung für Zeit--Seriendaten)-Für Analysen:-
```csharp
builder.Services.AddBotDetection();
builder.Services.AddStyloBotDashboard();
builder.Services.AddStyloBotPostgreSQL(connectionString, options =>
{
options.EnableTimescaleDB = true;
options.RetentionDays = 90;
options.CompressionAfter = TimeSpan.FromDays(7);
});
```
```yaml
# docker-compose.yml
services:
timescaledb:
image: timescale/timescaledb:latest-pg16
environment:
POSTGRES_DB: stylobot
POSTGRES_USER: stylobot
POSTGRES_PASSWORD: ${DB_PASSWORD}
volumes:
- timescale-data:/var/lib/postgresql/data
app:
build: .
environment:
ConnectionStrings__BotDetection: "Host=timescaledb;Database=stylobot;Username=stylobot;Password=${DB_PASSWORD}"
depends_on:
timescaledb:
condition: service_healthy
```
TimescaleDB gibt Ihnen hypertable Partitionierung.Automatische Komprimierung...... ..(90-95%. Speicherreduzierung nach... Tagen.. .-),. kontinuierliche Aggregate für sub...
**Gut für** Mehrmals Server für , benötigen Analyse-Dashboard.
### Tier: Voller Stack - Gateway - Qdrant - LLM
```
Internet → Caddy (TLS) → Stylobot Gateway ([YARP](https://microsoft.github.io/reverse-proxy/)) → Your App
│
├── TimescaleDB (analytics, learning)
├── [Qdrant](https://qdrant.tech/documentation/) (vector similarity search)
└── LLamaSharp CPU [LLM](https://en.wikipedia.org/wiki/Large_language_model) (bot classification)
```
Das Gateway ist ein eigenständiger Docker-Container`scottgal/stylobot-gateway`Die Erkennung auf allen Traffic- und Forwards-Ergebnissen läuft als HTTP-Header. Ihre App liest Header. **kein SDK benötigt wird.**Wenn " ist nicht bekannt " ist, denken Sie an "[umgekehrter Proxy](https://en.wikipedia.org/wiki/Reverse_proxy) das vor Ihrer App sitzt und Sicherheit hinzufügt
```yaml
services:
gateway:
image: scottgal/stylobot-gateway:latest
environment:
DEFAULT_UPSTREAM: "http://app:8080"
StyloBotDashboard__PostgreSQL__ConnectionString: "Host=timescaledb;..."
StyloBotDashboard__PostgreSQL__EnableTimescaleDB: true
BotDetection__Qdrant__Enabled: true
BotDetection__Qdrant__Endpoint: http://qdrant:6334
BotDetection__Qdrant__EnableEmbeddings: true
BotDetection__AiDetection__Provider: LlamaSharp
BotDetection__AiDetection__LlamaSharp__ModelPath: "Qwen/Qwen2.5-0.5B-Instruct-GGUF/qwen2.5-0.5b-instruct-q4_k_m.gguf"
app:
build: .
environment:
BOTDETECTION_TRUST_UPSTREAM: true
qdrant:
image: qdrant/qdrant:latest
timescaledb:
image: timescale/timescaledb:latest-pg16
caddy:
image: caddy:latest
```
Ihre App vertraut auf die Gateway-Header von '
```csharp
// ASP.NET Core
builder.Services.Configure(o => o.TrustUpstreamDetection = true);
```
Oder lesen Sie Kopfzeilen direkt in jeder Sprache.
```python
# Python/Flask
@app.route('/api/data')
def api_data():
if request.headers.get('X-Bot-Detected') == 'true':
return jsonify(error='blocked'), 403
return jsonify(data='sensitive')
```
```javascript
// Node.js/Express
app.get('/api/data', (req, res) => {
if (req.headers['x-bot-detected'] === 'true') {
return res.status(403).json({ error: 'blocked' });
}
res.json({ data: 'sensitive' });
});
```
**Kopfzeilen des Gateways sendet - :**
Beispiel für die Verwendung von |
|--------|---------|---------|
| `X-Bot-Detected` | `true` ]|-Bot-/-Humanklassifizierung ®|-
| `X-Bot-Confidence` | `0.91` Das Vertrauen in die Detektion
| `X-Bot-Detection-Probability` | `0.87` Wahrscheinlichkeit des Bot-Tests
| `X-Bot-Type` | `Scraper` Kategorie der Bot-Kategorie
| `X-Bot-Name` | `AhrefsBot` ]| Identifizierter Bot
| `X-Bot-Detection-RiskBand` | `High` Risikoklassifizierung
### Was jede Komponente hinzufügt
|-Komponente, was es tut
|-----------|-------------|-----------|
| **ZeitskalaDB** - Series analytics , Empfohlen für die Produktion |
| **Qdrant** Vector similarity search -® findet Bots, auch wenn sie rotieren User MS K2®Agenten Optional
| **LLamaSharp** Nur LLM für Bot-Cluster-Nennung und Klassifikationssynthese
| **Caddy, /, Nginx** Beenden von TLS-Dateien Beseitigen von statischen Dateien Berühren Sie Ihren vorhandenen umgekehrten Proxy
| **Gateway** Zentralisierte Detektion für Multi- oder Nicht--.-NET-Backends für multi- und --Service-Architekturen
### Wählen Sie Ihr Tier
```
Starting out?
├── Single ASP.NET app → Tier 1 (two lines of code)
│ └── Need geo blocking? → Tier 2 (one more line)
│ └── Need analytics? → Tier 3 (add PostgreSQL)
└── Multiple apps or non-.NET? → Tier 4 (Gateway)
```
Bewegen zwischen den Ebenen ist eine DI-Registrierungsänderung... Ihr Endpunktschutzcode... `[BlockBots]` Attribute: `.BlockBots()` filtern, die `context.IsBot()` überprüft, bleibt genau das gleiche, .
---
## Enterprise Hooks
Das Zwei---Linien-Setup ist der Startpunkt... Hier.'.s, was sonst noch für den Produktionseinsatz eingebaut wird.
### Response Headers für Debugging
Schalten Sie Detektion Header global ein, so dass Sie das Verhalten überprüfen können, ohne auf diagnostische Endpunkte zu treffen.
```json
{
"BotDetection": {
"ResponseHeaders": {
"Enabled": true,
"HeaderPrefix": "X-Bot-",
"IncludeConfidence": true,
"IncludeDetectors": true,
"IncludeProcessingTime": true,
"SkipPaths": ["/health"]
}
}
}
```
Jede Antwort bekommt `X-Bot-Detected`, `X-Bot-Confidence`, `X-Bot-Processing-Ms`Nützlich für Rand-Routing-Entscheidungen in Caddy, /, Nginx, und zum Debuggen in dev,., Deaktivieren in der Produktion oder Beschränkung auf vertrauenswürdige Netzwerke
### Herausforderungs-Politiken vor Blockierung)
Don.'.t Block auf Ungewissheit......herausforderung statt......... StyloBot hat fünf gebaute -.in Herausforderungstypen...
```json
{
"BotDetection": {
"ActionPolicies": {
"challenge-on-uncertain": {
"Type": "Challenge",
"ChallengeType": "JavaScript"
},
"captcha-gate": {
"Type": "Challenge",
"ChallengeType": "Captcha",
"RedirectUrl": "/captcha"
},
"proof-of-work": {
"Type": "Challenge",
"ChallengeType": "ProofOfWork"
}
}
}
}
```
Herausforderungstypen `Redirect` Seite zur Herausforderung schicken `Inline` (,HTML interstitial, ),, `JavaScript` ,( ,JS-Beweis ,- ,von der Arbeit , ), , `Captcha`, `ProofOfWork` Zuweisen an Endpunkte über `[BotPolicy]`:
```csharp
[BotPolicy("default", ActionPolicy = "challenge-on-uncertain")]
public IActionResult Submit() => Ok();
```
### IP-Listen zulassen
Global erlauben und leugnen Listen für bekannte IPs und [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) Bereich:
```json
{
"BotDetection": {
"WhitelistedIps": ["203.0.113.10/32", "198.51.100.0/24"],
"BlacklistedIps": ["1.2.3.4", "5.6.7.0/24"]
}
}
```
Whitelisted IPs überspringen Detektion vollständig... Blacklisted IPs erhalten sofort blockiert... beide unterstützen CIDR-Notation...
### OpenTelemetrie Metrics
StyloBot setzt Metriken über `System.Diagnostics.Metrics`kompatibel mit [OpenTelemetrie](https://opentelemetry.io/docs/), [Prometheus](https://prometheus.io/docs/introduction/overview/), [Grafana](https://grafana.com/docs/).,- und beliebige ..-NET-Metriken
```csharp
builder.Services.AddOpenTelemetry()
.WithMetrics(metrics => metrics.AddMeter("Mostlylucid.BotDetection"));
```
**Verfügbare Metriken**
Metrisches Messgerät Typ |, was es misst
|--------|------|-----------------|
| `botdetection.requests.total` Gesamtanfragen verarbeitet
| `botdetection.bots.detected` Anfragen, die als Bots eingestuft werden
| `botdetection.humans.detected` Anfragen, die als human eingestuft werden
| `botdetection.errors.total` Fehler bei der Erkennung von Pipeline-Fehlern
| `botdetection.detection.duration` Histogramm-Latenz der Erkennungslatenz
| `botdetection.confidence.average` Durchschnittliche Konfidenzintervalle
| `botdetection.cache.patterns.count` Anzahl der eingezäunten Muster
Dies sind die Zahlen, die Sie für Dashboards benötigen Benachrichtigungen, und Kapazitätsplanung. . Detection Latenz-Histogramm können Sie SLOs .. . Bot . / menschliche Zähler geben Ihnen Verkehrszusammensetzung im Laufe der Zeit .
### Voreinstellungen für Routengruppen
Bot-Schutz auf ganze Routengruppen anwenden, anstatt per---Endpunkt zu wiederholen.:
```csharp
// All /api routes: block bots, allow search engines
var api = app.MapGroup("/api").WithBotProtection(allowSearchEngines: true);
api.MapGet("/products", () => "data");
api.MapGet("/categories", () => "cats");
// Secured routes: humans only
var secure = app.MapGroup("/secure").WithHumanOnly();
secure.MapPost("/submit", () => "ok");
secure.MapPost("/checkout", () => "done");
// Individual endpoints can still override
api.MapGet("/special", () => "overridden")
.BlockBots(allowSearchEngines: true, allowSocialMediaBots: true);
```
`WithBotProtection()` nimmt die gleichen Parameter wie `.BlockBots()`Beeindruckend, aber absichtlich immer Blöcke Schaber und bösartige Bots auf Gruppenebene `allowScrapers` / `allowMaliciousBots` auf Gruppen `WithHumanOnly()` ist die Gruppe entspricht der `.RequireHuman()`.
### Benannte Richtlinien auf Minimal API
Verwendung `.BotPolicy()` um benannte Aktionsrichtlinien Minimalen API-Endpunkten zuzuordnen `[BotPolicy]` tut für MVC-:
```csharp
// Throttle bots on this endpoint
app.MapGet("/api/data", () => "sensitive")
.BotPolicy("default", actionPolicy: "api-throttle");
// Block with high-confidence threshold
app.MapPost("/api/submit", () => "ok")
.BotPolicy("strict", actionPolicy: "block", blockThreshold: 0.8);
```
### Rückkopplungs-API
Meldung falscher Positive und Negative an das System über `POST /bot-detection/feedback`:
```bash
# Mark a detection as a false positive (bot detected but was actually human)
curl -X POST http://localhost:5090/bot-detection/feedback \
-H "Content-Type: application/json" \
-d '{"outcome": "Human", "notes": "Known partner integration"}'
# Mark a missed bot (human detected but was actually a bot)
curl -X POST http://localhost:5090/bot-detection/feedback \
-H "Content-Type: application/json" \
-d '{"outcome": "Bot", "notes": "Automated scraper spotted in logs"}'
```
Der Endpunkt gibt zurück, ob das Feedback ein falsch-positives oder falsch-negatives Verhältnis zum aktuellen Erkennungsergebnis darstellt.
### Gateway Trust Boundary mit HMAC Signing
Wenn Sie das YARP-Gateway verwenden, vertraut Ihr Backend den vorgelagerten Erkennungsköpfen. Dies ist eine sicherheitsempfindliche Einstellung von -... Sie müssen sicherstellen, dass nur das Gateway diese Header einstellen kann.
**Basis-Vertrauen - Netzwerk - Isolation nur auf der Ebene von ):**
```json
{
"BotDetection": {
"TrustUpstreamDetection": true
}
}
```
**HMAC.-.signiertes Vertrauen**
```json
{
"BotDetection": {
"TrustUpstreamDetection": true,
"UpstreamSignatureHeader": "X-Bot-Signature",
"UpstreamSignatureSecret": "base64-encoded-shared-secret"
}
}
```
Wann `UpstreamSignatureHeader` und `UpstreamSignatureSecret` sind gesetzt ,, , die Middleware überprüft ein [HMAC---SHAM256-](https://datatracker.ietf.org/doc/html/rfc2104) Signatur vor dem Vertrauen in die vorgelagerten Header
Verwenden Sie dies derzeit für **Benutzerdefinierte Gateway-Integrationen** Das eingebaute -in Stylobot-Gateway führt Bot---Detektions-Header vor, sendet HMAC-Signatur Header aber noch nicht aus..
Erforderliche signierte Kopfzeilen
- `X-Bot-Signature` ](-Basis ®64-HMAC-)-
- `X-Bot-Detection-Timestamp` (-Unix-Epoche Sekunden ,- UTC-)-
Unterzeichneter Vertrag
- `payload = X-Bot-Detected + ":" + X-Bot-Confidence + ":" + X-Bot-Detection-Timestamp`
- `signature = Base64(HMACSHA256(payload, base64Decoded(UpstreamSignatureSecret)))`
Signaturen außerhalb eines Replay-Fensters werden abgelehnt, wenn die Signatur fehlt oder abgelaufen ist, werden vorgelagerte Header von , zurückgewiesen und stattdessen wird eine vollständige lokale Erkennung ausgeführt.
**Wichtig** Nur dann Vertrauen aktivieren, wenn Ihr Backend hinter einem vertrauenswürdigen Reverse Proxy liegt. `X-Bot-Detected: false` und umgehen alle Detektionen... in der Produktion...
- Sicherstellen, dass das Backend nicht öffentlich zugänglich ist
- Streifen `X-Bot-*` Header an Ihrem Edge Proxy, bevor sie das Gateway erreichen
- Verwenden Sie HMAC-Signatur für die Verteidigung, auch mit Netzwerkisolation
---
## Was StyloBot nicht ist
Es lohnt sich, explizit zu sein.
- **Kein WAF-.** StyloBot doesn''-Inspektion von Nutzlasten für SQL-Injektion oder XSSD.-Inspection *Wer* macht die Anfrage nicht *Was ist* sie ,' , die senden .. , Verwenden Sie es neben einem WAF , , , nicht anstelle von one ?. .
- **Kein CAPTCHA-Bauernhof** Herausforderungen gibt es nicht, aber die Design-Philosophie ist Detektion. *Vorher* zu entscheiden, ob man anfechtet
- **Nicht nur im Umkreis von .** Detektion läuft per---Endpunkt mit per---Endpoint-Richtlinien `/products` Suchmaschinen erlauben, während `/api/checkout` erfordert Menschen , . , Dies ist Endpunkt Semantik , nicht Firewall-Regeln ,. ,
- **Nicht wolkenabhängig** Alles läuft selbst, --integriert, .-Qdrant,,-TimescaleDB, ,-LLM, alle optional, MSSK5-Der Kern ist zwei Zeilen Code und eine SQLite-Datei..-
- **Ungewissheit** Zwei unabhängige Werte Wahrscheinlichkeit +...Vertrauen )" bedeuten, dass Sie eine Bot-"" unterscheiden können, wahrscheinlich ein Bot-," wir ' sind sicher "" von " wahrscheinlich ein bot-," aber wir ' erraten "." Die meisten Systeme geben Ihnen eine Nummer und Hoffnung für das beste ."
---
## Was kommt als nächstes?
Teil behandelt, warum die Bot-Detektion zählt. Teil deckte die Erkennungspipeline Internals ab. Dieser Beitrag umfasste die minimale praktikable Integration und den Skalierungspfad von zwei Codezeilen zu einem vollständigen Produktionsgateway.
**Beginnen Sie mit :**
- NuGet-:- `dotnet add package Mostlylucid.BotDetection`
- Gateway Docker-: `docker pull scottgal/stylobot-gateway`
- [Vollständige Dokumente](https://github.com/scottgal/LLMApi/tree/main/Mostlylucid.BotDetection/docs)
- [Live-Demo, MSK, StyloBot, .,net](https://stylobot.net)