06.12.2024

Aufbau einer sicheren Laravel-API mit JWT-Authentifizierung

Bei der Erstellung von APIs mit Laravel ist die Gewährleistung einer sicheren Authentifizierung von entscheidender Bedeutung, insbesondere beim Umgang mit Benutzerdaten. JSON Web Tokens (JWT) bieten eine robuste Methode für die Handhabung der Authentifizierung in zustandslosen Anwendungen und ermöglichen eine sichere Übertragung von Benutzerinformationen zwischen den Parteien. Diese Anleitung führt Sie durch den Prozess der Erstellung einer sicheren Laravel-API mit JWT-Authentifizierung.

Voraussetzungen

Grundlegende Kenntnisse von PHP und Laravel.
Laravel auf Ihrem Rechner installiert (vorzugsweise Laravel 9 oder neuer).
Composer installiert.
MySQL oder eine andere Datenbank, die für Ihre Anwendung eingerichtet ist.

Schritt 1: Erstellen Sie ein neues Laravel-Projekt

Erstellen Sie zunächst ein neues Laravel-Projekt mit Composer:

composer create-project laravel/laravel laravel-jwt-api

Navigieren Sie zu Ihrem Projektverzeichnis:

cd laravel-jwt-api

Schritt 2: JWT-Authentifizierungspaket installieren

Das am häufigsten verwendete Paket für die JWT-Authentifizierung in Laravel ist

tymon/jwt-auth

. Installieren Sie es mit Composer:

composer require tymon/jwt-auth

Nach der Installation des Pakets veröffentlichen Sie die JWT-Konfiguration:

php artisan vendor:publish --provider="Tymon\JWTAuth\Provider\LaravelServiceProvider"

Dadurch wird eine Datei

config/jwt.php

in Ihrem Projekt erstellt.

Schritt 3: Erzeugen des geheimen JWT-Schlüssels

Erzeugen Sie einen geheimen Schlüssel, den JWT für die Signierung von Token verwenden wird:

php artisan jwt:secret

Dies fügt einen

JWT_SECRET-Eintrag

zu Ihrer

.env-Datei

hinzu, der für die Kodierung und Dekodierung der Token verwendet wird.

Schritt 4: Authentifizierung einrichten

Um die JWT-Authentifizierung einzurichten, müssen Sie den Standardschutz für Ihre API konfigurieren. Aktualisieren Sie die Datei

config/auth.php

wie folgt:

'defaults' => [
 'guard' => 'api',
 'passwords' => 'users',

],‘guards’ => [
‘api’ => [
‘driver’ => ‘jwt’,
‘provider’ => ‘users’,
],
],

Dies weist Laravel an, den

jwt-Treiber

für API-Anfragen zu verwenden und sich mit dem

users-Anbieter

zu authentifizieren.

Schritt 5: Erstellen des Benutzermodells und Migration

Wenn Sie noch kein

Benutzermodell

erstellt haben, können Sie es zusammen mit seiner Migrationsdatei erstellen:

php artisan make:model Benutzer -m

Öffnen Sie die erstellte Migrationsdatei in

database/migrations/

und fügen Sie die erforderlichen Felder wie

Name

E-Mail

und

Passwort

hinzu:

public function up()
 {
 Schema::create('users', function (Blueprint $table) {
 $table->id();
 $table->string('name');
 $table->string('email')->unique();
 $table->string('Passwort');
 $table->Zeitstempel();
 });
 }

Führen Sie die Migration aus, um die

Benutzertabelle

zu erstellen:

php artisan migrate

Schritt 6: Implementierung von JWT-Methoden im Benutzermodell

Implementieren Sie im

Benutzermodell

(app/Models/User.php

) die Schnittstelle

JWTSubject

und die erforderlichen Methoden:

use Tymon\JWTAuth\Contracts\JWTSubject;
 use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable implements JWTSubject
{
public function getJWTIdentifier()
{
return $this->getKey();
}public function getJWTCustomClaims()
{
return [];
}
}

Schritt 7: Authentifizierungscontroller erstellen

Erstellen Sie einen Controller für die Benutzerauthentifizierung:

php artisan make:controller AuthController

Fügen Sie in

AuthController.php

