Skip to content

6. Daten-Scopes

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer sendet zahlreiche Anfragen. Daten können daher auf mehreren Ebenen geteilt werden, dem sogenannten Scope:

  • Anwendungs-Scope: Die Daten werden von allen Benutzern während der gesamten Lebensdauer der Anwendung gemeinsam genutzt (zum Beispiel die Liste der Ärzte);
  • Request-Scope: Die Daten existieren nur für die Dauer einer Anfrage (das Modell einer View, der für diese Anfrage identifizierte angemeldete Benutzer);
  • Session-Scope: Die Daten gehören zu einem bestimmten Benutzer und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, ein Warenkorb);
  • Client-Scope: Daten, die im Browser selbst in einem Cookie gespeichert werden.

In [PHP] verhalten sich diese Scopes besonders, weil die Anwendung bei jeder Anfrage neu aufgebaut wird (Beispiel 01): Nichts bleibt von einer Anfrage zur nächsten im Speicher erhalten. Daten, die länger als eine einzelne Anfrage bestehen sollen, werden daher außerhalb von [PHP] gespeichert: im Cache, in einer Datenbank, in Dateien oder auf der Client-Seite. Das ist die sogenannte „Shared-Nothing“-Architektur: Jede Anfrage wird isoliert von einem Prozess bearbeitet, der nichts mit den Prozessen teilt, die andere Anfragen bearbeiten. Dieser Ansatz hat erhebliche Vorteile: Ein Fehler betrifft nur eine einzelne Anfrage, es gelangen keine Daten von einem Benutzer zu einem anderen, und mehrere identische Server können hinter einem Load Balancer betrieben werden, sofern sie sich denselben Cache und dieselbe Datenbank teilen.

In [Laravel] hat jeder Scope seinen eigenen Container:

Scope
Container
Lebensdauer
Anwendung
der Cache ([Cache]-Fassade, Beispiel 20) oder die Datenbank
die gewählte Dauer oder unbegrenzt
Request
die Objekte des Containers (ein Singleton existiert nur für eine Anfrage), die Attribute der Anfrage (Beispiel 12)
Bearbeitung einer Anfrage
Session
die Session ([$request->session()], [session()]), vom Server gespeichert und über ein Cookie abgerufen
standardmäßig 2 Stunden Inaktivität ([SESSION_LIFETIME])
Client
ein Cookie ([withCookie], Beispiel 22), standardmäßig verschlüsselt
die angegebene Lebensdauer des Cookies

Die Session von [Laravel] ist eine serverseitig verwaltete Session, wie die von [Java] ([JSESSIONID]) oder die klassische von [PHP] ([PHPSESSID]): Ihre Daten werden auf dem Server gespeichert (eine Datei pro Session, mit der Konfiguration unserer Beispiele), und der Browser hält in einem verschlüsselten Cookie nur die Kennung (Beispiel 20). Das unterscheidet sich von [Flask], dessen gesamte Session in einem signierten Cookie auf der Client-Seite gespeichert wird.

6.1. Beispiel 23: Scopes

23-scopes/
├── app/
│   ├── Http/
│   │   └── Controllers/
│   │       └── ScopesController.php
│   └── Services/
│       ├── CounterService.php
│       └── RequestInfo.php
├── resources/
│   └── views/
│       └── scopes/
│           └── scopes.blade.php
└── ...

6.1.1. Die Objekte: app/Services/CounterService.php und RequestInfo.php

<?php
// app/Services/CounterService.php: Geltungsbereich ANWENDUNG, ein Zähler, der von
// allen Anfragen aller Benutzer gemeinsam genutzt und im Cache gespeichert wird (siehe Beispiel 20)

namespace App\Services;

use Illuminate\Support\Facades\Cache;

class CounterService
{
    // eine Zahl mehr unter dem Schlüssel [$key]; der "file"-Cache erhöht eine
    // Zahl nicht atomar: eine Sperre schützt das Lesen und das Schreiben
    public static function next(string $key): int
    {
        return Cache::lock("$key-lock", 10)->block(5, function () use ($key) {
            $value = Cache::get($key, 0) + 1;
            Cache::forever($key, $value);
            return $value;
        });
    }

