Vollständige Benutzerauthentifizierung und Zugriffskontrolle – Ein Laravel-Passport-Tutorial, Pt. 1

Bei der Entwicklung einer Webanwendung ist es im Allgemeinen eine gute Idee, sie in zwei Ebenen aufzuteilen. Eine Middle-Tier-API interagiert mit der Datenbank, und eine Web-Tier besteht normalerweise aus einer Front-End-SPA oder MPA. Auf diese Weise ist eine Webanwendung lockerer gekoppelt, wodurch sie auf lange Sicht einfacher zu verwalten und zu debuggen ist.

Wenn die API erstellt wurde, kann das Einrichten von Authentifizierung und Status in einem zustandslosen API-Kontext etwas problematisch erscheinen.

In diesem Artikel sehen wir uns an, wie man eine vollständige Benutzerauthentifizierung und eine einfache Form der Zugriffskontrolle in einer API mit Laravel und Passport implementiert. Sie sollten Erfahrung im Umgang mit Laravel haben, da dies kein Einführungstutorial ist.

Installationsvoraussetzungen:

• PHP 7+, MySQL und Apache (Entwickler, die alle drei gleichzeitig installieren möchten, können XAMPP verwenden.)
• Komponist
• Laravel 7
• Laravel-Pass. Da APIs im Allgemeinen zustandslos sind und keine Sitzungen verwenden, verwenden wir im Allgemeinen Token, um den Status zwischen Anfragen beizubehalten. Laravel verwendet die Passport-Bibliothek, um einen vollständigen OAuth2-Server zu implementieren, den wir für die Authentifizierung in unserer API verwenden können.
• Postman, cURL oder Insomnia zum Testen der API – dies hängt von den persönlichen Vorlieben ab
• Texteditor Ihrer Wahl
• Laravel-Helfer (für Laravel 6.0 und höher) – führen Sie nach der Installation von Laravel und Passport einfach Folgendes aus:

 composer require laravel/helpers

Wenn das oben Genannte installiert ist, können wir loslegen. Stellen Sie sicher, dass Sie Ihre Datenbankverbindung einrichten, indem Sie die .env -Datei bearbeiten.

Laravel Passport Tutorial, Schritt 1: Fügen Sie einen Controller und ein Modell für Dummy-Anfragen hinzu

Zuerst erstellen wir einen Controller und ein Modell für Dummy-Anfragen. Das Modell wird in diesem Tutorial nicht von großem Nutzen sein, es soll nur eine Vorstellung von den Daten geben, die der Controller manipulieren soll.

Bevor wir das Modell und den Controller erstellen, müssen wir eine Migration erstellen. Führen Sie in einem Terminal- oder cmd.exe -Fenster, wenn Sie Windows verwenden, Folgendes aus:

 php artisan make:migration create_articles_table --create=articles

Gehen Sie nun zum Ordner database/migrations und öffnen Sie die Datei mit einem ähnlichen Namen wie xxxx_xx_xx_xxxxxx_create_articles_table.php .

In die up -Funktion der Klasse schreiben wir Folgendes:

 Schema::create('articles', function (Blueprint $table) { $table->increments('id'); $table->string('title'); $table->string('body'); $table->integer('user_id'); $table->timestamps(); });

Als Nächstes erstellen wir ein Article . Führen Sie dazu Folgendes aus:

 php artisan make:model Article

Wir erstellen dann den ArticleController -Controller, indem wir Folgendes ausführen:

 php artisan make:controller ArticleController --resource

Als Nächstes bearbeiten wir die Datei app/Providers/AppServiceProvider.php und importieren die Klasse Illuminate\Support\Facades\Schema , indem wir Folgendes hinzufügen:

 use Illuminate\Support\Facades\Schema

…an das Ende der Importe am Anfang der Datei.

Dann schreiben wir in die boot Funktion:

 Schema::defaultStringLength(191);

Nachdem dies alles erledigt ist, können wir Folgendes ausführen:

 php artisan migrate

…um die oben erstellte Migration anzuwenden.

Laravel Passport-Tutorial, Schritt 2: Erstellen Sie die erforderlichen Middleware-Elemente

Hier fügen wir die Middleware hinzu, die für das Funktionieren der API erforderlich ist.

JSON-Antworten

Das erste benötigte Teil ist die ForceJsonResponse Middleware, die alle Antworten automatisch in JSON konvertiert.

