Skip to content

6. Gültigkeitsbereiche von Daten

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer sendet zahlreiche Anfragen. Daten können daher auf mehreren Ebenen gemeinsam genutzt werden, die man als ihren Gültigkeitsbereich (Scope) bezeichnet:

  • Anwendungsbereich (Application Scope): Die Daten werden von allen Benutzern für die gesamte Lebensdauer des Servers gemeinsam genutzt (zum Beispiel die Liste der Ärzte);
  • Anfragebereich (Request Scope): Die Daten existieren nur für die Dauer einer einzelnen Anfrage (das Modell einer View, der für diese Anfrage identifizierte angemeldete Benutzer);
  • Clientbereich (Client Scope): Die Daten gehören zu einem Benutzer und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, der angemeldete Benutzer).

Für diesen letzten Bereich verwenden Webanwendungen seit langem eine vom Server verwaltete Session: ein Speicher für jeden Browser, der über ein Identifikations-Cookie erkannt wird ([JSESSIONID] in [Java], [PHPSESSID] in [PHP]). Die Session von [Flask] ist anders: Wie wir in Beispiel 20 gesehen haben, wird sie in einem signierten Cookie auf der Seite des Clients gespeichert. Der Server speichert zwischen zwei Anfragen desselben Benutzers nichts: Man nennt ihn zustandslos (stateless). Dadurch ist es zum Beispiel möglich, mehrere identische Server hinter einem Load Balancer zu betreiben: Jeder von ihnen kann jede Anfrage bearbeiten. Der Preis dafür ist, dass ein Cookie der Kontrolle des Benutzers unterliegt; er kann es lesen und versuchen, es zu ändern. Deshalb werden dort nur unkritische Daten gespeichert, und – wenn den Daten vertraut werden muss – sie werden vom Server signiert, der dann jede Änderung erkennt: Das ist bei der Session von [Flask] und beim Authentifizierungs-Token der Fall (siehe das Kapitel über Authentifizierung).

In [Flask] hat jeder Bereich seinen eigenen Container:

Bereich
Träger
Lebensdauer
Anwendung
Ein beim Start erzeugtes Objekt, gespeichert in [app.extensions] und abgerufen über [current_app] (Beispiel 06)
Die gesamte Lebensdauer des Servers, gemeinsam genutzt von allen Anfragen
Anfrage
Das Objekt [g] und das Objekt [request] selbst (Beispiel 16)
Verarbeitung einer Anfrage
Session
Das Objekt [session], ein in einem signierten Cookie gespeichertes Wörterbuch
Bis zum Schließen des Browsers (standardmäßig)
Client
Ein normales Cookie, gesetzt mit [set_cookie] (Beispiel 22)
Die mit [max_age] festgelegte Dauer

Die Objekte [current_app], [g], [request] und [session] werden aus dem Paket [flask] importiert. Es handelt sich um Proxys (Beispiel 05): Während einer Anfrage verweist jedes von ihnen auf das Objekt dieser Anfrage (oder der Anwendung, die sie verarbeitet).

6.1. Beispiel 23: Gültigkeitsbereiche

1
2
3
4
5
6
7
8
9
23-scopes/
├── app.py
├── controllers/
│   └── scopes.py
├── services/
│   └── counter.py
└── templates/
    └── scopes/
        └── scopes.html

6.1.1. Die Objekte: services/counter.py

# services/counter.py: ein gemeinsamer Zähler und die Informationen einer Anfrage
from itertools import count
from threading import Lock


# Scope APPLICATION: eine einzige Instanz (siehe app.py)
class CounterService:

    def __init__(self):
        self._total = 0
        # mehrere Anfragen können GLEICHZEITIG laufen: der Lock garantiert,
        # dass zwei gleichzeitige Inkremente nicht verloren gehen
        self._lock = Lock()

    def increment(self) -> int:
        with self._lock:
            self._total += 1
            return self._total


# Scope REQUEST: eine Instanz pro Anfrage (siehe app.py, Funktion start)
class RequestInfo:

    # ein Zähler, der von allen Instanzen gemeinsam genutzt wird (KLASSENattribut);
    # next(...) ist atomar: zwei Threads erhalten nie dieselbe Nummer
    _instances = count(1)

    def __init__(self, start: str):
        self.number = next(RequestInfo._instances)
        self.start = start
  • Zeilen 7–18: ein Besuchszähler mit Anwendungsbereich: ein einziges Objekt, das von allen Anfragen gemeinsam genutzt wird. Wie bei der Aufgabenliste in Beispiel 20 schützt eine Sperre das Inkrementieren: Die Anweisung [self._total += 1] ist nicht atomar (sie liest den Wert, erhöht ihn und schreibt ihn dann zurück), und zwei Threads, die sie gleichzeitig ausführen, könnten denselben Wert lesen – mit dem Ergebnis, dass ein Besuch verloren geht;
  • Zeilen 22–30: Informationen im Anfragebereich: ein Objekt pro Anfrage, das eine Nummer und die Uhrzeit der Anfrage enthält. Die Nummer stammt von einem Zähler, der von allen Instanzen gemeinsam genutzt wird: [count(1)] aus dem Standardmodul [itertools] ist ein Iterator , der bei jedem Aufruf von [next] 1, 2, 3 ... liefert. Es handelt sich um ein Klassenattribut (auf Klassenebene deklariert, nicht im Konstruktor): Es wird von allen Instanzen gemeinsam genutzt.

