Seminar Flask Intensivseminar – Entwicklung vollständiger Webanwendungen

Das Intensivseminar fasst den vollständigen Entwicklungsweg einer klassischen Flask-Webanwendung zusammen. Es reicht von Projektstart und HTTP über Templates und Formulare bis zu Datenbank, Anmeldung, Internationalisierung, Tests und erster Produktionsausführung.

Die Themen werden in einer einzigen Fachanwendung zusammengeführt. Dadurch bleiben die Abhängigkeiten zwischen Oberfläche, Validierung, Persistenz, Sicherheit und Betrieb sichtbar, statt in isolierten Einzelübungen zu verschwinden.

Inhaltsübersicht

1. Arbeitsumgebung und Projektstart
2. HTTP, WSGI und Flask-Lebenszyklus
3. Anwendungsobjekt und erste Endpunkte
4. Routing, Konverter und URL-Erzeugung
5. Request-Daten und Kontextobjekte
6. Responses, Statuscodes und Content Negotiation
7. Hooks, Fehlerbehandlung und Request-Abschluss
8. Sitzungen, Cookies und Flash-Meldungen
9. Jinja-Rendering und sichere Ausgabe
10. Template-Vererbung und Layoutstruktur
11. Makros, Includes und wiederverwendbare Komponenten
12. Statische Dateien und Frontend-Integration
13. Formulare und serverseitige Validierung
14. CSRF-Schutz und robuste Eingabeprüfung
15. Datei-Uploads und sichere Verarbeitung
16. SQLAlchemy-Integration und Sitzungsmanagement
17. Modelle, Beziehungen und Integritätsregeln
18. Abfragen, Transaktionen und Servicegrenzen
19. Schema-Migrationen und Datenänderungen
20. Benutzerkonten, Kennwörter und Anmeldung
21. Locale-Ermittlung und Übersetzungskataloge
22. Datums-, Zeit-, Zahlen- und Währungsformate
23. Barrierearme Templates und Formulare
24. Tests für Übersetzung und Barrierearmut
25. pytest-Struktur und Fixtures
26. Routen- und Browserfluss-Tests
27. Produktionsbetrieb mit WSGI-Servern
28. Praxisprojekt und Wissenssicherung

Lernziele

• Eine vollständige Flask-Anwendung reproduzierbar aufbauen.
• HTTP, Routing, Templates und Formulare sicher verbinden.
• Datenmodelle, Transaktionen und Migrationen integrieren.
• Login, Sitzungen, Mehrsprachigkeit und Zugänglichkeit berücksichtigen.
• Nutzerflüsse automatisiert testen und produktionsnah starten.

Zielgruppe

Python-Entwickler mit soliden Sprachkenntnissen, die in kurzer Zeit eine vollständige Flask-Webanwendung systematisch entwickeln wollen.

Voraussetzungen

Sichere Python-Grundlagen. Vorkenntnisse in Flask sind hilfreich, aber bei guter Python-Praxis nicht zwingend.

Seminarinhalte

1. Arbeitsumgebung und Projektstart

Eine reproduzierbare Python-Umgebung bildet die Grundlage für Entwicklung, Tests und spätere Bereitstellung.

1. Schritt 1: Python-Version, virtuelle Umgebung und Paketverwaltung festlegen und voneinander abgrenzen.
2. Schritt 2: Projektverzeichnis mit Paketstruktur, Konfigurationsdateien und getrennten Abhängigkeiten anlegen.
3. Schritt 3: Flask installieren, Anwendungserkennung konfigurieren und den Entwicklungsmodus kontrolliert aktivieren.
4. Schritt 4: Start, Neustart und Abhängigkeitsprüfung dokumentieren und auf einem zweiten System nachvollziehen.

2. HTTP, WSGI und Flask-Lebenszyklus

Das Zusammenspiel von Browser, Reverse Proxy, WSGI-Server und Anwendung wird technisch eingeordnet.