Führen Sie dazu Folgendes aus:

 php artisan make:middleware ForceJsonResponse

Und dies ist die Handle-Funktion dieser Middleware in App/Http/Middleware/ForceJsonReponse.php :

 public function handle($request, Closure $next) { $request->headers->set('Accept', 'application/json'); return $next($request); }

Als Nächstes fügen wir die Middleware unserer Datei app/Http/Kernel.php im Array $routeMiddleware :

 'json.response' => \App\Http\Middleware\ForceJsonResponse::class,

Dann fügen wir es auch dem Array $middleware in derselben Datei hinzu:

 \App\Http\Middleware\ForceJsonResponse::class,

Dadurch würde sichergestellt, dass die ForceJsonResponse Middleware bei jeder Anfrage ausgeführt wird.

CORS (Cross-Origin Resource Sharing)

Damit die Verbraucher unserer Laravel-REST-API von einem anderen Ursprung darauf zugreifen können, müssen wir CORS einrichten. Dazu erstellen wir eine Middleware namens Cors .

Wechseln Sie in einem Terminal oder einer cd in das Stammverzeichnis des Projekts und führen Sie Folgendes aus:

 php artisan make:middleware Cors

Fügen Sie dann in app/Http/Middleware/Cors.php den folgenden Code hinzu:

 public function handle($request, Closure $next) { return $next($request) ->header('Access-Control-Allow-Origin', '*') ->header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS') ->header('Access-Control-Allow-Headers', 'X-Requested-With, Content-Type, X-Token-Auth, Authorization'); }

Um diese Middleware zu laden, müssen wir dem Array $routeMiddleware von app/Http/Kernel.php eine Zeile hinzufügen:

 'cors' => \App\Http\Middleware\Cors::class,

Außerdem müssen wir es wie bei der vorherigen Middleware zum Array $middleware hinzufügen:

 \App\Http\Middleware\Cors::class,

Danach fügen wir diese Routengruppe an routes/api.php :

 Route::group(['middleware' => ['cors', 'json.response']], function () { // ... });

Alle unsere API-Routen gehen in diese Funktion, wie wir unten sehen werden.

Laravel Passport Tutorial, Schritt 3: Erstellen Sie Benutzerauthentifizierungs-Controller für die API

Jetzt wollen wir den Authentifizierungscontroller mit login und register erstellen.

Zuerst werden wir ausführen:

 php artisan make:controller Auth/ApiAuthController

Jetzt importieren wir einige Klassen in die Datei app/Http/Controllers/Auth/ApiAuthController.php . Diese Klassen werden bei der Erstellung der login und register verwendet. Wir werden die Klassen importieren, indem wir Folgendes hinzufügen:

 use App\User; use Illuminate\Support\Facades\Hash; use Illuminate\Support\Facades\Validator; use Illuminate\Support\Str;

…an der Oberseite des Controllers.

Um nun die Laravel-API-Authentifizierung für unsere Benutzer hinzuzufügen, werden wir die Funktionen login , logout und register (signup) in derselben Datei erstellen.

Die register sieht folgendermaßen aus:

 public function register (Request $request) { $validator = Validator::make($request->all(), [ 'name' => 'required|string|max:255', 'email' => 'required|string|email|max:255|unique:users', 'password' => 'required|string|min:6|confirmed', ]); if ($validator->fails()) { return response(['errors'=>$validator->errors()->all()], 422); } $request['password']=Hash::make($request['password']); $request['remember_token'] = Str::random(10); $user = User::create($request->toArray()); $token = $user->createToken('Laravel Password Grant Client')->accessToken; $response = ['token' => $token]; return response($response, 200); }

Die login -Funktion ist wie folgt:

 public function login (Request $request) { $validator = Validator::make($request->all(), [ 'email' => 'required|string|email|max:255', 'password' => 'required|string|min:6|confirmed', ]); if ($validator->fails()) { return response(['errors'=>$validator->errors()->all()], 422); } $user = User::where('email', $request->email)->first(); if ($user) { if (Hash::check($request->password, $user->password)) { $token = $user->createToken('Laravel Password Grant Client')->accessToken; $response = ['token' => $token]; return response($response, 200); } else { $response = ["message" => "Password mismatch"]; return response($response, 422); } } else { $response = ["message" =>'User does not exist']; return response($response, 422); } }

Und schließlich die logout Funktion:

 public function logout (Request $request) { $token = $request->user()->token(); $token->revoke(); $response = ['message' => 'You have been successfully logged out!']; return response($response, 200); }

Danach müssen wir die Funktionen login , register und logout zu unseren Routen hinzufügen, d. h. innerhalb der bereits in der API vorhandenen Routengruppe:

 Route::group(['middleware' => ['cors', 'json.response']], function () { // ... // public routes Route::post('/login', 'Auth\ApiAuthController@login')->name('login.api'); Route::post('/register','Auth\ApiAuthController@register')->name('register.api'); Route::post('/logout', 'Auth\ApiAuthController@logout')->name('logout.api'); // ... });

Zuletzt müssen wir das HasApiToken Merkmal zum User hinzufügen. Navigieren Sie zu app/User und vergewissern Sie sich, dass Sie Folgendes haben:

 use HasApiTokens, Notifiable;

… an der Spitze der Klasse.

Was wir bisher haben…

Wenn wir den Anwendungsserver starten – dh php artisan serve ausführen – und dann versuchen, eine GET -Anfrage an die Route /api/user zu senden, sollten wir die Nachricht erhalten:

 { "message": "Unauthenticated." }

Dies liegt daran, dass wir nicht für den Zugriff auf diese Route authentifiziert sind. Um einige Routen Ihrer Wahl zu schützen, können wir sie direkt nach den Route::post -Zeilen zu routes/api.php hinzufügen:

 Route::middleware('auth:api')->group(function () { // our routes to be protected will go in here });

Bevor wir fortfahren, fügen wir die Logout-Route zur auth:api -Middleware hinzu, da Laravel ein Token verwendet, um den Benutzer abzumelden – ein Token, auf das von außerhalb der auth:api -Middleware nicht zugegriffen werden kann. Unsere öffentlichen Routen sehen so aus:

 Route::group(['middleware' => ['cors', 'json.response']], function () { // ... // public routes Route::post('/login', 'Auth\ApiAuthController@login')->name('login.api'); Route::post('/register', 'Auth\ApiAuthController@register')->name('register.api'); // ... });

Unsere geschützten Routen hingegen sehen so aus:

 Route::middleware('auth:api')->group(function () { // our routes to be protected will go in here Route::post('/logout', 'Auth\ApiAuthController@logout')->name('logout.api'); });

Jetzt navigieren wir zum ArticleController , den wir in app/Http/Controllers/ArticleController.php erstellt haben, und löschen die create und edit -Methoden in dieser Klasse. Danach fügen wir den folgenden Code, leicht bearbeitet, zu jeder verbleibenden Funktion hinzu:

 $response = ['message' => '<function name> function']; return response($response, 200);

Wir füllen <function name> nach Bedarf aus. Zum Beispiel hat die update Funktion dies als Hauptteil:

 $response = ['message' => 'update function']; return response($response, 200);

Ein manueller Laravel-Authentifizierungstest: Erstellen eines Benutzers

Um einen Benutzer zu registrieren, senden wir eine POST -Anfrage an /api/register mit den folgenden Parametern: name , email (die eindeutig sein muss), password und password_confirmation .

Wenn der Benutzer erstellt wird, gibt die API ein Token zurück, das wir in weiteren Anfragen als Mittel zur Authentifizierung verwenden.

Um sich anzumelden, senden wir eine POST -Anforderung an /api/login . Wenn unsere Anmeldeinformationen korrekt sind, erhalten wir auf diese Weise auch ein Token von unserer Laravel-Anmelde-API.

Das Autorisierungstoken, das wir von dieser Anfrage zurückerhalten, können wir verwenden, wenn wir auf eine geschützte Route zugreifen möchten. In Postman hat die Registerkarte „Autorisierung“ ein Dropdown-Menü, in dem der Typ auf „Bearer Token“ eingestellt werden kann, wonach der Token in das Token-Feld gehen kann.

Der Vorgang ist bei Insomnia ganz ähnlich.

cURL-Benutzer können das Äquivalent tun, indem sie den Parameter -H "Authorization: Bearer <token>" übergeben, wobei <token> das Autorisierungstoken ist, das von der Anmelde- oder Registrierungsantwort angegeben wird.

Wie bei cURL können Entwickler, wenn sie planen, die API mit Axios oder einer Bibliothek dieser Art zu nutzen, einen Authorization -Header mit dem Wert Bearer <token> hinzufügen.

Laravel Passport Tutorial, Schritt 4: Erstellen Sie die Funktion zum Zurücksetzen des Passworts

Nachdem die grundlegende Authentifizierung abgeschlossen ist, ist es an der Zeit, eine Funktion zum Zurücksetzen des Passworts einzurichten.

Dazu können wir ein api_auth -Controller-Verzeichnis erstellen, neue benutzerdefinierte Controller erstellen und die Funktion implementieren; oder wir können die Auth-Controller bearbeiten, die wir mit Laravel generieren können. In diesem Fall bearbeiten wir die Auth-Controller, da die gesamte Anwendung eine API ist.

Zuerst generieren wir die Auth-Controller, indem wir Folgendes ausführen:

 composer require laravel/ui php artisan ui vue --auth

Wir bearbeiten die Klasse in app/Http/Controllers/Auth/ForgotPasswordController.php und fügen diese beiden Methoden hinzu:

 protected function sendResetLinkResponse(Request $request, $response) { $response = ['message' => "Password reset email sent"]; return response($response, 200); } protected function sendResetLinkFailedResponse(Request $request, $response) { $response = "Email could not be sent to this email address"; return response($response, 500); }

Als nächstes müssen wir den Controller einrichten, der das Passwort tatsächlich zurücksetzt, also navigieren wir zu app/Http/Controllers/Auth/ResetPasswordController.php und überschreiben die Standardfunktionen wie folgt:

 protected function resetPassword($user, $password) { $user->password = Hash::make($password); $user->save(); event(new PasswordReset($user)); } protected function sendResetResponse(Request $request, $response) { $response = ['message' => "Password reset successful"]; return response($response, 200); } protected function sendResetFailedResponse(Request $request, $response) { $response = "Token Invalid"; return response($response, 401); }

Wir müssen auch einige Klassen in den Controller importieren, indem wir Folgendes hinzufügen:

 use Illuminate\Auth\Events\PasswordReset; use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash;

…an der Oberseite des Controllers.

Wir möchten auch ändern, welche E-Mail-Benachrichtigung verwendet wird, da die mit Laravel gelieferte E-Mail-Benachrichtigung keine API-Token zur Autorisierung verwendet. Wir können eine neue unter app/Notifications erstellen, indem wir diesen Befehl ausführen:

 php artisan make:notification MailResetPasswordNotification

Wir müssen die Datei app/Notifications/MailResetPasswordNotification.php so bearbeiten, dass sie so aussieht:

 <?php namespace App\Notifications; use Illuminate\Bus\Queueable; use Illuminate\Notifications\Messages\MailMessage; use Illuminate\Auth\Notifications\ResetPassword; use Illuminate\Support\Facades\Lang; class MailResetPasswordNotification extends ResetPassword { use Queueable; protected $pageUrl; public $token; /** * Create a new notification instance. * * @param $token */ public function __construct($token) { parent::__construct($token); $this->pageUrl = 'localhost:8080'; // we can set whatever we want here, or use .env to set environmental variables } /** * Get the notification's delivery channels. * * @param mixed $notifiable * @return array */ public function via($notifiable) { return ['mail']; } /** * Get the mail representation of the notification. * * @param mixed $notifiable * @return \Illuminate\Notifications\Messages\MailMessage */ public function toMail($notifiable) { if (static::$toMailCallback) { return call_user_func(static::$toMailCallback, $notifiable, $this->token); } return (new MailMessage) ->subject(Lang::getFromJson('Reset application Password')) ->line(Lang::getFromJson('You are receiving this email because we received a password reset request for your account.')) ->action(Lang::getFromJson('Reset Password'), $this->pageUrl."?token=".$this->token) ->line(Lang::getFromJson('This password reset link will expire in :count minutes.', ['count' => config('auth.passwords.users.expire')])) ->line(Lang::getFromJson('If you did not request a password reset, no further action is required.')); } /** * Get the array representation of the notification. * * @param mixed $notifiable * @return array */ public function toArray($notifiable) { return [ // ]; } }

Um diese neue Benachrichtigung nutzen zu können, müssen wir die sendPasswordResetNotification Methode überschreiben, die der User von der Authenticatable -Klasse erbt. Alles, was wir tun müssen, ist dies zu app/User.php :

 public function sendPasswordResetNotification($token) { $this->notify(new \App\Notifications\MailResetPasswordNotification($token)); }

Mit einer ordnungsgemäß funktionierenden E-Mail-Einrichtung sollten Benachrichtigungen an dieser Stelle funktionieren.

Jetzt fehlt nur noch die Benutzerzugriffskontrolle.

Laravel Passport-Tutorial, Schritt 5: Erstellen Sie Access Control Middleware

Bevor wir Zugriffssteuerungs-Middleware erstellen, müssen wir die user so aktualisieren, dass sie eine Spalte mit dem Namen type , die verwendet wird, um die Benutzerebene zu bestimmen: Typ 0 ist ein normaler Benutzer, Typ 1 ist ein Administrator und Typ 2 ist a höchster Vorgesetzter.

Um die user zu aktualisieren, müssen wir eine Migration erstellen, indem wir Folgendes ausführen:

 php artisan make:migration update_users_table_to_include_type --table=users

In der neu erstellten Datei des Formulars database/migrations/[timestamp]_update_users_table.php müssen wir die up und down aktualisieren, um die type hinzuzufügen bzw. zu entfernen:

 public function up() { Schema::table('users', function (Blueprint $table) { $table->integer('type'); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::table('users', function (Blueprint $table) { $table->dropIfExists('type'); }); }

Als Nächstes führen wir php artisan migrate aus. Sobald dies erledigt ist, müssen wir unsere register in der Datei ApiAuthController.php bearbeiten und diese direkt vor der Zeile mit $user = User::create($request->toArray()); :

 $request['type'] = $request['type'] ? $request['type'] : 0;

Außerdem müssen wir diese Zeile zum Array $validator hinzufügen:

 'type' => 'integer',

Die erste dieser beiden Änderungen macht alle registrierten Benutzer standardmäßig zu „normalen Benutzern“, dh wenn kein Benutzertyp eingegeben wird.

Die Zugriffssteuerungs-Middleware selbst

Jetzt sind wir in der Lage, zwei Middleware-Elemente für die Zugriffskontrolle zu erstellen: eines für Administratoren und eines für Super-Administratoren.

Also werden wir laufen:

 php artisan make:middleware AdminAuth php artisan make:middleware SuperAdminAuth

Zuerst navigieren wir zu app/Http/Middleware/AdminAuth.php und importieren Illuminate\Support\Facades\Auth und bearbeiten dann die handle -Funktion wie folgt:

 public function handle($request, Closure $next) { if (Auth::guard('api')->check() && $request->user()->type >= 1) { return $next($request); } else { $message = ["message" => "Permission Denied"]; return response($message, 401); } }

Wir müssen auch die handle -Funktion in app/Http/Middleware/SuperAdminAuth.php :

 public function handle($request, Closure $next) { if (Auth::guard('api')->check() && $request->user()->type >= 2) { return $next($request); } else { $message = ["message" => "Permission Denied"]; return response($message, 401); } }

Sie sollten auch die Auth -Klasse am Anfang beider Dateien importieren, indem Sie Folgendes hinzufügen:

 use Illuminate\Support\Facades\Auth;

…auf den Grund der dort gefundenen Importe.

Um unsere neue Middleware zu verwenden, referenzieren wir beide Klassen im Kernel – also in app/Http/Kernel.php – indem wir die folgenden Zeilen zum $routeMiddleware Array hinzufügen:

 'api.admin' => \App\Http\Middleware\AdminAuth::class, 'api.superAdmin' => \App\Http\Middleware\SuperAdminAuth::class,

Wenn Entwickler die Middleware in einer bestimmten Route verwenden möchten, müssen Sie sie nur wie folgt zur Routenfunktion hinzufügen:

 Route::post('route','Controller@method')->middleware('<middleware-name-here>');

<middleware-name-here> kann in diesem Fall je nach Bedarf api.admin , api.superAdmin usw. sein.

Das ist alles, was benötigt wird, um unsere Middleware zu erstellen.

Alles zusammenfügen

Um zu testen, ob unsere Authentifizierung und Zugriffskontrolle funktioniert, müssen einige zusätzliche Schritte durchlaufen werden.

Testen der Laravel-Authentifizierung und Zugriffskontrolle: Schritt 1

Wir müssen die index von ArticleController ändern und die Route registrieren. (In realen Projekten würden wir PHPUnit verwenden und dies als Teil eines automatisierten Tests tun. Hier fügen wir zu Testzwecken manuell eine Route hinzu – sie kann später entfernt werden.)

Wir navigieren zum ArticleController Controller unter app/Http/Controllers/ArticleController und ändern die index so, dass sie wie folgt aussieht:

 public function index() { $response = ['message' => 'article index']; return response($response, 200); }

Als Nächstes registrieren wir die Funktion in einer Route, indem wir zur Datei routes/api.php gehen und Folgendes anhängen:

 Route::middleware('auth:api')->group(function () { Route::get('/articles', 'ArticleController@index')->name('articles'); });

Testen der Laravel-Authentifizierung und Zugriffskontrolle: Schritt 2

Jetzt können wir versuchen, ohne Authentifizierungstoken auf die Route zuzugreifen. Wir sollten einen Authentifizierungsfehler erhalten.

Testen der Laravel-Authentifizierung und Zugriffskontrolle: Schritt 3

Wir können auch versuchen, auf dieselbe Route mit einem Autorisierungstoken zuzugreifen (das wir durch die Registrierung oder Anmeldung weiter oben in diesem Artikel erhalten haben).

Manchmal kann dies zu einem ähnlichen Fehler wie diesem führen:

 Unknown column 'api_token' in 'where clause' (SQL: select * from `users` where `api_token` = ... 

In diesem Fall sollten Entwickler sicherstellen, dass sie eine Passport-Migration durchgeführt haben und ['guards']['api']['driver'] in config/auth.php auf passport gesetzt haben:

 'guards' => [ 'web' => [ 'driver' => 'session', 'provider' => 'users', ], 'api' => [ 'driver' => 'passport', 'provider' => 'users', ], ],

Danach muss auch der Konfigurationscache aktualisiert werden.

Sobald das behoben ist, sollten wir Zugriff auf die Route haben.

Testen der Laravel-Authentifizierung und Zugriffskontrolle: Schritt 4

Es ist Zeit, die Zugangskontrolle zu testen. Hängen wir ->middleware('api.admin') an die Artikelroute an, damit es so aussieht:

 Route::get('/articles', 'ArticleController@index')->middleware('api.admin')->name('articles');

Wir haben es so gemacht, dass einem neu erstellten Benutzer automatisch der Typ 0 zugewiesen wird, wie wir über die Route api/user sehen können.

Aus diesem Grund sollte beim Versuch, als solcher Benutzer auf den articles -Endpunkt zuzugreifen, eine Fehlermeldung angezeigt werden.

Ändern wir zu Testzwecken den Benutzer in der Datenbank so, dass er den type 1 hat. Nachdem wir diese Änderung über die api/user -Route erneut überprüft haben, sind wir bereit, erneut zu GET , die /articles/ -Route abzurufen.

Es funktioniert perfekt.

Entwickler, die komplexere Anwendungen erstellen, sollten beachten, dass eine ordnungsgemäße Zugriffskontrolle nicht so einfach ist. In diesem Fall können andere Anwendungen von Drittanbietern oder die Gates und Richtlinien von Laravel verwendet werden, um eine benutzerdefinierte Benutzerzugriffskontrolle zu implementieren. Im zweiten Teil dieser Serie werden wir uns mit robusteren und flexibleren Zutrittskontrolllösungen befassen.

Laravel-API-Authentifizierung: Was wir gelernt haben

In diesem Laravel Passport-Tutorial haben wir Folgendes besprochen:

1. Erstellen eines Dummy-Controllers und -Modells, um beim Testen unseres Laravel-Passport-Beispiels etwas zu verwenden.
2. Erstellen der Middleware, die erforderlich ist, damit unsere API reibungslos läuft, Adressieren von CORS und Erzwingen der API, immer JSON-Antworten zurückzugeben.
3. Einrichten der grundlegenden Laravel-API-Authentifizierung: Registrieren, Anmelden und Abmelden.
4. Einrichten der Funktion zum Zurücksetzen des Passworts basierend auf Laravels Standard.
5. Erstellen von Zugriffssteuerungs-Middleware zum Hinzufügen von Benutzerberechtigungsebenen zu verschiedenen Routen.

Dies sind wesentliche Fähigkeiten für jeden, der im Bereich der Laravel-Entwicklungsdienste arbeitet. Leser finden das Endergebnis in diesem GitHub-Repo und sollten nun gut positioniert sein, um die Authentifizierung mit Laravel zu implementieren. Wir freuen uns auf Kommentare unten.