6.1.2. Die Konfiguration: app.py

# app.py: die Anwendung von Beispiel 23
from datetime import datetime
from pathlib import Path

from flask import Blueprint, Flask, g

from controllers.scopes import scopes
from services.counter import CounterService, RequestInfo

BOOTSTRAP = Path(__file__).resolve().parent.parent / "common" / "bootstrap"


def create_app():
    app = Flask(__name__)
    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True
    # der Schlüssel, der das Session-Cookie signiert (Scope SESSION)
    app.config["SECRET_KEY"] = "a-secret-key-for-example-23"
    # Scope APPLICATION: ein einziges Objekt, beim Start erstellt und von ALLEN
    # Anfragen ALLER Benutzer gemeinsam genutzt
    app.extensions["counter"] = CounterService()
    app.register_blueprint(Blueprint("bootstrap", __name__, static_folder=BOOTSTRAP,
                                     static_url_path="/bootstrap"))
    app.register_blueprint(scopes)

    # Scope REQUEST: das Objekt g entsteht und vergeht mit jeder Anfrage. Diese
    # Funktion, VOR der Action ausgeführt, legt darin ein Objekt ab, das die Action und die
    # View während DIESER Anfrage wiederfinden
    @app.before_request
    def start():
        g.info = RequestInfo(datetime.now().strftime("%H:%M:%S.%f")[:-3])

    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeile 18: der Schlüssel, der das Session-Cookie signiert;
  • Zeile 21: das Objekt mit Anwendungsbereich;
  • Zeilen 29–31: Vor jeder Anfrage wird ein Objekt [RequestInfo] in [g] abgelegt. Die Aktion und die View rufen es ab, aber nur während dieser Anfrage. [strftime("%H:%M:%S.%f")] formatiert die Uhrzeit mit ihren Mikrosekunden ([%f], sechs Ziffern); [[:-3]] entfernt die letzten drei Zeichen der Zeichenkette, sodass die Millisekunden übrig bleiben.

6.1.3. Der Controller: controllers/scopes.py

# controllers/scopes.py: die vier Datenbereiche (Scopes)
from flask import Blueprint, current_app, g, make_response, render_template, request, session

scopes = Blueprint("scopes", __name__)


@scopes.get("/")
def display():
    # APPLICATION: der gemeinsame Zähler
    total = current_app.extensions["counter"].increment()
    # SESSION: ein Dictionary, das speziell für DIESEN Browser gilt und das Flask in einem
    # SIGNIERTEN Cookie (session) speichert; es gilt, bis der Browser geschlossen wird
    session["visits"] = session.get("visits", 0) + 1
    # CLIENT: ein Datum, das vom BROWSER in einem gewöhnlichen Cookie aufbewahrt und
    # bei jeder Anfrage an den Server zurückgesendet wird
    my_visits = to_integer(request.cookies.get("myVisits")) + 1
    response = make_response(render_template(
        "scopes/scopes.html", total=total, instance=g.info.number,
        session_visits=session["visits"], my_visits=my_visits))
    response.set_cookie("myVisits", str(my_visits), httponly=True, samesite="Lax")
    return response


# "41" -> 41; None oder "abc" -> 0
def to_integer(text: str | None) -> int:
    try:
        return int(text)
    except (TypeError, ValueError):
        return 0
  • Zeile 10: der Anwendungsbereich. [current_app] bezeichnet die Anwendung, die die aktuelle Anfrage verarbeitet;
  • Zeile 13: der Session-Bereich. [session] wird wie ein Wörterbuch verwendet: [session.get("visits", 0)] liefert den Wert des Schlüssels oder 0, wenn er fehlt. Ändert die Aktion die Session, sendet [Flask] mit der Antwort ein neues Cookie, [session], das das signierte Wörterbuch enthält;
  • Zeile 16: der Clientbereich mit einem gewöhnlichen Cookie, [myVisits], gelesen aus [request.cookies]. Sein Wert ist eine vom Browser gelieferte Zeichenkette und kann daher fehlen oder ungültig sein; die Funktion [to_integer] liefert in beiden Fällen 0;
  • Zeilen 17–20: Um ein Cookie zu setzen, benötigt man das Antwortobjekt: [make_response] erstellt es aus der von der View erzeugten Seite (Beispiel 05), danach fügt [set_cookie] ihm den Header [Set-Cookie] hinzu. Ohne [max_age] gilt das Cookie, bis der Browser geschlossen wird (es ist ein „Session“-Cookie im Sinne der Browser);
  • Zeile 18: der Anfragebereich: das Objekt, das die Funktion [start] in [g] abgelegt hat.

