Lumen – das schnelle Mikro-Framework von Laravel

Inhalt:

• Was ist Lumen

• Wo kann das Lumen-Framework angewendet werden

• Komponenten in Lumen

• Installation

• Anwendung: eine Nutzerverwaltung mit Token-Verifizierung

 

---

Was ist Lumen

Lumen ist ein Projekt des Laravel-Erfinders Taylor Otwell. Es ist ein „Mikro-Framework“, das heißt, es ist eine kleinere, schnellere und schlankere Version eines vollständigen Webanwendungs-Frameworks (Laravel).

Lumen hat die gleiche Codebasis wie Laravel und viele gleiche Komponenten. Aber Lumen ist für Microservices gebaut, nicht so sehr für benutzerorientierte Anwendungen.

Wo kann das Lumen-Framework angewendet werden

Lumen ist für Projekte gedacht, die von der Eleganz und Leistungsfähigkeit von Laravel profitieren sollen. Einfach zu lesender und wartbarer Code, vollständig integriertes Unit-Testing. Man opfert gegenüber Laravel etwas Konfigurierbarkeit und Flexibilität für einen erheblichen Geschwindigkeitsschub.

Lumen ist auf Microservices ausgerichtet – kleine, lose gekoppelte Komponenten, die in der Regel ein Kernprojekt unterstützen und erweitern. Microservices sind getrennte Komponenten mit begrenzten Kontexten (d.h. sie haben wohldefinierte Schnittstellen untereinander). In einer Microservice-Architektur könnten Sie also mehrere kleine Lumen-Anwendungen haben, die eine andere, möglicherweise von Laravel betriebene, Anwendung unterstützen.

Komponenten in Lumen

Routing

Routing, das heißt Pfad-Planung, wird in Lumen standardmäßig unterstützt. Dazu gehören grundlegendes Routing, Routing-Parameter, benannte Routen und Routengruppen wie Middleware. (z.B. GET POST PUT usw.)

Authentifizierung

Die Authentifizierung unterstützt keinen Sitzungsstatus. Das heißt, APIs nutzen keine Sitzungs-Cookies und sind immer Zustandslos. Eingehende Anfragen werden über zustandslose Mechanismen wie Tokens authentifiziert.

Caching

Das Caching ist genauso implementiert wie in Laravel. Cache-Treiber wie Database, Memcached und Redis werden unterstützt.

Fehler und Logging

Fehler und Logging werden über die Monolog-Bibliothek implementiert, die Unterstützung für verschiedene Log-Handler bietet. Damit können Logs z.B. in den syslog geschrieben werden. Aber auch komplexeres logging wie Elastic-Search oder Redis sind möglich.

Queuing

Die Queuing (Warteschlangendienste) ähneln denen, die Laravel bietet. Es wird eine einheitliche API für eine Vielzahl von verschiedenen Warteschlangen-Backends bereitgestellt. Zum Beispiel können rechenintensive Zugriffe oder Updates im Hintergrund in einer Queue ausgeführt werden. Während die Lumen API schon eine Response gesendet hat.

Events

Ereignisse bieten eine einfache Beobachterimplementierung (Observer), mit der Ereignisse in der Lumen-Anwendung abonniert und abgehört werden können.

Encryption

Um sensible Daten wie Passwörter oder Zahlungsdaten zu speichern, nutzt Lumen die OpenSSL (AES-256-CBC) Verschlüsselung. Dazu werden die Befehle Crypt::encrypt(secret) und Crypt::decrypt($encryptedValue) zur Verfügung gestellt.

Installation

Composer, ein Abhängigkeitsmanager für PHP ist die Grundlage für die Installation und Verwaltung von Lumen. Daher muss Composer auf dem Rechner installiert sein, bevor man Lumen installieren kann.

Composer läuft nur mit PHP. Installationsanleitungen finden sich dazu unter der PHP-Website.

Folgende Befehle sind nötig um ein Lumen Projekt mit dem Namen blog aufzusetzten und dann auf dem localhost, Port 8000 zu starten:

composer create-project –prefer-dist laravel/lumen blog
php -S localhost:8000 -t public

Anwendung: eine Nutzerverwaltung mit Token-Verifizierung

Nutzerverwaltung Beispiel Frontend in HTML

Lumen konfigurieren

Nachdem das Lumen-Projekt aufgesetzt wurde, sollte ein App-Key erzeugt werden. Dieser sollte aus 32 zufälligen Zahlen und Buchstaben bestehen und in der .env Datei under APP_KEY eingetragen werden.

 

Datenbank vorbereiten

Lumen unterstützt die Verwendung einer Vielzahl von Datenbanken. Der Einfachheit halber soll hier nur die SQLite DB (File-Databasee) verwendeet werden. Dazu wird in der .env Datei die DB_CONNECTION=sqlite und DB_DATABASE=<path> gesetzt für Path wird der absolute Pfad zu eine leeren .sqlite – Datei eingesetzt.

