Seminar Flask Intensivseminar – Architektur, Erweiterungen und Modernisierung

Das Intensivseminar fasst die strukturellen Spezialthemen für langlebige Flask-Anwendungen zusammen. Neue Projekte erhalten eine klare Factory- und Blueprint-Architektur; gewachsene Systeme werden schrittweise in dieselbe Richtung modernisiert.

Zusätzlich werden Erweiterungen bewertet, selbst entwickelt und als Pakete ausgeliefert. CLI, Konfiguration, Logging, Testbarkeit und CI bilden dabei keine Nebenthemen, sondern die technische Klammer des gesamten Aufbaus.

Inhaltsübersicht

1. Application Factory und mehrfache Instanzen
2. Blueprints und modulare Funktionsbereiche
3. Paketstruktur und interne Abhängigkeiten
4. Konfiguration und Erweiterungsinitialisierung
5. Service-, Repository- und Domänenschichten
6. Eigene Flask-CLI-Befehle
7. Konfigurationsstrategie für Entwicklung, Test und Produktion
8. Strukturiertes Logging und Korrelationskennungen
9. Erweiterungen auswählen und bewerten
10. Eigene Erweiterung mit init_app entwickeln
11. Paketierung, Dokumentation und Veröffentlichung
12. Kompatibilität, Tests und Wartung von Erweiterungen
13. pytest-Struktur und Fixtures
14. Unit-Tests für Services und Domänenlogik
15. Integrations- und Migrationstests
16. Continuous Integration und Qualitätsgates
17. Bestandsaufnahme und technische Baseline
18. Abhängigkeiten und Deprecations aktualisieren
19. Refactoring zu Factory, Blueprints und Services
20. Schema-Migrationen und Datenänderungen
21. Migrationsplan, Datenänderungen und Rollout
22. Praxisprojekt und Wissenssicherung

Lernziele

• Eine modulare, factory-basierte Anwendungsarchitektur entwerfen.
• Services, Konfiguration und Erweiterungen sauber initialisieren.
• Wiederverwendbare Flask-Erweiterungen entwickeln und paketieren.
• Legacy-Anwendungen mit Tests und kleinen Releases modernisieren.
• CLI, Logging und CI als verbindliche Qualitätsbasis etablieren.

Zielgruppe

Erfahrene Entwickler, Softwarearchitekten, Bibliotheksverantwortliche und Teams mit langfristiger Wartungs- oder Modernisierungsverantwortung.

Voraussetzungen

Sehr gute Python- und Flask-Kenntnisse sowie praktische Erfahrung mit Tests, Git und mindestens einer größeren Anwendung.

Seminarinhalte

1. Application Factory und mehrfache Instanzen

Die Anwendung wird in einer Fabrikfunktion zusammengesetzt, damit Konfiguration, Tests und Varianten beherrschbar bleiben.

1. Schritt 1: create_app mit klarer Reihenfolge für Konfiguration, Erweiterungen, Blueprints und Hooks aufbauen.
2. Schritt 2: Testkonfiguration als Mapping übergeben und Dateizugriffe während des Imports vermeiden.
3. Schritt 3: Mehrere Anwendungsinstanzen mit getrennten Einstellungen innerhalb eines Prozesses erzeugen.
4. Schritt 4: Factory-Erkennung über die Flask-Kommandozeile und Produktionsserver prüfen.

2. Blueprints und modulare Funktionsbereiche

Große Anwendungen werden entlang fachlicher Verantwortlichkeiten in registrierbare Komponenten zerlegt.

1. Schritt 1: Blueprint-Grenzen nach Domäne statt ausschließlich nach technischen Schichten festlegen.
2. Schritt 2: Routen, Templates, statische Dateien und Fehlerbehandlung einem Blueprint zuordnen.
3. Schritt 3: URL-Präfixe, Unterdomänen und Endpunktnamen konsistent konfigurieren.
4. Schritt 4: Registrierungsreihenfolge, mehrfache Registrierung und gemeinsame Hooks testen.

3. Paketstruktur und interne Abhängigkeiten

Module werden so angeordnet, dass Importzyklen, globale Zustände und unklare Verantwortlichkeiten vermieden werden.