1. Schritt 1: HTTP-Anfrage, Statuscode, Header und Nachrichtentext anhand einer vollständigen Transaktion zerlegen.
2. Schritt 2: WSGI-Anwendung und Serverrolle unterscheiden und die Grenzen des integrierten Entwicklungsservers festhalten.
3. Schritt 3: Anwendungs-, Request- und Response-Lebenszyklus mit Hooks und Kontextobjekten nachvollziehen.
4. Schritt 4: Eine Anfrage vom Eingang bis zur Antwort protokollieren und Fehlerstellen den zuständigen Schichten zuordnen.

3. Anwendungsobjekt und erste Endpunkte

Aus einer minimalen Anwendung entsteht schrittweise ein sauber startbares und erweiterbares Grundgerüst.

1. Schritt 1: Anwendungsobjekt erzeugen und Ressourcenpfade für Templates, statische Dateien und Instanzdaten bestimmen.
2. Schritt 2: Ersten Endpunkt registrieren und Rückgabewerte in reguläre Response-Objekte überführen lassen.
3. Schritt 3: Debug-Modus, Reloading und interaktiven Debugger sicher voneinander trennen.
4. Schritt 4: Startparameter über die Flask-Kommandozeile prüfen und Fehlkonfigurationen gezielt reproduzieren.

4. Routing, Konverter und URL-Erzeugung

URL-Regeln werden so aufgebaut, dass sie verständlich, eindeutig und dauerhaft wartbar bleiben.

1. Schritt 1: Statische und dynamische Routen mit passenden Pfadkonvertern definieren.
2. Schritt 2: HTTP-Methoden explizit zuordnen und idempotente von verändernden Operationen unterscheiden.
3. Schritt 3: Endpunktnamen, URL-Präfixe und URL-Erzeugung ohne fest codierte Pfade einsetzen.
4. Schritt 4: Konflikte, Slash-Verhalten und fehlerhafte Parameter mit dem Test-Client überprüfen.

5. Request-Daten und Kontextobjekte

Eingabedaten aus URL, Formular, JSON, Cookies und Headern werden kontrolliert gelesen und normalisiert.

1. Schritt 1: Query-Parameter, Pfadwerte und Formulardaten mit expliziten Standardwerten auslesen.
2. Schritt 2: JSON-Nachrichten anhand des Inhaltstyps prüfen und ungültige Nutzdaten eindeutig ablehnen.
3. Schritt 3: request, session, g und current_app nach Lebensdauer und Verantwortlichkeit einsetzen.
4. Schritt 4: Grenzfälle wie fehlende Felder, Mehrfachwerte und große Request-Körper mit Tests absichern.

6. Responses, Statuscodes und Content Negotiation

Antworten werden fachlich korrekt, maschinenlesbar und für Browser wie API-Clients nachvollziehbar erzeugt.

1. Schritt 1: Text, HTML, JSON, Dateien und Weiterleitungen mit passenden Response-Varianten zurückgeben.
2. Schritt 2: Statuscodes nach tatsächlichem Verarbeitungsergebnis auswählen und nicht als bloße Konvention behandeln.
3. Schritt 3: Header für Cache-Steuerung, Inhaltstyp, Dateinamen und Sicherheitsvorgaben setzen.
4. Schritt 4: Inhaltsaushandlung und Fehlerantworten mit unterschiedlichen Accept-Headern testen.

7. Hooks, Fehlerbehandlung und Request-Abschluss

Querschnittsaufgaben werden an definierten Stellen des Anfragezyklus ausgeführt und zuverlässig aufgeräumt.

1. Schritt 1: before_request, after_request und teardown-Funktionen nach ihrem Ausführungszeitpunkt auswählen.
2. Schritt 2: Fachliche, technische und HTTP-Fehler in getrennte Klassen und Handler überführen.
3. Schritt 3: Fehlerseiten beziehungsweise JSON-Fehler ohne Preisgabe interner Details erzeugen.
4. Schritt 4: Aufräumlogik auch bei abgebrochenen Requests und ausgelösten Ausnahmen testen.

8. Sitzungen, Cookies und Flash-Meldungen