    public function increment(): int
    {
        return self::next('visits');
    }
}
  • Zeilen 13–20: ein Zähler im Anwendungs-Scope: eine Zahl, die im Cache unter einem Schlüssel gespeichert und bei jedem Aufruf um 1 erhöht wird. Der Cache stellt eine Methode [Cache::increment] bereit, doch mit dem Store „file“, den wir in unseren Beispielen verwenden, ist sie nicht atomar: Sie liest den Wert, erhöht ihn und schreibt ihn dann zurück, und zwei gleichzeitige Anfragen könnten denselben Wert lesen – das Ergebnis wäre ein verlorener Besuch. Ein Lock (Beispiel 20) schützt daher sowohl das Lesen als auch das Schreiben. (Bei einem Store wie [Redis] oder einer Datenbank ist [Cache::increment] atomar, und das Lock ist überflüssig.) Die Funktion gibt den Wert des Locks zurück, der mit dem Wert der von ihm geschützten Funktion identisch ist;
  • Zeilen 22–25: der Besuchszähler.
<?php
// app/Services/RequestInfo.php: Geltungsbereich ANFRAGE, die Informationen einer Anfrage

namespace App\Services;

class RequestInfo
{
    public readonly int $number;

    public readonly string $start;

    public function __construct()
    {
        // eine Nummer pro erstelltem OBJEKT, entnommen einem von allen Anfragen gemeinsam genutzten Zähler
        $this->number = CounterService::next('instances');
        // die Uhrzeit mit ihren Millisekunden (v)
        $this->start = now()->format('H:i:s.v');
    }
}
  • Zeilen 8–10: Eigenschaften, die einzeln (statt für die gesamte Klasse) als [readonly] deklariert sind: Sie können nur einmal, und zwar vom Konstruktor, zugewiesen werden;
  • Zeilen 12–18: Informationen im Request-Scope: eine Zahl, abgeleitet von einem Zähler, der von allen Anfragen gemeinsam genutzt wird (der Zähler der vorherigen Klasse unter einem anderen Schlüssel), und die Uhrzeit der Anfrage. Die Funktion [now()] gibt die aktuelle Zeit als [Carbon]-Datum zurück; das Format [v] gibt die Millisekunden an.

6.1.2. Konfiguration: bootstrap/app.php

<?php
// bootstrap/app.php: die Anwendung von Beispiel 23

use App\Services\CounterService;
use App\Services\RequestInfo;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // die Route, die Bootstrap ausliefert (siehe Beispiel 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // das Cookie [myVisits] ist nicht verschlüsselt (die anderen schon)
        $middleware->encryptCookies(except: ['myVisits']);
    })
    ->withExceptions()
    // ein einziges Objekt jeder Klasse während der Bearbeitung einer Anfrage
    ->withSingletons([CounterService::class])
    ->withScopedSingletons([RequestInfo::class])
    ->create();
  • Zeile 18: Das Cookie [myVisits] wird nicht verschlüsselt; alle anderen sind verschlüsselt (Beispiel 22);
  • Zeilen 22–23: Beide Services sind im Container registriert. [withSingletons] (Beispiel 06): ein einziges Objekt, das bei der ersten Anfrage erstellt wird. [withScopedSingletons]: ein einziges Objekt pro Anfrage. Bei einem Standard-[PHP] sind beide gleichwertig, da jede Anfrage die Anwendung und ihren Container neu aufbaut. Der Unterschied zeigt sich bei [Laravel Octane], einem Anwendungsserver, der die Anwendung zur Leistungssteigerung von einer Anfrage zur nächsten im Speicher hält: Ein Singleton wird von allen Anfragen gemeinsam genutzt, während ein „Scoped“-Singleton für jede Anfrage neu erstellt wird. Die Deklaration des gewünschten Scopes stellt sicher, dass der Code in beiden Fällen korrekt ist.

6.1.3. Der Controller: app/Http/Controllers/ScopesController.php

<?php
// app/Http/Controllers/ScopesController.php: die vier Geltungsbereiche von Daten

