Einführung in Flask

Flask ist ein leichtgewichtiges Web-Framework für Python, das nach dem Prinzip “Micro-Framework” entwickelt wurde. Im Gegensatz zu größeren Frameworks wie Django verzichtet Flask auf viele vorgefertigte Komponenten und bietet stattdessen eine minimale Grundausstattung, die flexibel erweitert werden kann.

Flask basiert auf dem WSGI-Toolkit Werkzeug und der Template-Engine Jinja2. Diese Komponenten bilden das Fundament für die Entwicklung von Webanwendungen. Der modulare Aufbau ermöglicht es Entwicklern, nur die benötigten Funktionalitäten zu integrieren und die Anwendung nach spezifischen Anforderungen zu gestalten.

Das Framework eignet sich besonders für kleine bis mittelgroße Anwendungen und Prototyping. Durch seine Einfachheit und die ausführliche Dokumentation ist Flask sowohl für Einsteiger als auch für erfahrene Entwickler gut geeignet.

2.2 Architektur und Designprinzipien

Flask folgt mehreren grundlegenden Designprinzipien, die seine Verwendung und Erweiterung bestimmen:

2.2.1 Minimalismus

Flask stellt nur die essentiellen Funktionen für die Webentwicklung zur Verfügung. Dazu gehören Routing, Request-Handling, Template-Rendering und Response-Generierung. Zusätzliche Funktionalitäten wie Datenbankabstraktion, Formularvalidierung oder Authentifizierung werden über Extensions hinzugefügt.

2.2.2 Flexibilität

Das Framework macht keine Vorgaben zur Projektstruktur oder zu verwendeten Bibliotheken. Entwickler können ihre Anwendungen nach eigenen Vorstellungen organisieren und passende Tools auswählen.

2.2.3 Explizite Konfiguration

Flask bevorzugt explizite Konfiguration gegenüber impliziten Konventionen. Dadurch wird der Code verständlicher und nachvollziehbarer, erfordert aber mehr initiale Konfigurationsarbeit.

2.2.4 WSGI-Kompatibilität

Flask-Anwendungen sind vollständig WSGI-kompatibel und können mit verschiedenen Webservern betrieben werden. Dies ermöglicht flexible Deployment-Strategien und Integration in bestehende Infrastrukturen.

2.2.5 Architekturkomponenten

Application Object: Das zentrale Flask-Objekt, das die Anwendung repräsentiert und Konfiguration sowie Routing verwaltet.

Request Context: Verwaltet anwendungsspezifische Daten während der Bearbeitung einer HTTP-Anfrage.

Application Context: Stellt anwendungsweite Ressourcen zur Verfügung, die unabhängig von spezifischen Requests existieren.

Blueprints: Ermöglichen die modulare Organisation von Anwendungscode durch gruppierte Routes und Funktionalitäten.

2.3 Installation und Projektsetup

2.3.1 Systemvoraussetzungen

Für die Flask-Entwicklung wird Python 3.8 oder höher empfohlen. Das System sollte pip für die Paketverwaltung zur Verfügung haben. In Windows-Umgebungen ist die Installation über den Microsoft Store oder die offizielle Python-Website möglich.

2.3.2 Virtuelle Umgebung erstellen

Die Verwendung virtueller Umgebungen ist für Flask-Projekte obligatorisch. Sie isolieren Projektabhängigkeiten und verhindern Konflikte zwischen verschiedenen Anwendungen.

python -m venv flask_projekt
flask_projekt\Scripts\activate  # Windows
source flask_projekt/bin/activate  # Linux/Mac

2.3.3 Flask-Installation

Nach der Aktivierung der virtuellen Umgebung kann Flask über pip installiert werden:

pip install Flask

Für Produktionsumgebungen sollte zusätzlich ein WSGI-Server installiert werden:

pip install gunicorn  # Linux/Mac
pip install waitress  # Windows-Alternative

2.3.4 Projektstruktur

2.3.5 Requirements-Datei

2.4 Erste Flask-Anwendung

2.4.1 Minimale Anwendung

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return '<h1>Hallo Flask!</h1>'

if __name__ == '__main__':
    app.run(debug=True)

2.4.2 Anwendungskomponenten erklärt

Import: Das Flask-Modul wird importiert und eine Anwendungsinstanz erstellt.

Route-Dekorator: @app.route('/') definiert eine URL-Route für die Wurzel-URL.

View-Funktion: hello_world() verarbeitet Anfragen an die definierte Route und gibt eine Antwort zurück.

Anwendungsstart: app.run(debug=True) startet den Entwicklungsserver mit aktiviertem Debug-Modus.

2.4.3 Erweiterte Anwendung mit Templates

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html', title='Startseite')

@app.route('/benutzer/<name>')
def benutzer(name):
    return render_template('benutzer.html', benutzername=name)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

2.4.4 Template-Dateien

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Flask Anwendung{% endblock %}</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

{% extends "base.html" %}

{% block title %}{{ title }}{% endblock %}

{% block content %}
<div class="row">
    <div class="col-md-12">
        <h1>Willkommen zur Flask-Anwendung</h1>
        <p>Dies ist eine einfache Flask-Anwendung mit Bootstrap-Integration.</p>
    </div>
</div>
{% endblock %}

2.4.5 Konfiguration und Umgebungsvariablen

import os

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'entwicklungsschluessel'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'sqlite:///app.db'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

app = Flask(__name__)
app.config.from_object(Config)

2.4.6 Debug-Modus und Entwicklungsumgebung

Der Debug-Modus sollte ausschließlich in der Entwicklungsumgebung aktiviert werden. In Produktionsumgebungen stellt er ein Sicherheitsrisiko dar.

2.4.7 Integration mit IIS

pip install wfastcgi

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.webServer>
    <handlers>
      <add name="PythonHandler" path="*" verb="*" 
           modules="FastCgiModule" 
           scriptProcessor="C:\path\to\python.exe|C:\path\to\wfastcgi.py" 
           resourceType="Unspecified" 
           requireAccess="Script" />
    </handlers>
  </system.webServer>
</configuration>

2.4.8 Erste Schritte zur Datenbankanbindung

import pyodbc
from flask import Flask

app = Flask(__name__)

# Datenbankverbindungsstring für MS-SQL
SQLSERVER_CONNECTION_STRING = (
    'DRIVER={ODBC Driver 17 for SQL Server};'
    'SERVER=servername;'
    'DATABASE=datenbankname;'
    'Trusted_Connection=yes;'
)

@app.route('/db-test')
def db_test():
    try:
        connection = pyodbc.connect(SQLSERVER_CONNECTION_STRING)
        cursor = connection.cursor()
        cursor.execute("SELECT @@VERSION")
        version = cursor.fetchone()[0]
        connection.close()
        return f"Datenbankverbindung erfolgreich: {version}"
    except Exception as e:
        return f"Datenbankfehler: {str(e)}"

Diese Grundlagen schaffen das Fundament für die Entwicklung komplexerer Flask-Anwendungen und die Integration mit bestehenden Unternehmensinfrastrukturen.

2 Einführung in Flask

2.1 Was ist Flask