Zustandsbehaftete Browserinteraktionen werden mit klaren Sicherheits- und Lebensdauerregeln umgesetzt.

1. Schritt 1: Secret Key, signierte Sitzung und serverseitige Alternativen fachlich bewerten.
2. Schritt 2: Cookie-Attribute Secure, HttpOnly und SameSite passend zur Betriebsumgebung konfigurieren.
3. Schritt 3: Sitzungsdaten minimieren, Loginwechsel durch session.clear absichern und Ablaufzeiten festlegen.
4. Schritt 4: Flash-Meldungen kategorisieren, im Template ausgeben und auf Mehrfachanzeige prüfen.

9. Jinja-Rendering und sichere Ausgabe

Dynamische HTML-Ausgabe wird strikt von Python-Logik getrennt und standardmäßig sicher gerendert.

1. Schritt 1: Template-Verzeichnis strukturieren und Daten über render_template übergeben.
2. Schritt 2: Variablen, Bedingungen, Schleifen und Filter lesbar einsetzen.
3. Schritt 3: Autoescaping, Markup und sichere Behandlung benutzergenerierter Inhalte unterscheiden.
4. Schritt 4: Fehlende Variablen und unerwartete Datentypen mit Tests und defensiven Filtern behandeln.

10. Template-Vererbung und Layoutstruktur

Gemeinsame Layoutteile werden zentral gepflegt, während einzelne Seiten nur ihre fachlichen Bereiche definieren.

1. Schritt 1: Basistemplate mit Kopf, Navigation, Hauptbereich und Fußbereich erstellen.
2. Schritt 2: Blöcke für Titel, Metadaten, Inhalte und Skripte gezielt freigeben.
3. Schritt 3: Unterlayouts und verschachtelte Templates ohne zyklische Abhängigkeiten aufbauen.
4. Schritt 4: Aktive Navigation, Fehlermeldungen und Seitentypen über einheitliche Kontextdaten steuern.

11. Makros, Includes und wiederverwendbare Komponenten

Wiederkehrende Oberflächenelemente werden als kleine, testbare Template-Komponenten gekapselt.

1. Schritt 1: Makros für Formularfelder, Tabellen, Hinweise und Pagination definieren.
2. Schritt 2: Includes nur für klar abgegrenzte Fragmente verwenden und Kontextübergaben explizit machen.
3. Schritt 3: Komponentenvarianten über Parameter statt kopierter Templates abbilden.
4. Schritt 4: HTML-Ausgabe der wichtigsten Komponenten mit Snapshot- oder Strukturtests prüfen.

12. Statische Dateien und Frontend-Integration

Stylesheets, JavaScript und Medien werden nachvollziehbar eingebunden und produktionsgerecht ausgeliefert.

1. Schritt 1: Static-Verzeichnis und URL-Erzeugung für versionierbare Assets einrichten.
2. Schritt 2: Progressive Enhancement für Formulare und Teilaktualisierungen planen.
3. Schritt 3: JSON-Endpunkte mit fetch-Aufrufen verbinden und Fehlerzustände im Browser behandeln.
4. Schritt 4: Cache-Busting, Content Security Policy und Asset-Build als Betriebsanforderungen dokumentieren.

13. Formulare und serverseitige Validierung

Formularverarbeitung wird als klarer Ablauf aus Anzeige, Eingabeprüfung, Verarbeitung und Rückmeldung umgesetzt.

1. Schritt 1: GET- und POST-Verhalten trennen und das Post/Redirect/Get-Muster anwenden.
2. Schritt 2: Felder, Validatoren und fachliche Abhängigkeiten in Formular- beziehungsweise Schemaobjekten definieren.
3. Schritt 3: Fehlermeldungen feldbezogen, verständlich und ohne Verlust eingegebener Werte ausgeben.
4. Schritt 4: Erfolgs- und Fehlerpfade mit realistischen Daten über den Test-Client prüfen.

14. CSRF-Schutz und robuste Eingabeprüfung

Verändernde Anfragen werden gegen fremde Ursprünge geschützt und Eingaberegeln zentral durchgesetzt.