namespace App\Http\Controllers;

use App\Services\CounterService;
use App\Services\RequestInfo;
use Illuminate\Http\Request;
use Illuminate\Http\Response;

class ScopesController
{
    // die beiden Objekte werden vom Container bereitgestellt (siehe bootstrap/app.php)
    public function display(Request $request, CounterService $counter, RequestInfo $info): Response
    {
        // ANWENDUNG: der gemeinsame Zähler
        $total = $counter->increment();
        // SESSION: Daten, die für DIESEN Browser spezifisch sind, vom SERVER aufbewahrt
        // (eine Datei in storage/framework/sessions), wiedergefunden dank des Session-Cookies
        $sessionVisits = $request->session()->increment('visits');
        // CLIENT: Daten, die vom BROWSER in Cookies aufbewahrt und
        // bei jeder Anfrage an den Server zurückgesendet werden; eines im Klartext, das andere verschlüsselt
        $myVisits = (int) $request->cookie('myVisits') + 1;
        $myEncryptedVisits = (int) $request->cookie('myEncryptedVisits') + 1;
        return response()->view('scopes.scopes', [
            'total' => $total, 'instance' => $info->number,
            'sessionVisits' => $sessionVisits, 'myVisits' => $myVisits,
            'myEncryptedVisits' => $myEncryptedVisits,
        ])->withCookie(cookie('myVisits', $myVisits))
            ->withCookie(cookie('myEncryptedVisits', $myEncryptedVisits));
    }
}
  • Zeile 14: Die Action erhält die Anfrage und die beiden Services, die vom Container bereitgestellt werden;
  • Zeile 17: der Anwendungs-Scope;
  • Zeile 20: der Session-Scope. [$request->session()] gibt die Session des Benutzers zurück; ihre Methode [increment] erhöht den Wert eines Schlüssels um 1 (oder setzt ihn auf 0, falls er nicht existiert) und gibt den neuen Wert zurück. Ein Wert wird mit [get('visits')] gelesen und mit [put('visits', 3)] geschrieben; die Funktion [session('visits')] ist eine Kurzform zum Lesen. [Laravel] speichert die Session am Ende der Anfrage (die [StartSession]-Middleware aus der Gruppe [web]);
  • Zeilen 23–24: der Client-Scope, mit zwei Cookies. Ihre Werte sind Zeichenketten, die vom Browser geliefert werden und daher fehlen oder ungültig sein können: Die Umwandlung [(int)] liefert 0 für [null] oder für Text, der keine Zahl ist;
  • Zeilen 25–30: Um ein Cookie zu setzen, benötigen Sie das Response-Objekt: [response()->view(...)] erstellt es aus der View (Beispiel 13), und anschließend fügt [withCookie] die Cookies hinzu. Ohne Ablaufzeit gilt ein Cookie, bis der Browser geschlossen wird (das ist ein „Session“-Cookie im Sinne der Browser).

6.1.4. Die View: resources/views/scopes/scopes.blade.php

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="{{ route('bootstrap', 'css/bootstrap.min.css') }}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {{-- @inject: an object requested from the container, from the view; during the SAME
         request, it is the same object as the one of the action --}}
    @inject('info', 'App\Services\RequestInfo')
    <ul>
      <li>application: {{ $total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ $instance }} (no. {{ $info->number }} in the view),
        request received at {{ $info->start }}</li>
      <li>session: {{ $sessionVisits }} visit(s) from this browser ({{ session('visits') }} in the view)</li>
      <li>client: {{ $myVisits }} visit(s) from this browser (clear-text cookie),
        {{ $myEncryptedVisits }} (encrypted cookie)</li>
    </ul>
  </div>
</body>
</html>
  • Zeile 13: Die Direktive [@inject] fordert innerhalb der View ein Objekt vom Container an und speichert es in einer Variablen (hier [$info]). Innerhalb derselben Anfrage ist dies dasselbe [RequestInfo]-Objekt wie das der Action: Die View zeigt dessen Nummer an, die mit der von der Action erhaltenen übereinstimmen muss;
  • Zeile 18: Die Session ist auch in den Views zugänglich.