1. Schritt 1: Anwendungspaket, Konfiguration, Blueprints, Services, Modelle und Tests getrennt strukturieren.
2. Schritt 2: Öffentliche Schnittstellen über __init__-Module bewusst begrenzen.
3. Schritt 3: Abhängigkeitsrichtung festlegen und zyklische Importe durch Factory- oder Interface-Muster auflösen.
4. Schritt 4: Paket installierbar machen und Importverhalten in einer frischen Umgebung prüfen.

4. Konfiguration und Erweiterungsinitialisierung

Umgebungsabhängige Werte und Erweiterungen werden früh, eindeutig und ohne Importseiteneffekte eingerichtet.

1. Schritt 1: Defaults, Umgebungsvariablen und geheime Werte in einer nachvollziehbaren Rangfolge laden.
2. Schritt 2: Konfigurationsschlüssel mit Namensräumen versehen und beim Start validieren.
3. Schritt 3: Erweiterungsobjekte ungebunden erzeugen und erst in create_app initialisieren.
4. Schritt 4: Fehlende oder widersprüchliche Einstellungen mit einem kontrollierten Startabbruch behandeln.

5. Service-, Repository- und Domänenschichten

Geschäftslogik wird von HTTP und Persistenz getrennt, damit sie unabhängig testbar und wiederverwendbar bleibt.

1. Schritt 1: View-Funktionen auf Eingabe, Serviceaufruf und Response-Abbildung reduzieren.
2. Schritt 2: Services für Anwendungsfälle und Repositories für Datenzugriffe definieren.
3. Schritt 3: Domänenfehler statt HTTP-Ausnahmen aus tieferen Schichten zurückgeben.
4. Schritt 4: Servicefälle mit Fakes testen und Integrationspfade separat absichern.

6. Eigene Flask-CLI-Befehle

Wiederkehrende Verwaltungsaufgaben werden als nachvollziehbare, testbare Kommandos bereitgestellt.

1. Schritt 1: Befehl und Optionsstruktur mit Click definieren und an die Anwendung registrieren.
2. Schritt 2: Anwendungskontext für Datenbank- und Servicezugriffe korrekt nutzen.
3. Schritt 3: Idempotente Befehle für Initialisierung, Import, Wartung und Diagnose entwickeln.
4. Schritt 4: Ausgaben, Exitcodes und Fehlersituationen mit dem CLI-Runner testen.

7. Konfigurationsstrategie für Entwicklung, Test und Produktion

Konfiguration wird früh geladen, validiert und nach Sensitivität sowie Umgebung getrennt.

1. Schritt 1: Nicht geheime Defaults versionieren und umgebungsspezifische Werte darüberlegen.
2. Schritt 2: Verschachtelte Umgebungsvariablen und Präfixe konsistent verwenden.
3. Schritt 3: Geheimnisse aus Dateien oder Secret Stores laden, ohne sie zu protokollieren.
4. Schritt 4: Startprüfung für Pflichtwerte, Datentypen und widersprüchliche Optionen implementieren.

8. Strukturiertes Logging und Korrelationskennungen

Protokolle werden so gestaltet, dass technische Abläufe und einzelne Requests zuverlässig nachvollziehbar bleiben.

1. Schritt 1: Logger-Hierarchie, Level und Handler zentral konfigurieren.
2. Schritt 2: Request-, Benutzer- und Korrelationskennung als strukturierte Felder ergänzen.
3. Schritt 3: Sensible Daten, Tokens und vollständige Request-Körper konsequent filtern.
4. Schritt 4: Logausgabe für Entwicklung und zentrale Sammlung getrennt testen.

9. Erweiterungen auswählen und bewerten

Zusatzpakete werden nach Wartbarkeit, Kompatibilität, Sicherheitslage und tatsächlichem Nutzen ausgewählt.

1. Schritt 1: Funktionale Lücke beschreiben, bevor nach einer Erweiterung gesucht wird.
2. Schritt 2: Releaseaktivität, unterstützte Flask-Versionen, Tests und Abhängigkeiten prüfen.
3. Schritt 3: Konfigurations- und Lock-in-Risiken mit einer kleinen Spike-Implementierung bewerten.
4. Schritt 4: Entscheidung, Alternativen und Ausstiegsstrategie im Projekt festhalten.