1. Schritt 1: CSRF-Token aktivieren, in Formulare integrieren und für APIs bewusst anders behandeln.
2. Schritt 2: Längen, Formate, Wertebereiche und erlaubte Auswahlwerte bereits am Rand der Anwendung prüfen.
3. Schritt 3: Fachliche Validierung von Datenbankzugriff und Seiteneffekten trennen.
4. Schritt 4: Manipulierte Tokens, doppelte Übermittlungen und ungültige Zeichensätze automatisiert testen.

15. Datei-Uploads und sichere Verarbeitung

Uploads werden als untrusted input behandelt und mit Größen-, Typ- und Speicherregeln abgesichert.

1. Schritt 1: Multipart-Formulare, Request-Limits und erlaubte Dateitypen konfigurieren.
2. Schritt 2: Dateinamen normalisieren, zufällige Zielnamen vergeben und Pfadmanipulation verhindern.
3. Schritt 3: Dateien außerhalb direkt ausführbarer Webverzeichnisse speichern und Abrufrechte prüfen.
4. Schritt 4: Zu große, leere, doppelte und absichtlich falsch deklarierte Dateien testen.

16. SQLAlchemy-Integration und Sitzungsmanagement

Datenbankzugriffe werden über klar initialisierte Erweiterungen und requestgebundene Sessions organisiert.

1. Schritt 1: Datenbank-URL, Engine-Optionen und Verbindungsparameter je Umgebung festlegen.
2. Schritt 2: SQLAlchemy-Objekt ungebunden erzeugen und in der Application Factory mit init_app verbinden.
3. Schritt 3: Anwendungs- und Transaktionskontext für CLI, Tests und Requests korrekt öffnen.
4. Schritt 4: Verbindungsfehler, Poolgrenzen und sauberes Aufräumen reproduzierbar prüfen.

17. Modelle, Beziehungen und Integritätsregeln

Fachliche Datenstrukturen werden mit expliziten Schlüsseln, Constraints und nachvollziehbaren Beziehungen modelliert.

1. Schritt 1: Tabellen, Primärschlüssel, Datentypen und Nullbarkeit aus Fachregeln ableiten.
2. Schritt 2: Eins-zu-viele-, viele-zu-viele- und optionale Beziehungen mit klarer Eigentümerschaft definieren.
3. Schritt 3: Unique-, Check- und Foreign-Key-Regeln in der Datenbank statt nur in der Oberfläche verankern.
4. Schritt 4: Repräsentative Beispieldaten erzeugen und Integritätsverletzungen gezielt testen.

18. Abfragen, Transaktionen und Servicegrenzen

Lesen und Schreiben werden in Services gekapselt, damit Views keine unkontrollierte Datenbanklogik enthalten.

1. Schritt 1: Select-Abfragen mit Filtern, Sortierung, Pagination und gezielter Spaltenauswahl formulieren.
2. Schritt 2: Transaktionsgrenzen pro Anwendungsfall bestimmen und Commit beziehungsweise Rollback zentral steuern.
3. Schritt 3: N+1-Probleme und unnötige Lazy Loads mit geeigneten Ladeoptionen vermeiden.
4. Schritt 4: Paralleländerungen, verlorene Updates und fehlgeschlagene Commits in Tests simulieren.

19. 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.

20. Benutzerkonten, Kennwörter und Anmeldung

Lokale Konten werden mit sicheren Kennwortableitungen, eindeutigen Identitäten und kontrollierten Fehlversuchen verwaltet.

1. Schritt 1: Benutzeridentität, Status und eindeutige Anmeldeattribute modellieren.
2. Schritt 2: Kennwörter ausschließlich mit geeigneter Hashfunktion und individuellen Salts speichern.
3. Schritt 3: Login, Logout und generische Fehlermeldungen ohne Benutzererkennung umsetzen.
4. Schritt 4: Fehlversuche, deaktivierte Konten und Kennwortänderung mit Tests abdecken.

21. Locale-Ermittlung und Übersetzungskataloge

