open-how2 – Entdecke. Verstehe. Nutze.
Veröffentlicht am
• How2-Tipps

Anubis im Alltag: So schützt du deine API oder Website mit nur wenigen Zeilen Code

Autor
Anubis im Alltag: So schützt du deine API oder Website mit nur wenigen Zeilen Code

Webanwendungen sind heute mehr Angriffen ausgesetzt als je zuvor – von aggressivem Scraping über API-Abuse bis hin zu automatisierten Credential-Stuffing-Versuchen. Klassische Firewalls oder WAFs stoßen dabei oft an ihre Grenzen: sie arbeiten mit starren Regeln, erkennen neue Angriffsmuster zu spät und produzieren unnötig viele False Positives.

Hier setzt Anubis an – eine KI-gestützte Web-AI-Firewall, die lernfähig, leicht zu integrieren und auf maximale Effizienz im laufenden Betrieb ausgelegt ist. In diesem Artikel zeigen wir dir, wie du Anubis in wenigen Minuten in deine bestehende Infrastruktur (Nginx, Cloudflare, Apache) einbindest – inklusive Konfigurationsbeispielen, Rate-Limiting, Whitelists und Monitoring mit Grafana & Prometheus.

Was Anubis anders macht

Anubis ist keine statische WAF, sondern ein intelligenter Reverse Proxy mit Machine Learning-Unterbau. Statt sich auf einfache IP- oder Header-Blocklisten zu verlassen, erkennt Anubis ungewöhnliche Muster im Traffic – etwa Request-Frequenzen, Browser-Fingerprints oder unnatürliche Timings.

Typische Einsatzszenarien

  • Schutz von REST- oder GraphQL-APIs vor Massenzugriffen
  • Absicherung von Admin-Portalen gegen Bots und Credential-Stuffing
  • Verhinderung von Preis-Scraping oder Datenkopien
  • Traffic-Firewall für SaaS- und E-Commerce-Plattformen

1. Installation und Grundkonfiguration

Anubis kann direkt auf deinem Server laufen – oder als Container im Netzwerk agieren.

Variante A – Docker-Setup (empfohlen)

docker run -d \
  -p 8080:8080 \
  -v /opt/anubis/config.yaml:/app/config.yaml \
  ghcr.io/anubis-ai/anubis:latest

Variante B – Native Installation

wget https://github.com/anubis-ai/anubis/releases/latest/download/anubis-linux-amd64.tar.gz
tar -xzf anubis-linux-amd64.tar.gz
sudo mv anubis /usr/local/bin/
sudo anubis serve --config /etc/anubis/config.yaml

2. Beispielhafte config.yaml

Die zentrale Konfiguration steuert Verhalten, Sicherheit und Integrationen. Hier ein Beispiel für eine produktionsreife Konfiguration:

server:
  listen: ":8080"
  mode: "reverse-proxy"
  upstream: "http://localhost:8000"
  log_level: "info"

security:
  ai_mode: "adaptive"          # AI Detection: off, monitor, adaptive
  rate_limit: "100/minute"     # Globales Request-Limit pro IP
  allow_regions: ["EU", "US"]  # Geo-Fencing
  deny_countries: ["CN", "RU"] # Optional blockierte Regionen
  enable_fingerprint: true     # Aktiviert Device Fingerprinting
  challenge_mode: "javascript" # Optional: CAPTCHA, JS-Delay etc.

rules:
  whitelist:
    - 127.0.0.1
    - 192.168.0.0/16
  blacklist:
    - 45.23.0.0/16
  skip_paths:
    - /health
    - /metrics

logging:
  format: json
  output: /var/log/anubis/access.log

monitoring:
  prometheus_enabled: true
  metrics_port: 9001

Tipp:

Starte Anubis zunächst im "monitor"-Modus:

ai_mode: "monitor"

So lernst du den Traffic kennen, bevor du Blockierungen aktivierst.

3. Integration mit Nginx

Anubis kann direkt vor Nginx oder als Upstream hinter Nginx betrieben werden. Die erste Variante ist einfacher für den Einstieg.

Variante A – Anubis als Reverse Proxy vor Nginx

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Anubis prüft den gesamten eingehenden Traffic, bevor Nginx ihn weiterverarbeitet. Im Log siehst du anschließend Scoring-Informationen zu jedem Request.

4. Integration mit Cloudflare