10. Eigene Erweiterung mit init_app entwickeln

Wiederverwendbare Funktionalität wird ohne anwendungsspezifischen globalen Zustand gekapselt.

1. Schritt 1: Öffentliche API, Konfigurationsnamensraum und Lebenszyklus der Erweiterung definieren.
2. Schritt 2: Erweiterungsobjekt ungebunden erzeugen und über init_app registrieren.
3. Schritt 3: Zustand in app.extensions ablegen und Zugriff über Kontextobjekte kontrollieren.
4. Schritt 4: Mehrere Anwendungsinstanzen und unterschiedliche Konfigurationen parallel testen.

11. Paketierung, Dokumentation und Veröffentlichung

Die Erweiterung wird als installierbares Python-Paket mit klarer Versionierung und belastbarer Dokumentation bereitgestellt.

1. Schritt 1: Paketmetadaten, Abhängigkeiten und optionale Extras in pyproject.toml definieren.
2. Schritt 2: Öffentliche Klassen, Typinformationen und minimale Anwendungsbeispiele dokumentieren.
3. Schritt 3: Wheel und Source Distribution bauen und in einer sauberen Umgebung installieren.
4. Schritt 4: Version, Changelog und Freigabeprozess mit automatisierten Prüfungen verbinden.

12. Kompatibilität, Tests und Wartung von Erweiterungen

Unterstützte Python- und Flask-Stände werden in einer Testmatrix nachweisbar abgesichert.

1. Schritt 1: Einheiten-, Integrations- und Beispielanwendungstests getrennt strukturieren.
2. Schritt 2: Mehrere Konfigurationen und fehlende optionale Abhängigkeiten abdecken.
3. Schritt 3: Deprecations früh als Fehler behandeln und Migrationshinweise vorbereiten.
4. Schritt 4: Sicherheitsupdates und Abhängigkeitsänderungen mit geregelten Releases ausliefern.

13. pytest-Struktur und Fixtures

Tests erhalten wiederverwendbare, klar begrenzte Setups für Anwendung, Client, CLI und Daten.

1. Schritt 1: Testverzeichnisse und Benennung nach pytest-Konventionen anlegen.
2. Schritt 2: App-Fixture mit TESTING-Konfiguration und sauberem Teardown erstellen.
3. Schritt 3: Client-, Runner- und Daten-Fixtures aus der App-Fixture ableiten.
4. Schritt 4: Fixture-Sichtbarkeit und Scope so klein wie möglich halten.

14. Unit-Tests für Services und Domänenlogik

Geschäftsregeln werden ohne HTTP, echte Datenbank oder externe Dienste schnell und präzise geprüft.

1. Schritt 1: Komplexe Logik aus Views in reine Funktionen oder Services extrahieren.
2. Schritt 2: Abhängigkeiten über kleine Interfaces beziehungsweise Fakes ersetzen.
3. Schritt 3: Normal-, Grenz- und Fehlerfälle aus den Fachregeln ableiten.
4. Schritt 4: Tests nach beobachtbarem Verhalten statt internen Implementierungsdetails formulieren.

15. Integrations- und Migrationstests

Zusammenspiel von Anwendung, Datenbank, Queue und Fremdsystemadaptern wird in realitätsnahen Umgebungen überprüft.

1. Schritt 1: Testdatenbank mit produktionsnahem Datenbanktyp bereitstellen.
2. Schritt 2: Migrationen vom leeren Schema bis zum aktuellen Stand ausführen.
3. Schritt 3: Transaktionen, Constraints und Adapter gegen lokale Testdienste prüfen.
4. Schritt 4: Tests isolieren, parallelisierbar machen und Ressourcen zuverlässig abbauen.

16. Continuous Integration und Qualitätsgates

Jede Änderung durchläuft reproduzierbare Prüfungen, bevor sie zusammengeführt oder ausgeliefert wird.