6.1.5. Ausführung

Nach einigen Besuchen in einem Browser:

Image

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

curl -i -c a.txt -b a.txt http://localhost:8000/
HTTP/1.1 200 OK
Set-Cookie: myVisits=1; path=/; httponly; samesite=lax
Set-Cookie: myEncryptedVisits=eyJpdiI6InFOdXY5QmhoSlNCTWx4Q0VmN1lDSUE9PSIsInZhbHVlIjoiNm1GckpjQ3JK...; path=/; httponly; samesite=lax
Set-Cookie: XSRF-TOKEN=eyJpdiI6Im5IcHgvN2RRWiswNEZkMFRrUHBkOEE9PSIsInZhbHVlIjoiMTk1eElxemZz...; expires=...; Max-Age=7200; path=/; samesite=lax
Set-Cookie: example23_session=eyJpdiI6IjVEbjh1V2toeTdCdUFhSDdWWkV3ZHc9PSIsInZhbHVlIjoiK1J5SVNi...; expires=...; Max-Age=7200; path=/; httponly; samesite=lax
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 1 (no. 1 in the view),
        request received at 16:19:05.722</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (encrypted cookie)</li>
...

Die Antwort setzt vier Cookies. Das erste, [myVisits], enthält den Wert im Klartext. Das zweite, [myEncryptedVisits], enthält denselben Wert, verschlüsselt: Der sichtbare Teil ist eine Base64-codierte Zeichenkette (JSON), die den Initialisierungsvektor der Verschlüsselung ([iv]), den verschlüsselten Wert ([value]) und einen Authentifizierungscode ([mac]) enthält, der sicherstellt, dass der Wert nicht verändert wurde. Die letzten beiden dienen der Session und dem Anti-CSRF-Schutz (Beispiel 20). Ein zweiter Besuch mit denselben Cookies:

curl -i -c a.txt -b a.txt http://localhost:8000/
...
Set-Cookie: myVisits=2; path=/; httponly; samesite=lax
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the view),
        request received at 16:19:05.922</li>
      <li>session: 2 visit(s) from this browser (2 in the view)</li>
      <li>client: 2 visit(s) from this browser (clear-text cookie),
        2 (encrypted cookie)</li>
...

Ein zweiter „Browser“ mit eigener Cookie-Datei, die anfangs leer ist:

curl -c b.txt -b b.txt http://localhost:8000/
1
2
3
4
5
6
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the view),
        request received at 16:19:06.027</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (encrypted cookie)</li>

Der Anwendungszähler lief weiter; die Session und die Cookies des zweiten Browsers beginnen wieder bei 1. Jede Anfrage hatte ihr eigenes [RequestInfo]-Objekt, und in jeder waren Action und View dieselben. Schließlich fälscht ein böswilliger Benutzer seine eigenen Cookies: 1.000 Besuche in [myVisits], 999 in [myEncryptedVisits] und eine selbst erfundene Session-ID:

curl -b "myVisits=1000;myEncryptedVisits=999;example23_session=abc" http://localhost:8000/
1
2
3
4
5
      <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 (clear-text cookie),
        1 (encrypted cookie)</li>

Das unverschlüsselte Cookie wurde unverändert akzeptiert: 1.001 Besuche. Das Cookie [myEncryptedVisits] konnte hingegen nicht entschlüsselt werden: [Laravel] ignorierte es, als wäre es nicht vorhanden. Dasselbe gilt für das Session-Cookie: Der Benutzer kann nicht die Session eines anderen Benutzers wählen und erhält eine neue zugewiesen. Das ist der wesentliche Unterschied zwischen einem gewöhnlichen und einem verschlüsselten Cookie. Merken wir uns die Regel: Daten vom Client sind nur dann vertrauenswürdig, wenn sie vom Server geschützt werden (verschlüsselt, wie hier, oder signiert, wie das Token im Kapitel über die Authentifizierung); Daten, die nichts zu verbergen haben und deren Wert der Server überprüft (die Sprache in Beispiel 22), können im Klartext bleiben.