Wenn du bereits Cloudflare nutzt, kann Anubis trotzdem hinter Cloudflare arbeiten. Dabei greift Anubis die echten IP-Adressen aus dem CF-Connecting-IP Header ab:

security:
  real_ip_header: "CF-Connecting-IP"

Empfohlene Kombination:

  • Cloudflare → DDoS-/Layer 7 Basisschutz
  • Anubis → KI-Analyse & Verhaltensprüfung

Damit erhältst du den besten Mix aus Geschwindigkeit, Datenschutz und Intelligenz.

5. Apache-Integration

Für Apache kannst du Anubis mit dem ProxyPass-Modul kombinieren:

<VirtualHost *:80>
    ServerName secure.example.com

    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8080/
    ProxyPassReverse / http://127.0.0.1:8080/

    ErrorLog ${APACHE_LOG_DIR}/anubis_error.log
    CustomLog ${APACHE_LOG_DIR}/anubis_access.log combined
</VirtualHost>

Anubis sitzt dann zwischen Apache und Internet und überwacht alle Requests – inklusive API-Endpunkte und statische Ressourcen.

6. Rate-Limiting und Whitelists

Beispiel: Strenges Limit für API-Endpunkte

rules:
  rate_limit_paths:
    - path: /api/
      limit: "50/minute"
    - path: /login
      limit: "10/minute"

Beispiel: Whitelist für interne Systeme

rules:
  whitelist:
    - 10.0.0.0/8
    - 172.16.0.0/12

Pro-Tipp: Nutze Whitelists für eigene Monitoring-Tools oder interne Gateways, um False Positives zu vermeiden.

7. Monitoring mit Prometheus & Grafana

Anubis exportiert Metriken über Prometheus-kompatible Endpunkte.

Prometheus Scrape-Config:

scrape_configs:
  - job_name: 'anubis'
    static_configs:
      - targets: ['localhost:9001']

Wichtige Metriken:

Metrik Beschreibung
anubis_requests_total Gesamtzahl der Requests
anubis_blocked_total Geblockte Anfragen
anubis_score_avg Durchschnittlicher Vertrauen-Score
anubis_latency_ms Durchschnittliche Antwortzeit
anubis_rate_limit_hits Anzahl der Limit-Trigger

In Grafana kannst du diese Daten visuell darstellen – z. B. als Security-Dashboard mit Heatmaps, Score-Verteilung und Block-Rate über Zeit.

8. Integration in CI/CD-Pipelines

Mit Anubis kannst du Sicherheit direkt in deinen Deployment-Prozess einbauen. Das ist besonders nützlich, wenn du DevSecOps-Praktiken umsetzt.

Beispiel (GitLab CI):

stages:
  - deploy

deploy:
  stage: deploy
  script:
    - docker compose pull
    - docker compose up -d
    - curl -f http://localhost:8080/health || exit 1
  only:
    - main

So stellst du sicher, dass die Anubis-Firewall bei jedem Release automatisch aktualisiert und getestet wird.

9. Kombination mit Security-Tools

Fail2Ban

Anubis kann über Syslog verdächtige IPs an Fail2Ban weiterleiten:

logging:
  syslog_enabled: true
  syslog_target: "127.0.0.1:514"

SIEM-Integration

Anbindung an Systeme wie Graylog, Wazuh oder ELK ist problemlos möglich:

logging:
  output: /var/log/anubis/events.json

So kannst du Security-Events in dein globales Monitoring aufnehmen.

10. Best Practices für den Betrieb

Empfohlene Startkonfiguration:

  • ai_mode: monitor → Lernen ohne Eingriff
  • rate_limit: 100/min → Grundschutz gegen Traffic-Spikes
  • prometheus_enabled: true → Performance überwachen

Update-Strategie:

sudo docker compose pull
sudo docker compose up -d

Backup:

tar czf /root/anubis_backup_$(date +%F).tar.gz /opt/anubis/config.yaml /var/lib/anubis/

Sicherheit, die mitdenkt

Anubis zeigt, dass moderne Websicherheit nicht kompliziert sein muss. Mit einer klaren YAML-Konfiguration, KI-basierter Erkennung und Integrationen in gängige Tools wie Nginx, Cloudflare, Prometheus und Grafana bietet die Plattform einen Schutzschild, der mit deiner Infrastruktur wächst.

Für Systemadministratoren und Entwickler bedeutet das:

  • weniger Aufwand,
  • mehr Transparenz,
  • und eine Abwehr, die mit jedem Angriff intelligenter wird.

Ähnliche Beiträge