1. Schritt 1: Installation aus Lockfile beziehungsweise definierten Abhängigkeiten in sauberer Umgebung durchführen.
2. Schritt 2: Formatierung, Linting, Typprüfung, Tests und Sicherheitsprüfung in getrennten Schritten ausführen.
3. Schritt 3: Testmatrix für unterstützte Python- und Flask-Stände festlegen.
4. Schritt 4: Abbruchkriterien, Artefakte und nachvollziehbare Berichte als Merge-Gate konfigurieren.

17. Bestandsaufnahme und technische Baseline

Vor Änderungen werden Versionen, Erweiterungen, Betriebswege und kritische Funktionen belastbar erfasst.

1. Schritt 1: Python-, Flask-, Werkzeug-, Jinja- und Erweiterungsstände inventarisieren.
2. Schritt 2: Startpfade, globale Zustände, Importseiteneffekte und eigene Patches identifizieren.
3. Schritt 3: Kritische Endpunkte, Datenflüsse und Betriebsabhängigkeiten priorisieren.
4. Schritt 4: Reproduzierbare Entwicklungs- und Testumgebung als Ausgangsbasis herstellen.

18. Abhängigkeiten und Deprecations aktualisieren

Versionssprünge werden in kleinen, überprüfbaren Schritten statt als unkontrollierter Rundumschlag durchgeführt.

1. Schritt 1: Abhängigkeiten sperren und Sicherheits- sowie Kompatibilitätsgrenzen dokumentieren.
2. Schritt 2: Deprecation-Warnungen sammeln und nach Auswirkung priorisieren.
3. Schritt 3: Zuerst transitive Bibliotheken, danach Flask und Erweiterungen stufenweise aktualisieren.
4. Schritt 4: Nach jedem Schritt Testlauf, Startprobe und Datenbankzugriff prüfen.

19. Refactoring zu Factory, Blueprints und Services

Monolithische Einstiegsmodule werden ohne Big-Bang in klar getrennte Bestandteile überführt.

1. Schritt 1: Globale Erweiterungsobjekte vom konkreten App-Objekt lösen.
2. Schritt 2: Application Factory einführen und bestehende Konfiguration übernehmen.
3. Schritt 3: Routen schrittweise in Blueprints und Geschäftslogik in Services verschieben.
4. Schritt 4: Alte und neue Struktur während der Übergangsphase mit denselben Regressionstests prüfen.

20. Schema-Migrationen und Datenänderungen

Datenbankschemata werden versioniert, überprüft und mit sicheren Vorwärts- und Rückwärtswegen ausgeliefert.

1. Schritt 1: Migrationswerkzeug initialisieren und Metadaten der Anwendung korrekt anbinden.
2. Schritt 2: Autogenerierte Migrationen fachlich prüfen und manuelle Korrekturen dokumentieren.
3. Schritt 3: Schemaänderung und Datenmigration trennen, wenn Laufzeit oder Sperren kritisch werden.
4. Schritt 4: Upgrade, Downgrade und Neuaufbau der Datenbank in einer isolierten Umgebung testen.

21. Migrationsplan, Datenänderungen und Rollout

Technische Modernisierung wird mit Datenkompatibilität, Betriebsfenster und Rückfallstrategie abgestimmt.

1. Schritt 1: Änderungen nach Risiko, Kopplung und Betriebswirkung in Releases schneiden.
2. Schritt 2: Schemaänderungen rückwärtskompatibel vorbereiten und getrennt ausrollen.
3. Schritt 3: Shadow-, Canary- oder Parallelbetrieb anhand der Plattformmöglichkeiten planen.
4. Schritt 4: Rollback-Kriterien, Datensicherung und Nachkontrolle vor dem Produktivwechsel testen.

Praxisprojekt

Eine monolithische Altanwendung wird testbar gemacht, in Factory und Blueprints zerlegt und um eine selbst entwickelte Erweiterung ergänzt. Paketbau, Kompatibilitätsmatrix und ein kontrollierter Modernisierungsrollout schließen das Projekt ab.

Methodik

Kurze fachliche Einordnungen wechseln mit Demonstrationen, geführten Umsetzungen, Fehleranalysen und eigenständigen Übungen. Jede größere Änderung wird durch einen Test, eine Diagnose oder eine betriebliche Prüfroutine abgesichert. Die Arbeitsstände werden schrittweise zu einem durchgängigen Beispielprojekt zusammengeführt.