Seminar Flask Grundlagen und Webanwendungen

Der viertägige Einstieg vermittelt Flask nicht als Sammlung einzelner Dekoratoren, sondern als vollständigen Entwicklungsweg von HTTP und Projektstruktur bis zu Datenbank, Formularen, Tests und erster Produktionsbereitstellung.

Jede Funktion wird in einer zusammenhängenden Anwendung umgesetzt. Dadurch entstehen belastbare Grundlagen für spätere Spezialisierungen in Architektur, APIs, Sicherheit und Betrieb, ohne zentrale Zusammenhänge zu überspringen.

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. Jinja-Rendering und sichere Ausgabe
8. Template-Vererbung und Layoutstruktur
9. Formulare und serverseitige Validierung
10. SQLAlchemy-Integration und Sitzungsmanagement
11. Modelle, Beziehungen und Integritätsregeln
12. pytest-Struktur und Fixtures
13. Produktionsbetrieb mit WSGI-Servern
14. Praxisprojekt und Wissenssicherung

Lernziele

• Eine Flask-Anwendung reproduzierbar einrichten und starten.
• HTTP-Routen, Requests und Responses fachlich korrekt umsetzen.
• Dynamische Oberflächen mit Jinja und Formularen entwickeln.
• Relationale Daten über SQLAlchemy modellieren und verändern.
• Wichtige Nutzerflüsse mit pytest und Test-Client absichern.
• Die Anwendung mit einem Produktionsserver bereitstellen.

Zielgruppe

Python-Entwickler, Quereinsteiger mit soliden Python-Grundlagen und Teams, die Webanwendungen mit Flask systematisch entwickeln wollen.

Voraussetzungen

Sichere Python-Grundlagen einschließlich Funktionen, Klassen, Module, Ausnahmen und virtueller Umgebungen. Webframework-Erfahrung ist nicht erforderlich.

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

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

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

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

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

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

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

Über vier Tage entsteht eine kleine, aber vollständige Fachanwendung mit Navigation, Formularen, Datenbankzugriff, Sitzungsfunktion und Tests. Der Abschlussstand wird als installierbares Paket über einen WSGI-Server gestartet.

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.