Sprache wird nachvollziehbar ausgewählt und alle sichtbaren Texte über wartbare Kataloge übersetzt.

1. Schritt 1: Unterstützte Sprachen und Fallback-Regeln festlegen.
2. Schritt 2: Locale aus Konto, URL oder Accept-Language in definierter Priorität bestimmen.
3. Schritt 3: Texte markieren, Kataloge extrahieren und Übersetzungen aktualisieren.
4. Schritt 4: Fehlende Übersetzungen und gemischte Sprache automatisiert erkennen.

22. Datums-, Zeit-, Zahlen- und Währungsformate

Internationale Darstellung wird von Speicherung und fachlicher Berechnung getrennt.

1. Schritt 1: Zeitpunkte intern eindeutig speichern und erst bei Ausgabe in die Nutzerzeitzone umwandeln.
2. Schritt 2: Datum, Uhrzeit, Dezimalzahl und Währung mit Locale-Regeln formatieren.
3. Schritt 3: Lokalisierte Eingaben kontrolliert parsen und mehrdeutige Formate vermeiden.
4. Schritt 4: Sommerzeitwechsel, negative Werte und große Zahlen mit Tests abdecken.

23. Barrierearme Templates und Formulare

Semantische Struktur, Tastaturbedienung und verständliche Rückmeldungen werden in die Komponenten eingebaut.

1. Schritt 1: Überschriftenhierarchie, Landmarken und sinnvolle Linktexte im Basistemplate festlegen.
2. Schritt 2: Formularfelder mit Labels, Hilfetexten und programmatisch zugeordneten Fehlermeldungen versehen.
3. Schritt 3: Fokusführung, Tastaturreihenfolge und sichtbare Fokuszustände prüfen.
4. Schritt 4: Automatisierte Prüfungen durch manuelle Tastatur- und Screenreader-Szenarien ergänzen.

24. Tests für Übersetzung und Barrierearmut

Sprachvarianten und grundlegende Zugänglichkeitsregeln werden Bestandteil der regulären Qualitätssicherung.

1. Schritt 1: Test-Client mit verschiedenen Locales und Zeitzonen konfigurieren.
2. Schritt 2: Übersetzte Templates auf fehlende Schlüssel, Platzhalter und unerwünschte Fallbacks prüfen.
3. Schritt 3: Formulare, Fehlermeldungen und Navigation in jeder Hauptsprache testen.
4. Schritt 4: A11y-Linting, HTML-Validierung und definierte manuelle Prüfschritte in die CI aufnehmen.

25. 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.

26. Routen- und Browserfluss-Tests

HTTP-Verhalten wird ohne realen Server über den Flask-Test-Client geprüft.

1. Schritt 1: GET-, POST- und Redirect-Ketten mit Statuscodes und Headern testen.
2. Schritt 2: Formular-, JSON-, Datei- und Cookie-Daten realistisch übermitteln.
3. Schritt 3: Anmeldezustand und Request-Kontext kontrolliert erhalten.
4. Schritt 4: HTML-Inhalte gezielt auf Semantik und Fehlermeldungen statt auf vollständige Zeichenketten prüfen.

27. Produktionsbetrieb mit WSGI-Servern

Der Entwicklungsserver wird durch einen belastbaren WSGI-Server mit passendem Worker-Modell ersetzt.

1. Schritt 1: Anwendungsimport beziehungsweise Factory-Aufruf für den Server eindeutig konfigurieren.
2. Schritt 2: Prozess-, Thread- und asynchrone Worker nach Lastprofil auswählen.
3. Schritt 3: Timeouts, Workeranzahl, Max-Requests und Graceful Shutdown festlegen.
4. Schritt 4: Start, Reload, Absturz und kontrolliertes Herunterfahren unter Last prüfen.

Praxisprojekt

Eine mehrsprachige Fachanwendung mit Benutzerkonto, Formularen, Upload, relationalen Daten, Rollenprüfung und automatisierten Tests entsteht als zusammenhängendes Projekt. Der fertige Stand wird über einen WSGI-Server ausgeführt.

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.