6.1.4. Die View: templates/scopes/scopes.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="{{ url_for('bootstrap.static', filename='css/bootstrap.min.css') }}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# g und session sind in den Views zugänglich, während DERSELBEN Anfrage #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ g.info.number }} in the view),
        request received at {{ g.info.start }}</li>
      <li>session: {{ session_visits }} visit(s) from this browser ({{ session["visits"] }} in the view)</li>
      <li>client: {{ my_visits }} visit(s) from this browser</li>
    </ul>
  </div>
</body>
</html>

Die Objekte [g] und [session] sind auch in den Views zugänglich. Die View zeigt die von der Aktion erhaltenen Werte an und in Klammern dieselben Werte, direkt aus [g] und [session] gelesen: Während derselben Anfrage sehen die Aktion und die View dieselben Objekte.

6.1.5. Ausführung

Nach zwei Besuchen in einem Browser:

Image

Verfolgen wir die Anfragen mit [curl], das als erster Browser agiert und seine Cookies in der Datei [a.txt] speichert:

curl -i -c a.txt -b a.txt http://localhost:5000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 581
Set-Cookie: myVisits=1; HttpOnly; Path=/; SameSite=Lax
Set-Cookie: session=eyJ2aXNpdHMiOjF9.arfKwA.YK-2GACLdbCJ_NXM5dYJYlqEF-4; HttpOnly; Path=/
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the view),
        request received at 15:38:08.779</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser</li>
...

Die Antwort setzt zwei Cookies. Das erste, [myVisits], enthält den Wert im Klartext. Das zweite, [session], enthält das Session-Wörterbuch: Der Teil vor dem ersten Punkt ist das JSON [{"visits":1}], Base64-codiert (nicht komprimiert, wie in Beispiel 20, da es kurz ist); danach folgen das Datum und die Signatur.

Das Objekt des Anfragebereichs trägt die Nummer 2, obwohl dies der erste Besuch der Seite ist: Das liegt daran, dass die Funktion [start] vor jeder von der Anwendung empfangenen Anfrage läuft, auch vor Anfragen, für die keine Aktion existiert (hier eine Anfrage an eine nicht vorhandene URL, kurz zuvor gestellt) und vor Anfragen nach statischen Dateien. Im Browser löst jede Seite so eine zweite Anfrage nach dem Stylesheet von [Bootstrap] aus: daher die ungeraden Zahlen im Screenshot. Ein zweiter Besuch mit denselben Cookies:

curl -i -c a.txt -b a.txt http://localhost:5000/
1
2
3
4
5
6
7
8
Set-Cookie: myVisits=2; HttpOnly; Path=/; SameSite=Lax
Set-Cookie: session=eyJ2aXNpdHMiOjJ9.arfKwA.l68wWEMYpKTfN3xPp_lysXPExO8; HttpOnly; Path=/
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the view),
        request received at 15:38:08.799</li>
      <li>session: 2 visit(s) from this browser (2 in the view)</li>
      <li>client: 2 visit(s) from this browser</li>

Ein zweiter „Browser“ mit eigener, anfangs leerer Cookie-Datei:

curl -c b.txt -b b.txt http://localhost:5000/
1
2
3
4
5
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 4 (no. 4 in the view),
        request received at 15:38:08.813</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser</li>

Der Zähler der Anwendung läuft weiter; die Session und das Cookie des zweiten Browsers beginnen wieder bei 1. Schließlich fälscht ein böswilliger Benutzer seine eigenen Cookies: 1.000 Besuche in [myVisits] und eine Session, die vorgibt, [{"visits":999}] (Base64-codiert als [eyJ2aXNpdHMiOjk5OX0]) zu enthalten, mit der Signatur einer anderen Session:

curl -b "myVisits=1000;session=eyJ2aXNpdHMiOjk5OX0.arfKwA.YK-2GACLdbCJ_NXM5dYJYlqEF-4" http://localhost:5000/
1
2
3
4
      <li>application: 4 visit(s) to the site, all browsers combined</li>
      ...
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1001 visit(s) from this browser</li>

Das gewöhnliche Cookie wurde unverändert akzeptiert: 1.001 Besuche. Die gefälschte Session wurde dagegen abgelehnt: Ihre Signatur passt nicht zu ihrem Inhalt, und [Flask] hat sie ignoriert, als wäre sie nicht vorhanden. Das ist der entscheidende Unterschied zwischen einem gewöhnlichen und einem signierten Cookie. Merken wir uns die Regel: Daten vom Client sind nur vertrauenswürdig, wenn sie vom Server signiert wurden; und selbst dann bleiben sie lesbar: Wir legen nichts Geheimes darin ab.