Um Nutzer verwalten zu können, müssen Diese in einer Datenbank abgelegt werden. Um die entsprechende Tabelle zu erzeugen gibt es in Lumen vorgefertigte Werkzeuge. Die Datenbank-Migration der User-Table wird mit folgendem Befehl von Lumen generiert:

php artisan make:migration User

Im ordner database/migrations  wird die neue Migration erzeugt. Diese wird entsprechend erweitert mit den notwendigen Felder:

class User extends Migration
{
    /
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('fname');
            $table->string('sname');
            $table->timestamps();
        });
    }

    /
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('users');
    }
}

Routes erstellen

In der Datei routes/web.php werden von der API akzeptierte Pfade implementiert. Um alle Einträge aus der User Tabelle zu erhalten kann z.B. folgender Code genutzt werden:

$router->get('/users', function () use ($router) {
    return response()->json(app('db')->select("SELECT * FROM users"));
});

Diese Route ist dann unter http://localhost:8000/users erreichbar.

Um einen neuen Nutzer anzulegen wird ein POST Request genutzt. Dieses verbindet das Eingabeformular mit der Datenbank. Hier soll, der Einfachheit halber, ein simples HTML-Formular verwendet werden. Denkbar wäre aber auch ein POST-Request mit den entsprechenden einzutragenden Nutzerdaten über ein beliebiges anderes Frontend (Windows-EXE Datei, React-Web-App oder Android APK)

Link zur HTML-Datei

Authentisierung

Im POST Request steht ein API-TOKEN. Dieses wird durch die Lumen – Auth-Middleware überprüft und mit dem in der .env-Datei hinterlegten Token verglichen.

Dazu werden im Lumen Projekt in der Datei bootstrap/app.php die folgenden Zeilen einkommentiert:

$app->routeMiddleware([
    'auth' => App\Http\Middleware\Authenticate::class,
]);

$app->register(App\Providers\AuthServiceProvider::class);

Danach wird definiert, wie man den Nutzer Authentifizieren möchte. Die passiert in der Datei: app/providers/AuthServiceProvider.php

.
.
.
    public function boot()
    {
        // Here you may define how you wish users to be authenticated for your Lumen
        // application. The callback which receives the incoming request instance
        // should return either a User instance or null. You're free to obtain
        // the User instance via an API token or any other method necessary.

        $this->app['auth']->viaRequest('api', function ($request) {
            if ($request->input('api_token')) {
                if($request->input('api_token') === env("APP_TOKEN")){
                    return new User();
                }
                //return User::where('api_token', $request->input('api_token'))->first();
            }
        });
    }
}
.
.
.

Das Token wird aus dem .env-File geladen, um bei der Veröffentlichung des Quellcodes geheim zu bleiben. ENV-Files werden durch die .gitignore nicht mit hochgeladen.

Um Datenbank-Änderungen (User-POST) nur durch Authentifizierte Nutzer zuzulassen, wird eine neue Pfad-Verbindung in routes/web.php erstellt. Diese wird mittels der Auth-Middleware geschützt:

$router->post('/test', ['middleware' => 'auth', function (Illuminate\Http\Request $request) {
    $fname = $request->input('fname');
    $sname = $request->input('sname');
    $pdo = DB::connection()->getPdo();

$result = DB::insert(sprintf("INSERT INTO users (fname,sname)
VALUES ('%s','%s')",$fname,$sname));
    return  response()->json(["result" => "ok",
"user"=> [
    "id" => $pdo->lastInsertId(),
    "fname" => $fname,
    "sname" => $sname
]]);
}]);

Weiterführende Gedanken

Beispiel Nutzerverwaltung als Git Repository

Der Quellcode für das Beispiel der Nutzerverwaltung liegt HIER.

Vorteile

Die Tatsache, dass Lumen Laravel untergliedert ist, kann es leicht auf das Laravel angehoben werden.
Lumen hat eine geringe Lernkurve und ist einfach zu bedienen. Lumen gilt als eines der schnellsten Mikro-Frameworks von PHP und ist in der Lage hoch-performante Web-Applikationen mit Daten zu versorgen.

Nachteile

Lumen ist hauptsächlich für kleinere Anwendungen gedacht. Teilweise müssen simple Anfragen sehr abstrakt programmiert werden, da das Framework für fast alle Arten von Aufgaben und Anfragen schon ein Werkzeug mitliefert. Der Nachteil ist hier weniger Flexibilität.

Links zum Thema – Quellen

• Lumen-Homepage
• Lumen Dokumentation
• RESTful API Tutorial
• Laravel vs Lumen