Seminar Apache Grails Multi-Tenancy und Mandantenfähigkeit

Mandantenfähigkeit ist in erster Linie eine Isolations- und Sicherheitsentscheidung. Eine technische Filterbedingung genügt nicht, wenn Hintergrundjobs, administrative Funktionen oder Integrationen den Mandantenkontext verlieren können.

Das Seminar vergleicht die gebräuchlichen Isolationsmodelle und setzt einen ausgewählten Ansatz mit GORM um. Negative Tests prüfen ausdrücklich, dass Daten anderer Mandanten weder gelesen noch verändert werden können.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Mandantenmodell und Isolationsstrategie
5. Modul 2: Multi-Tenancy mit GORM umsetzen
6. Modul 3: Autorisierung auf URL-, Controller- und Methodenebene
7. Modul 4: Geschäftstransaktionen und Konsistenzmuster
8. Modul 5: Sicherheit, Tests und Betrieb mandantenfähiger Systeme
9. Modul 6: Integrationstests mit echter Anwendungskonfiguration
10. Praxisprojekt und Übungen
11. Arbeitsweise

Zielgruppe

Grails-Entwickler, Softwarearchitekten und technische Leiter von SaaS- oder mandantenfähigen Geschäftsanwendungen.

Voraussetzungen

Grails- und GORM-Grundkenntnisse, Erfahrung mit Authentifizierung und relationalen Datenbanken.

Lernziele

• Ein Mandanten- und Isolationsmodell aus Anforderungen ableiten.
• Mandantenkontext zuverlässig für Web, Services und Jobs auflösen.
• GORM-Multi-Tenancy korrekt konfigurieren und anwenden.
• Autorisierung zusätzlich zur Datenfilterung durchsetzen.
• Isolation, Onboarding, Sicherung und Wiederherstellung testen und planen.

Modul 1: Mandantenmodell und Isolationsstrategie

Mandantenfähigkeit wird aus Sicherheits-, Betriebs- und Datenanforderungen abgeleitet.

1. Schritt 1: Mandantenidentität und Lebenszyklus definieren.
2. Schritt 2: Datenbank-, Schema- oder Diskriminatoransatz vergleichen.
3. Schritt 3: Mandantenkontext für Web, Jobs und Integrationen festlegen.
4. Schritt 4: Isolations-, Skalierungs- und Migrationsfolgen dokumentieren.

Modul 2: Multi-Tenancy mit GORM umsetzen

Der gewählte Ansatz wird in Domain-Klassen, Services und Datenzugriff konsistent verankert.

1. Schritt 1: GORM-Multi-Tenancy konfigurieren und Tenant Resolver bereitstellen.
2. Schritt 2: Mandantengebundene Abfragen und Services implementieren.
3. Schritt 3: Systemweite administrative Operationen ausdrücklich trennen.
4. Schritt 4: Fehlenden oder ungültigen Mandantenkontext sicher behandeln.

Modul 3: Autorisierung auf URL-, Controller- und Methodenebene

Berechtigungen werden nah an der geschützten Operation und mit nachvollziehbaren Regeln umgesetzt.

1. Schritt 1: Rollen, Berechtigungen und Hierarchien fachlich definieren.
2. Schritt 2: URL-Regeln und Annotationen konsistent kombinieren.
3. Schritt 3: Objektbezogene Berechtigungen in Services prüfen.
4. Schritt 4: Unzulässige Zugriffe mit negativen Tests absichern.

Modul 4: Geschäftstransaktionen und Konsistenzmuster

Komplexe Abläufe werden in robuste, nachvollziehbare Transaktionen und Kompensationsschritte zerlegt.

1. Schritt 1: Atomare und verteilte fachliche Operationen unterscheiden.
2. Schritt 2: Idempotenz und Wiederholbarkeit für kritische Methoden herstellen.
3. Schritt 3: Nebenwirkungen über Ereignisse oder Outbox-ähnliche Muster entkoppeln.
4. Schritt 4: Fehlerfälle und Teilabbrüche mit gezielten Tests durchspielen.

Modul 5: Sicherheit, Tests und Betrieb mandantenfähiger Systeme

Datenlecks zwischen Mandanten werden mit technischen und organisatorischen Kontrollen verhindert.

1. Schritt 1: Authentifizierte Identität und Mandantenkontext konsistent verknüpfen.
2. Schritt 2: Autorisierung zusätzlich zur Datenfilterung prüfen.
3. Schritt 3: Negative Isolationstests für Lesen, Schreiben und Suche erstellen.
4. Schritt 4: Onboarding, Offboarding, Sicherung und Wiederherstellung pro Mandant planen.

Modul 6: Integrationstests mit echter Anwendungskonfiguration

Zusammenspiel von Persistenz, Transaktionen, Spring-Kontext und Webschicht wird realitätsnah überprüft.

1. Schritt 1: Integrationsprofil und Testdaten reproduzierbar konfigurieren.
2. Schritt 2: Services und GORM gegen eine echte Testdatenbank prüfen.
3. Schritt 3: Transaktionsverhalten und Rollback bewusst kontrollieren.
4. Schritt 4: Langsame Tests strukturieren und von schnellen Tests trennen.

Praxisprojekt und Übungen

Eine bestehende Anwendung wird um Mandantenkontext, tenantgebundene Datenzugriffe und administrative Ausnahmen erweitert. Eine Testsuite versucht gezielt, Grenzen zwischen zwei Mandanten zu verletzen.

Arbeitsweise

Kurze fachliche Einführungen wechseln mit Demonstrationen, angeleiteten Implementierungsschritten, selbstständigen Übungen und gemeinsamer Auswertung. Entscheidungen werden im Code, in Tests und in einer knappen technischen Dokumentation nachvollziehbar festgehalten.