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. Dieser Leitfaden 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',
],],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 User -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('password');
$table->timestamps();
});
}
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(); // Normalerweise der Primärschlüssel (id)
}
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:
<?php
namespace App\Http\Controllers;
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
{
// User Registration
public function register(Request $request)
{
$request->validate([
'name' => 'required|string|max:255',
'email' => 'required|string|email|max:255|unique:users',
'password' => 'required|string|min:6|confirmed',
]);
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
]);
$token = JWTAuth::fromUser($user);
return response()->json(['token' => $token], 201);
}
// User Login
public function login(Request $request)
{
$credentials = $request->only('email', 'password');
if (!$token = Auth::attempt($credentials)) {
return response()->json(['error' => 'Invalid credentials'], 401);
}
return response()->json(['token' => $token]);
}
// Logout User (Invalidate Token)
public function logout()
{
Auth::logout();
return response()->json(['message' => 'Successfully logged out']);
}
// Get Authenticated User
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:
use App\Http\Controllers\AuthController;
use Illuminate\Support\Facades\Route;
Route::post('registrieren', [AuthController::class, 'registrieren']);
Route::post('login', [AuthController::class, 'login']);
// Geschützte Routen (erfordern JWT-Token)
Route::middleware('auth:api')->group(function () {
Route::post('logout', [AuthController::class, 'logout']);
Route::get('me', [AuthController::class, 'me']);
});Diese Routen behandeln die Benutzerregistrierung, die Anmeldung, die Abmeldung und das Abrufen des authentifizierten Benutzers.
Schritt 9: Schützen von 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
Host: your-domain.com
Content-Type: application/json
{
"name": "John Doe",
"email": "john@example.com",
"password": "password",
"password_confirmation": "password"
}- Log in:
POST /api/login
Host: your-domain.com
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: Bearer <token>
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.