Methoden für die Registrierung eines Benutzers, die Anmeldung und die Abmeldung hinzu:

use App\Models\User;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Hash;
 use Tymon\JWTAuth\Facades\JWTAuth;

class AuthController extends Controller
{
public function register(Request $request)
{
$request->validate([
name’ => ‘required|string|max:255’,
’email’ => ‘required|string|email|max:255|unique:users’,
‘passwort’ => ‘erforderlich|string|min:6|bestätigt’,
]); $benutzer = Benutzer::erstellen([
name’ => $Anfrage->Name,
’email’ => $anforderung->email,
‘Passwort’ => Hash::make($Anfrage->Passwort),
]);$token = JWTAuth::fromUser($user);

return response()->json([‘token’ => $token], 201);
}

public function login(Request $request)
{
$credentials = $request->only(’email’, ‘password’);

if (!$token = Auth::attempt($credentials)) {
return response()->json([‘error’ => ‘Ungültige Anmeldedaten’], 401);
}

return response()->json([‘token’ => $token]);
}

public function logout()
{
Auth::logout();

return response()->json([‘message’ => ‘Erfolgreich abgemeldet’]);
}

public function me()
{
return response()->json(Auth::user());
}
}

Schritt 8: Definieren von API-Routen

Fügen Sie Routen für die Authentifizierung in

routes/api.php

hinzu:

app\Http\Controllers\AuthControllerverwenden;

Route::post(‘register’,[AuthController::class, ‘register’]);
Route::post(‘login’,[AuthController::class, ‘login’]);
Route::post(‘logout’,[AuthController::class, ‘logout’])->middleware(‘auth:api’);
Route::get(‘me’,[AuthController::class, ‘me’])->middleware(‘auth:api’);

Diese Routen behandeln die Benutzerregistrierung, die Anmeldung, die Abmeldung und das Abrufen des authentifizierten Benutzers.

Schritt 9: Schutz der API-Routen

Um andere API-Routen zu schützen, können Sie die

auth:api-Middleware

verwenden. Wenn Sie zum Beispiel eine Ressourcenroute für

Beiträge

haben:

Route::middleware('auth:api')->group(function () {
 Route::resource('posts', PostController::class);
 });

Damit wird sichergestellt, dass nur authentifizierte Benutzer auf diese Routen zugreifen können.

Schritt 10: Testen der API

Sie können Ihre API mit Tools wie Postman oder cURL testen.

Registrieren Sie einen Benutzer:
POST /api/register Inhalt-Typ: application/json{
“name”: “John Doe”,
“email”: “john@example.com”,
“password”: “passwort”,
“passwort_bestaetigung”: “passwort”
}
Anmelden:
POST /api/login Content-Type: application/json{
“email”: “john@example.com”,
“password”: “password”
}
Dadurch wird ein Token zurückgegeben, das Sie für die Authentifizierung anderer Anfragen verwenden können.
Zugriff auf geschützte Route: Um auf eine geschützte Route wie
GET /api/me
zuzugreifen, fügen Sie das Token in den
Authorization-Header
ein:
Authorization: Überbringer

Schritt 11: Auffrischen von JWT-Tokens (optional)

Um ein Token zu aktualisieren, kann man eine Methode im

AuthController

hinzufügen:

public function refresh()
 {
 $token = Auth::refresh();
 return response()->json(['token' => $token]);
 }

Hinzufügen der Route für die Auffrischung:

Route::post('refresh', [AuthController::class, 'refresh'])->middleware('auth:api');

Schlussfolgerung

Mit diesem Leitfaden haben Sie eine sichere Laravel-API mit JWT-Authentifizierung erstellt, die die Registrierung und Anmeldung von Benutzern sowie den Zugriff auf geschützte Routen ermöglicht. Mit JWT können Sie einen zustandslosen Authentifizierungsmechanismus beibehalten, was besonders nützlich für die Skalierung von APIs ist. Mit dieser Einrichtung können Sie die Authentifizierungslogik Ihrer Anwendung weiter anpassen und zusätzliche Funktionen integrieren, wie z. B. rollenbasierte Zugriffskontrolle und Aktualisierungs-Tokens für langlebige Sitzungen.