Ein umfassendes SLA (Service Level Agreement) Monitoring und Dashboard System, entwickelt mit Django und Django REST Framework. Das Projekt befindet sich in der experimentellen Phase und dient der Erforschung und Entwicklung von SLA-Monitoring-Lösungen.
Dieses Projekt wurde KI-gestützt mit orchestrierten Agenten entwickelt, um die Effizienz und Qualität der Softwareentwicklung zu demonstrieren. Es handelt sich dabei nicht um Vibe Programming, sondern um eine strukturierte, methodische Herangehensweise mit spezialisierten KI-Agenten.
Das Projekt wurde mit einem Orchestrator und folgenden spezialisierten Agenten umgesetzt:
- 🔍 Researcher: 1 Agent - Analyse von Anforderungen und Best Practices
- 💻 Coder: 1 Agent - Implementierung der Django-Anwendung und APIs
- 📊 Analyst: 1 Agent - Datenmodellierung und Business Logic
- 🧪 Tester: 1 Agent - Qualitätssicherung und Testdaten-Generierung
- Analyse-Phase: Der Researcher analysierte SLA-Monitoring-Anforderungen
- Design-Phase: Der Analyst erstellte Datenmodelle und API-Strukturen
- Implementierung: Der Coder entwickelte die Django-Anwendung
- Testing & Optimierung: Der Tester generierte Testdaten und validierte Funktionalität
- Orchestrierung: Der Orchestrator koordinierte alle Agenten und führte finale Anpassungen durch
- Strukturierte Methodik: Jeder Agent hat spezifische Rollen und Verantwortlichkeiten
- Qualitätskontrolle: Mehrere Agenten überprüfen und validieren Code
- Skalierbarkeit: Orchestrierte Agenten können komplexe Projekte handhaben
- Nachhaltigkeit: Code ist wartbar und dokumentiert
- Effizienz: Reduziert Entwicklungszeit bei hoher Qualität
Das SLA Dashboard zeigt eine moderne, professionelle Oberfläche mit Key Metrics, Verfügbarkeits-Timeline, Antwortzeit-Verteilung und SLA-Compliance-Charts.
- Service Management: Verfolgung mehrerer Services mit konfigurierbaren SLA-Zielen
- Metrik-Sammlung: Speicherung und Analyse von Verfügbarkeit, Antwortzeit, Durchsatz und Fehlerrate
- Incident Tracking: Überwachung und Verwaltung von SLA-Verstößen und Service-Incidents
- Datenimport: CSV-Upload-Funktionalität mit Feldzuordnung und Validierung
- Alert-System: Konfigurierbare Alert-Regeln mit Benachrichtigungskanälen
- Dashboard: Anpassbare Dashboards mit Widgets und Benutzereinstellungen
- Reports: Automatisierte SLA-Report-Generierung
- Django 5.2.4 mit moderner Architektur
- REST API mit Django REST Framework
- Multi-Database-Routing-Support (PostgreSQL/MySQL)
- CSV-Verarbeitung mit pandas
- Umfassende Admin-Oberfläche
- UUID-Primärschlüssel für Sicherheit
- Filterung, Suche und Paginierung
- Benutzerauthentifizierung und Berechtigungen
django-sla/
├── sla_dashboard/ # Haupt-Django-Projekt
├── sla_metrics/ # Core SLA Metriken Modelle und API
├── data_sources/ # Datenimport und CSV-Verarbeitung
├── alerts/ # Alert-Regeln und Benachrichtigungen
├── dashboard/ # Dashboard-Widgets und Benutzereinstellungen
├── media/ # Hochgeladene Dateien (CSV, etc.)
├── static/ # Statische Dateien
└── logs/ # Anwendungslogs
- Nicht für Produktion geeignet: Dies ist ein experimentelles Projekt
- Entwicklungsphase: Das Projekt befindet sich in aktiver Entwicklung
- Tests erforderlich: Weitere Tests und Validierungen sind geplant
- Performance-Optimierungen: Weitere Optimierungen sind in Planung
- Grundlegende Funktionalität implementiert
- Weitere Tests erforderlich
- Performance-Optimierungen geplant
- Frontend-Integration in Entwicklung
- Python 3.8+
- pip oder uv (empfohlen)
git clone https://github.com/bks-lab/experimental-django-sla-dashboard.git
cd experimental-django-sla-dashboard# Mit uv (empfohlen)
uv venv
source .venv/bin/activate
# Oder mit venv
python3 -m venv venv
source venv/bin/activate# Mit uv
uv pip install -r requirements.txt
# Oder mit pip
pip install -r requirements.txt# Für SQLite (Entwicklung)
python manage.py migrate
# Für PostgreSQL (Produktion)
# settings.py Datenbank-Konfiguration aktualisieren
# Datenbank erstellen und Migrationen ausführen
python manage.py migrate# Testdaten mit Admin-Benutzer erstellen
python -c "
import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sla_dashboard.settings')
django.setup()
from django.contrib.auth.models import User
from django.utils import timezone
from sla_metrics.models import ServiceType, Service, SLAMetric, SLAIncident
from datetime import timedelta
import random
from decimal import Decimal
# Create admin user
if not User.objects.filter(username='admin').exists():
User.objects.create_superuser('admin', 'admin@example.com', 'admin123')
print('👤 Created admin user (admin/admin123)')
# Create service types
types_data = [
{'name': 'Web API', 'description': 'REST API services'},
{'name': 'Database', 'description': 'Database services'},
{'name': 'Web Application', 'description': 'Web applications'},
]
service_types = []
for data in types_data:
service_type, created = ServiceType.objects.get_or_create(
name=data['name'],
defaults={'description': data['description']}
)
service_types.append(service_type)
if created:
print(f'📋 Created service type: {service_type.name}')
# Create services
service_names = [
'User Authentication API', 'Payment Gateway', 'Email Service',
'File Storage Service', 'Search Engine', 'Analytics API',
'Notification Service', 'Order Management', 'Inventory System',
'Customer Portal'
]
services = []
admin_user = User.objects.get(username='admin')
for name in service_names:
service_type = random.choice(service_types)
availability_target = Decimal(random.uniform(99.5, 99.9))
response_time_target = random.randint(100, 500)
service = Service.objects.create(
name=name,
service_type=service_type,
description=f'Test service for {service_type.name}',
owner=admin_user,
availability_target=availability_target,
response_time_target=response_time_target,
is_active=True
)
services.append(service)
print(f'🔧 Created service: {service.name}')
# Create metrics
now = timezone.now()
for service in services:
print(f'📊 Generating metrics for {service.name}...')
for day in range(7):
date = now - timedelta(days=day)
for hour in range(24):
timestamp = date.replace(hour=hour, minute=0, second=0, microsecond=0)
# Availability metric
base_availability = float(service.availability_target)
availability = max(95.0, min(100.0, base_availability + random.uniform(-0.5, 0.3)))
SLAMetric.objects.create(
service=service,
metric_type='availability',
timestamp=timestamp,
value=Decimal(str(round(availability, 2))),
unit='%',
source='test_data'
)
# Response time metric
base_response_time = service.response_time_target
response_time = max(50, min(1000, base_response_time + random.uniform(-50, 150)))
SLAMetric.objects.create(
service=service,
metric_type='response_time',
timestamp=timestamp,
value=Decimal(str(round(response_time, 1))),
unit='ms',
source='test_data'
)
# Create incidents
for service in services[:5]:
started_at = timezone.now() - timedelta(days=random.randint(1, 5))
incident = SLAIncident.objects.create(
service=service,
title=f'Test incident for {service.name}',
description=f'This is a test incident for {service.name}',
severity=random.choice(['low', 'medium', 'high']),
status='resolved',
started_at=started_at,
resolved_at=started_at + timedelta(hours=random.randint(1, 4)),
affected_users=random.randint(100, 1000),
revenue_impact=Decimal(str(random.uniform(100, 1000)))
)
print(f'🚨 Created incident: {incident.title}')
print('\\n✅ Test data generated successfully!')
print('\\n🔑 Admin credentials:')
print(' Username: admin')
print(' Password: admin123')
print('\\n🌐 Access your dashboard:')
print(' Admin: http://localhost:8000/admin/')
print(' Dashboard: http://localhost:8000/dashboard/')
print(' API: http://localhost:8000/api/v1/sla/')
"python manage.py runserver-
📊 Dashboard: http://localhost:8000/dashboard/
- Moderne Visualisierung mit Charts und Metriken
- Real-time Updates
- Service-Status-Übersicht
- Funktioniert ohne Login!
-
🔧 Admin-Interface: http://localhost:8000/admin/
- Login:
admin/admin123 - Vollständige Verwaltung aller Daten
- Service-Management, Incidents, Reports
- Login:
-
📡 API-Endpunkte: http://localhost:8000/api/v1/sla/
- REST API für alle SLA-Daten
- JSON-Format für Frontend-Integration
-
Key Metrics:
- Gesamtverfügbarkeit: ~99.5%
- Aktive Incidents: 5
- Durchschnittliche Antwortzeit: ~200ms
- Services überwacht: 10
-
Charts:
- Verfügbarkeits-Timeline (24h)
- Antwortzeit-Verteilung
- SLA-Compliance Donut-Chart
-
Service-Status-Tabelle:
- Alle Services mit aktuellen Metriken
- Status-Indikatoren (grün/gelb/rot)
- Verfügbarkeit und Antwortzeiten
-
Alerts & Incidents:
- Aktuelle Benachrichtigungen
- Incident-Historie
GET/POST /service-types/- Service-Typen auflisten/erstellenGET/PUT/DELETE /service-types/{id}/- Service-Typ DetailsGET/POST /services/- Services auflisten/erstellenGET/PUT/DELETE /services/{id}/- Service DetailsGET/POST /metrics/- Metriken auflisten/erstellenGET/PUT/DELETE /metrics/{id}/- Metrik DetailsGET/POST /incidents/- Incidents auflisten/erstellenGET/PUT/DELETE /incidents/{id}/- Incident DetailsGET/POST /reports/- Reports auflisten/erstellenGET/PUT/DELETE /reports/{id}/- Report Details
POST /csv/upload/- CSV-Datei hochladenGET /csv/status/{id}/- Upload-StatusPOST /csv/process/{id}/- Hochgeladene CSV verarbeitenGET /csv/history/- Upload-Historie
service_nameoderservice- Name des Services- Metrik-Felder (mindestens eines):
availability- Verfügbarkeit in Prozentresponse_time- Antwortzeit in Millisekundenthroughput- Requests pro Sekundeerror_rate- Fehlerrate in Prozent
timestamp- Wann die Metrik aufgezeichnet wurdeuptime_seconds- Gesamte Uptime in Sekundendowntime_seconds- Gesamte Downtime in Sekundentotal_requests- Gesamtzahl der Requestsfailed_requests- Anzahl fehlgeschlagener Requestsunit- Einheit der Messungnotes- Zusätzliche Notizen
service_name,timestamp,availability,response_time,uptime_seconds,total_requests,failed_requests
Web API,2024-01-01 12:00:00,99.9,150,3590,1000,1
Database,2024-01-01 12:00:00,99.8,50,3588,500,1- Datenquelle in Admin-Interface erstellen
- Feldzuordnungen für CSV-Spalten konfigurieren
- CSV-Datei über API oder Admin hochladen
- Hochgeladene Daten verarbeiten
- Alle Modelle verwenden UUID-Primärschlüssel für Sicherheit
- Modelle enthalten created/updated Timestamps
- Beziehungen verwenden proper related_name Attribute
- Indizes sind für Performance konfiguriert
- Verwendet Django REST Framework mit ViewSets
- Enthält Filterung, Suche und Sortierung
- Umfassende Serializer für alle Modelle
- Proper Error Handling und Validierung
- PostgreSQL-Datenbank einrichten
- Umgebungsvariablen konfigurieren
- Redis für Caching einrichten
- Celery für Background-Tasks konfigurieren
- Monitoring und Logging einrichten
- Email/Slack-Benachrichtigungen konfigurieren
- Automatisierte Backups einrichten
- React/Vue.js Frontend erstellen
- Dashboard-Visualisierungen implementieren
- Real-time Updates mit WebSockets hinzufügen
- Mobile-responsive Interface erstellen
- Real-time Metrik-Sammlung
- Erweiterte Alerting mit ML
- Multi-Tenant Support
- API Rate Limiting
- Erweiterte Reporting mit Charts
- Integration mit Monitoring-Tools
- UUID-Primärschlüssel für Sicherheit und Verteilung
- Ordnungsgemäße Fremdschlüssel-Beziehungen mit Cascade-Optionen
- Indizes auf häufig abgefragten Feldern
- Datenbank-Routing für Multi-Source-Support
- RESTful-Endpunkte nach Django-Konventionen
- Umfassende Filterung und Suchfunktionen
- Ordnungsgemäße HTTP-Statuscodes und Fehlerbehandlung
- Paginierung für große Datensätze
- Umgebungsbasierte Konfiguration
- Passwort-Felder als write-only markiert
- Ordnungsgemäße Benutzerauthentifizierung integriert
- CORS-Konfiguration für Frontend-Zugriff
- Datenbankabfrage-Optimierung mit select_related
- Ordnungsgemäße Indizierung auf Modellen
- Paginierung zur Handhabung großer Datensätze
- Datei-Upload-Größenlimits und Validierung
Dieses Projekt ist für Bildungs- und Entwicklungszwecke erstellt.
BKS Lab GmbH
- Email: info@bks-lab.com
- Website: https://bks-lab.com
