{"id":60607,"date":"2023-03-30T14:40:09","date_gmt":"2023-03-30T13:40:09","guid":{"rendered":"https:\/\/kinsta.com\/de\/?p=60607&preview=true&preview_id=60607"},"modified":"2025-09-01T16:51:43","modified_gmt":"2025-09-01T15:51:43","slug":"laravel-authentifizierung","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/laravel-authentifizierung\/","title":{"rendered":"Ein umfassender Leitfaden zur Laravel-Authentifizierung"},"content":{"rendered":"

Die Authentifizierung ist eine der kritischsten und wichtigsten Funktionen von Webanwendungen. Web-Frameworks wie Laravel bieten viele M\u00f6glichkeiten f\u00fcr die Authentifizierung von Nutzern.<\/p>\n

Du kannst die Authentifizierungsfunktionen von Laravel schnell und sicher implementieren. Eine mangelhafte Implementierung dieser Authentifizierungsfunktionen kann jedoch riskant sein, da b\u00f6swillige Parteien sie ausnutzen k\u00f6nnen.<\/p>\n

In diesem Leitfaden erf\u00e4hrst du alles, was du wissen musst, um mit den von dir gew\u00e4hlten Laravel-Authentifizierungsmethoden loszulegen.<\/p>\n

Los geht’s!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Eine Einf\u00fchrung in die Laravel-Authentifizierung<\/h2>\n

Laravel<\/a> f\u00fchrt Module ein, die aus „W\u00e4chtern“ und „Anbietern<\/a>“ bestehen Guards legen die Benutzerauthentifizierung f\u00fcr jede Anfrage fest, und Provider definieren den Abruf von Benutzerdaten aus einem dauerhaften Speicher (z. B. einer MySQL<\/a>-Datenbank).<\/p>\n

Wir legen unsere Authentifizierungsparameter in einer Datei namens config\/auth.php<\/code> fest. Sie enth\u00e4lt mehrere Optionen, um das Authentifizierungsverhalten von Laravel zu optimieren und zu \u00e4ndern.<\/p>\n

Zuerst musst du die Authentifizierungsvorgaben festlegen. Diese Option steuert die Standardoptionen f\u00fcr die Authentifizierung und das Zur\u00fccksetzen von Passw\u00f6rtern in deiner Anwendung. Du kannst diese Voreinstellungen nach Bedarf \u00e4ndern, aber f\u00fcr die meisten Anwendungen sind sie ein perfekter Start.<\/p>\n

Als N\u00e4chstes legst du die Authentifizierungsgarantien f\u00fcr deine Anwendung fest. In unserer Standardkonfiguration verwenden wir den Sitzungsspeicher und den Eloquent User Provider. Alle Authentifizierungstreiber haben einen User Provider.<\/p>\n

<?php\n\nreturn [\n    \/* \n    Defining Authentication Defaults  \n    *\/\n    \n    'defaults' => [\n        'guard' => 'web', \n        'passwords' => 'users',\n    ],\n    \n    \/*\n    Defining Authentication Guards\n   \n    Supported: \"session\"\n    *\/\n\n    'guards' => [\n        'web' => [\n            'driver' => 'session',\n            'provider' => 'users',\n        ],\n     ],\n    \n    \/*\n    Defining User Providers\n\n    Supported: \"database\", \"eloquent\"\n    *\/\n\n    'providers' => [\n        'users' => [\n             'driver' => 'eloquent',\n             'model' => App\\Models\\User::class,\n        ], \n\n        \/\/ 'users' => [\n        \/\/     'driver' => 'database',\n        \/\/     'table' => 'users',\n        \/\/ ],\n    ],\n\n    \/*\n    Defining Password Resetting\n    *\/\n\n    'passwords' => [\n        'users' => [\n            'provider' => 'users',\n            'table' => 'password_resets',\n            'expire' => 60,\n            'throttle' => 60,\n         ],\n     ],\n\n     \/*\n     Defining Password Confirmation Timeout\n     *\/\n\n    'password_timeout' => 10800,\n];<\/code><\/pre>\n
Sp\u00e4ter stellen wir sicher, dass alle Authentifizierungstreiber einen Benutzerprovider haben. Dieser legt fest, wie die Benutzer aus deiner Datenbank oder anderen Speichermechanismen abgerufen werden, um die Benutzerdaten zu erhalten. Du kannst mehrere Quellen f\u00fcr jedes Modell oder jede Tabelle konfigurieren, wenn du mehrere Benutzertabellen oder -modelle hast. Diese Quellen k\u00f6nnen allen zus\u00e4tzlichen Authentifizierungsgarden zugewiesen werden, die du definiert hast.<\/p>\n
Es kann auch sein, dass die Benutzer ihre Passw\u00f6rter zur\u00fccksetzen wollen. Hierf\u00fcr kannst du mehrere Konfigurationen f\u00fcr das Zur\u00fccksetzen von Passw\u00f6rtern festlegen, wenn du mehr als eine Benutzertabelle oder ein Modell in der Anwendung hast und f\u00fcr die einzelnen Benutzertypen unterschiedliche Einstellungen vornehmen m\u00f6chtest. Die Ablaufzeit ist die Anzahl der Minuten, die jedes Reset-Token g\u00fcltig ist. Diese Sicherheitsfunktion sorgt daf\u00fcr, dass die Token kurzlebig sind, damit sie weniger Zeit haben, erraten zu werden. Du kannst dies nach Bedarf \u00e4ndern.<\/p>\n
Schlie\u00dflich musst du die Zeit festlegen, die vergeht, bevor eine Passwortbest\u00e4tigung abl\u00e4uft und der Nutzer aufgefordert wird, sein Passwort erneut \u00fcber den Best\u00e4tigungsbildschirm einzugeben. In der Standardeinstellung dauert die Zeit\u00fcberschreitung drei Stunden.<\/p>\n
Arten von Laravel-Authentifizierungsmethoden<\/h2>\n
Es gibt nicht f\u00fcr jedes Szenario die perfekte Authentifizierungsmethode, aber wenn du sie kennst, kannst du bessere Entscheidungen treffen. Dies und wie sich Laravel mit den neuen Funktionen in Laravel 9<\/a> weiterentwickelt. Das macht unsere Arbeit als Entwickler viel einfacher, wenn wir die Authentifizierungsmethoden wechseln.<\/p>\n
Passwortbasierte Authentifizierung<\/h3>\n
Diese rudiment\u00e4re Art der Benutzerauthentifizierung wird immer noch von Tausenden von Unternehmen genutzt, aber wenn man die aktuelle Entwicklung betrachtet, ist sie eindeutig veraltet.<\/p>\n
Die Anbieter m\u00fcssen komplexe Passw\u00f6rter durchsetzen und gleichzeitig daf\u00fcr sorgen, dass die Reibung f\u00fcr den Endnutzer m\u00f6glichst gering ist.<\/p>\n
Die Funktionsweise ist ziemlich einfach: Der Nutzer gibt seinen Namen und sein Passwort ein, und wenn die Datenbank eine \u00dcbereinstimmung zwischen diesen beiden Daten feststellt, entscheidet der Server, die Anfrage zu authentifizieren und dem Nutzer f\u00fcr eine bestimmte Zeit Zugang zu den Ressourcen zu gew\u00e4hren.<\/p>\n
Token-basierte Authentifizierung<\/h3>\n
Bei dieser Methode erh\u00e4lt der\/die Nutzer\/in nach der \u00dcberpr\u00fcfung ein eindeutiges Token.<\/p>\n
Mit diesem Token kann der Nutzer nun auf die entsprechenden Ressourcen zugreifen. Die Berechtigung gilt so lange, bis das Token abl\u00e4uft.<\/p>\n
Solange der Token aktiv ist, muss der Nutzer weder einen Benutzernamen noch ein Passwort verwenden, aber wenn er einen neuen Token abruft, sind diese beiden erforderlich.<\/p>\n
Token werden heute in vielen Szenarien eingesetzt, da sie zustandslose Einheiten sind, die alle Authentifizierungsdaten enthalten.<\/p>\n
Die M\u00f6glichkeit, die Tokengenerierung von der Token\u00fcberpr\u00fcfung zu trennen, gibt den Anbietern viel Flexibilit\u00e4t.<\/p>\n
Multi-Faktor-Authentifizierung<\/h3>\n
Wie der Name schon sagt, m\u00fcssen mindestens zwei Authentifizierungsfaktoren verwendet werden, um die Sicherheit zu erh\u00f6hen.<\/p>\n
Im Gegensatz zur Zwei-Faktor-Authentifizierung<\/a>, bei der nur zwei Faktoren zum Einsatz kommen, kann diese Methode zwei, drei, vier und mehr Faktoren umfassen..<\/p>\n
Bei dieser Methode wird in der Regel ein Passwort verwendet, nach dem der\/die Nutzer\/in einen Verifizierungscode auf sein\/ihr Smartphone geschickt bekommt. Anbieter, die diese Methode einsetzen, sollten auf Fehlalarme und Netzwerkausf\u00e4lle achten, die bei einer schnellen Skalierung zu gro\u00dfen Problemen f\u00fchren k\u00f6nnen.<\/p>\n
Wie man die Laravel-Authentifizierung implementiert<\/h2>\n
In diesem Abschnitt lernst du mehrere M\u00f6glichkeiten kennen, wie du die Nutzer deiner Anwendung authentifizieren kannst. F\u00fcr einige Bibliotheken wie Jetstream, Breeze und Socialite gibt es kostenlose Tutorials<\/a>, die dir zeigen, wie du sie nutzen kannst.<\/p>\n
Manuelle Authentifizierung<\/h3>\n
Beginne mit der Registrierung von Nutzern und der Erstellung der ben\u00f6tigten Routen in routes\/web.php<\/code>.<\/strong><\/p>\n
Wir werden zwei Routen erstellen, eine zum Anzeigen des Formulars und eine zur Registrierung:<\/p>\n
use App<\/span>\\Http<\/span>\\Contrllers\\Auth\\RegisterController;\nuse Illuminate\\Support\\Facades\\Route;\n\n\/*\nWeb Routes \n\nRegister web routes for your app's RouteServiceProvider \nin a group containing the \"web\" middleware\n*\/\n\nRoute::get('\/register', [RegisterController::class], 'create']);\n\nRoute::post('\/register', [RegisterController::class], 'store']);<\/code><\/pre>\n
Und erstellen den daf\u00fcr ben\u00f6tigten Controller:<\/p>\n
php artisan make controller Auth\/RegisterController -r<\/code><\/pre>\n
Aktualisiere nun den Code wie folgt:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse illuminate\\Htpp\\Request<\/span>;\n\nclass RegisterController extends Controller\n{\n    public function create()\n    {\n        return view('auth.register');\n    }\n\n    public function store(Request $request)\n    {\n    }\n}<\/code><\/pre>\n
Der Controller ist jetzt leer und gibt einen View zum Registrieren zur\u00fcck. Wir erstellen diese Ansicht in resources\/views\/auth<\/code> und nennen sie register.blade.php<\/code>.<\/p>\n
\"Laravel-Blade-View<\/a>
Laravel-Blade-Ansicht f\u00fcr die Benutzerregistrierung.<\/figcaption><\/figure>\n
Jetzt, wo alles eingerichtet ist, sollten wir unsere \/register<\/code> Route besuchen und das folgende Formular sehen:<\/p>\n
\"Anmeldung
Anmeldung f\u00fcr die manuelle Authentifizierung.<\/figcaption><\/figure>\n
Da wir nun ein Formular anzeigen k\u00f6nnen, das ein Nutzer ausf\u00fcllen kann, und die Daten daf\u00fcr erhalten, sollten wir die Daten des Nutzers abrufen, validieren und dann in der Datenbank speichern, wenn alles in Ordnung ist. Hier solltest du eine Datenbanktransaktion verwenden, um sicherzustellen, dass die Daten, die du einf\u00fcgst, vollst\u00e4ndig sind.<\/p>\n
Wir werden die Anfragevalidierung von Laravel nutzen, um sicherzustellen, dass alle drei Anmeldedaten erforderlich sind. Wir m\u00fcssen sicherstellen, dass die E-Mail ein E-Mail-Format hat und in der Tabelle users<\/code> eindeutig ist und dass das Passwort best\u00e4tigt ist und mindestens 8 Zeichen hat:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse Illuminate\\Foundation\\Auth\\User<\/span>;\nuse Illuminate\\Http<\/span>\\Request<\/span>;\nuse Illuminate\\Support\\Facades\\Hash<\/span>;\n\nclass RegisterController extends Controller\n{\n    public function store(Request $request)\n    {\n        \/* \n        Validation\n        *\/\n        $request->validate([\n            'name' => 'required',\n            'email' => 'required|email|unique:users',\n            'password' => 'required|confirmed|min:8',\n        ]);\n\n        \/*\n        Database Insert\n        *\/\n        $user = User:;create([\n            'name' => $request->name,\n            'email' => $request->email,\n            'password' => Hash::make($request->password),\n        ]);\n\n        return back();\n    }\n\n    public function create()\n    {\n        return view('auth.register');\n    }\n}<\/code><\/pre>\n
Da unsere Eingaben nun validiert sind, wird alles, was gegen unsere Validierung verst\u00f6\u00dft, einen Fehler ausl\u00f6sen, der im Formular angezeigt wird:<\/p>\n
\"Beispiel
Beispiel f\u00fcr eine ung\u00fcltige Eingabe bei der Registrierung<\/figcaption><\/figure>\n
Angenommen, wir haben in der Methode store<\/code> ein Benutzerkonto erstellt, wollen wir den Benutzer auch anmelden. Es gibt zwei M\u00f6glichkeiten, wie wir das tun k\u00f6nnen. Wir k\u00f6nnen es manuell tun oder die Auth-Fassade<\/strong> verwenden.<\/p>\n
Nachdem sich der Nutzer angemeldet hat, sollten wir ihn nicht auf den Registrierungsbildschirm zur\u00fcckbringen, sondern auf eine neue Seite, z. B. ein Dashboard oder eine Homepage. Genau das werden wir hier tun:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse App<\/span>\\Providers\\RouteServiceProvider;\nuse Illuminate\\Foundation\\Auth\\User<\/span>;\nuse Illuminate\\Http<\/span>\\Request<\/span>;\nuse Illuminate\\Support\\Facades\\Auth;\nuse Illuminate\\Support\\Facades\\Hash<\/span>;\n\nclass RegisterController extends Controller\n{\n    public function store(Request $request)\n    {\n        \/* \n        Validation\n        *\/\n        $request->validate([\n            'name' => 'required',\n            'email' => 'required|email|unique:users',\n            'password' => 'required|confirmed|min:8',\n        ]);\n\n        \/*\n        Database Insert\n        *\/\n        $user = User:;create([\n            'name' => $request->name,\n            'email' => $request->email,\n            'password' => Hash::make($request->password),\n        ]);\n\n        Auth::login($user):\n\n        return redirect(RouteServiceProvider::HOME);\n    }\n\n    public function create()\n    {\n        return view('auth.register');\n    }\n}<\/code><\/pre>\n
Jetzt, wo ein Nutzer registriert und angemeldet ist -n<\/code>, sollten wir daf\u00fcr sorgen, dass er sich sicher abmelden kann.<\/p>\n
Laravel schl\u00e4gt vor, die Sitzung ung\u00fcltig zu machen und das Token zur Sicherheit nach einer Abmeldung neu zu generieren. Und genau das werden wir jetzt tun. Wir beginnen damit, eine neue \/logout<\/code> Route zu erstellen, indem wir die destroy<\/code> Methode des LogoutControllers <\/strong> verwenden:<\/p>\n
use App<\/span>\\Http<\/span>\\Controllers\\Auth\\RegisterController;\nuse App<\/span>\\Http<\/span>\\Controllers\\Auth\\LogoutController;\nuse Illuminate\\Support\\Facades\\Route;\n\n\/*\nWeb Routes\n\nHere is where you can register web routes for your application. These\nroutes are loaded by the RrouteServiceProvider with a group which\ncontains the \"web\" middleware group. Now create something great!\n*\/\n\nRoute::get('\/register', [RegisterController::class, 'create']);\n\nRoute::post('\/register', [RegisterController::class, 'store']);\n\nRoute::post('\/logout', [Logoutcontroller::class, 'destroy'])\n    ->middleware('auth');<\/code><\/pre>\n
Die Weiterleitung des Logouts durch die auth<\/code>-Middleware ist sehr wichtig. Die Nutzer sollen nicht auf die Route zugreifen k\u00f6nnen, wenn sie nicht angemeldet sind.<\/p>\n
Erstelle nun einen Controller, wie wir es zuvor getan haben:<\/p>\n
php artisan make:controller Auth\/LogoutController -r<\/code><\/pre>\n
Wir k\u00f6nnen sicherstellen, dass wir die Anfrage als Parameter in der Methode destroy<\/code> erhalten. Wir melden den Benutzer \u00fcber die Auth-Fassade ab, machen die Sitzung ung\u00fcltig, generieren das Token neu und leiten den Benutzer zur Homepage weiter:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse Illuminate\\Http<\/span>\\Request<\/span>;\nuse Illuminate\\Support\\Facades\\Auth;\n\nclass LogoutController extends Controller\n{\n    public function destroy(Request $request)\n    { \n        Auth::logout();\n\n        $request->session()->invalidate();\n\n        $request->session()->regenerateToken();\n \n        return redirect('\/');\n     }\n}<\/code><\/pre>\n
Erinnerung an den Benutzer<\/h3>\n
Die meisten, wenn nicht sogar alle, modernen Webanwendungen bieten in ihrem Anmeldeformular ein Kontrollk\u00e4stchen zur Erinnerung an den Benutzer.<\/p>\n
Wenn wir eine Erinnerungsfunktion anbieten wollen, k\u00f6nnen wir einen booleschen Wert als zweites Argument an die Methode attempt \u00fcbergeben.<\/p>\n
Wenn dieser Wert g\u00fcltig ist, beh\u00e4lt Laravel den Benutzer auf unbestimmte Zeit oder so lange, bis er manuell abgemeldet wird, authentifiziert. Die Benutzertabelle muss die Spalte remember_token<\/code> enthalten (deshalb werden die Token neu generiert), in der wir unser „Remember me“-Token speichern.<\/p>\n
In der Standardmigration f\u00fcr Benutzer ist sie bereits enthalten.<\/p>\n
Als Erstes musst du das Feld „Remember Me<\/strong>“ zu deinem Formular hinzuf\u00fcgen:<\/p>\n
\"Remember<\/a>
Hinzuf\u00fcgen des Remember Me-Feldes von.<\/figcaption><\/figure>\n
Danach holst du dir die Anmeldedaten aus der Anfrage und verwendest sie in der Methode attempt der Auth-Fassade.<\/p>\n
Wenn der Benutzer erinnert werden soll, loggen wir ihn ein und leiten ihn auf unsere Homepage um. Andernfalls geben wir eine Fehlermeldung aus:<\/p>\n
public function store(Request $request)\n{\n    $credentials = $request->only('email', 'password');\n\n    if (Auth::attempt($credentials, $request->filled('remember'))) {\n        $request->session()->regenerate();\n\n        return redirect()->intended('\/');\n    }\n\n    return back()->withErrors([\n        'email' => 'The provided credentials do not match our records.',\n    ]);\n}<\/code><\/pre>\n
Passw\u00f6rter zur\u00fccksetzen<\/h3>\n
Die meisten Webanwendungen bieten heute die M\u00f6glichkeit, Passw\u00f6rter zur\u00fcckzusetzen.<\/p>\n
Wir erstellen eine weitere Route f\u00fcr das vergessene Passwort und erstellen den Controller wie zuvor. Au\u00dferdem f\u00fcgen wir eine Route f\u00fcr den Link zum Zur\u00fccksetzen des Passworts hinzu, die das Token f\u00fcr den gesamten Prozess enth\u00e4lt:<\/p>\n
Route::post('\/forgot-password', [ForgotPasswordLinkController::class, 'store']);\n\nRoute::post('\/forgot-password\/{token}', [ForgotPasswordController::class, 'reset']);<\/code><\/pre>\n
In der Store-Methode nehmen wir die E-Mail aus der Anfrage und validieren sie, wie wir es bereits getan haben.<\/p>\n
Danach k\u00f6nnen wir die Methode sendResetLink<\/code> aus der Passwort-Fassade verwenden.<\/p>\n
Und dann wollen wir als Antwort den Status zur\u00fcckgeben, wenn der Link erfolgreich gesendet wurde, oder andernfalls einen Fehler:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse Illuminate\\Http<\/span>\\Request<\/span>;\nuse Illuminate\\Support\\Facades\\Password<\/span>;\n\nclass ForgotPasswordLinkController extends Controller\n{\n    public function reset(Request $request)\n    {\n        $request->validate([\n             'email' => 'required|email',\n        ]);\n\n        $status = Password::sendResetLink(\n            $request->only('email');\n        );\n\n        return $status === Password::RESET_LINK_SENT\n            ? back()->with('status', __($status))\n            : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]);\n     }\n}<\/code><\/pre>\n
Nachdem der Link zum Zur\u00fccksetzen des Passworts an die E-Mail des Nutzers gesendet wurde, sollten wir uns um die Logik k\u00fcmmern, was danach passiert.<\/p>\n
Wir erhalten das Token, die E-Mail und das neue Passwort in der Anfrage und \u00fcberpr\u00fcfen sie.<\/p>\n
Danach k\u00f6nnen wir die Reset-Methode der Passwort-Fassade verwenden, damit Laravel sich um alles andere im Hintergrund k\u00fcmmert.<\/p>\n
Wir werden das Passwort immer mit einem Hash versehen, um es sicher zu machen.<\/p>\n
Am Ende pr\u00fcfen wir, ob das Passwort zur\u00fcckgesetzt wurde. Wenn ja, leiten wir den Benutzer mit einer Erfolgsmeldung zum Anmeldebildschirm weiter. Andernfalls zeigen wir eine Fehlermeldung an, dass es nicht zur\u00fcckgesetzt werden konnte:<\/p>\n
namespace<\/span> App<\/span>\\Http<\/span>\\Controllers\\Auth;\n\nuse App<\/span>\\Http<\/span>\\Controllers\\Controller<\/span>;\nuse Illuminate\\Http<\/span>\\Request<\/span>;\nuse Illuminate\\Support\\Facades\\Hash<\/span>;\nuse Illuminate\\Support\\Facades\\Password<\/span>;\nuse Illuminate\\Support\\Str;\n\nclass ForgotPasswordController extends Controller\n{\n    public function store(Request $request)\n    {\n        $request->validate([\n            'token' => 'required',\n            'email' => 'required|email',\n            'password' => 'required|string|confirmed|min:8',\n        ]);\n\n        $status = Password::reset(\n            $request->only('email', 'password', 'password_confirmation', 'token'),\n            function ($user) use ($request) {\n                $user->forceFill(\n                    'password' => Hash::make($request->password),\n                    'remember_token' => Str::random(60)\n                ])->save();\n            }\n        );\n\n        return $status == Password::PASSWORD_RESET\n            ? redirect()->route('login')->with('status', __($status))\n            : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]);\n    }\n}<\/code><\/pre>\n
Laravel Breeze<\/h2>\n
Laravel Breeze ist eine einfache Implementierung der Laravel-Authentifizierungsfunktionen: Anmeldung, Registrierung, Passwortzur\u00fccksetzung, E-Mail-Verifizierung und Passwortbest\u00e4tigung. Du kannst es verwenden, um die Authentifizierung in deiner neuen Laravel-Anwendung zu implementieren.<\/p>\n
Installation und Einrichtung<\/h3>\n
Nachdem du deine Laravel-Anwendung erstellt hast, musst du nur noch deine Datenbank konfigurieren, deine Migrationen durchf\u00fchren und das Paket laravel\/breeze \u00fcber Composer installieren:<\/p>\n
composer require laravel\/breeze \u2013dev<\/code><\/pre>\n
Danach f\u00fchrst du Folgendes aus:<\/p>\n
php artisan breeze:install<\/code><\/pre>\n
Dadurch werden deine Authentifizierungsansichten, -routen, -controller und andere Ressourcen, die es verwendet, ver\u00f6ffentlicht. Nach diesem Schritt hast du die vollst\u00e4ndige Kontrolle \u00fcber alles, was Breeze bietet.<\/p>\n
Jetzt m\u00fcssen wir unsere Anwendung auf dem Frontend rendern, also installieren wir unsere JS-Abh\u00e4ngigkeiten (die @vite verwenden):<\/p>\n
npm install<\/code><\/pre>\n
:<\/p>\n
npm run dev<\/code><\/pre>\n
Danach sollten die Links zum Anmelden und Registrieren auf deiner Homepage zu finden sein und alles sollte reibungslos funktionieren.<\/p>\n
Laravel Jetstream<\/h2>\n
Laravel Jetstream erweitert Laravel Breeze um n\u00fctzliche Funktionen und andere Frontend-Stacks.<\/p>\n
Es bietet Login, Registrierung, E-Mail-Verifizierung, Zwei-Faktor-Authentifizierung<\/a>, Sitzungsmanagement, API-Unterst\u00fctzung \u00fcber Sanctum und optionales Team-Management.<\/p>\n
Bei der Installation von Jetstream musst du im Frontend zwischen Livewire und Inertia w\u00e4hlen. Im Backend wird Laravel Fortify verwendet, ein frontend-unabh\u00e4ngiges, „headless“ Authentifizierungs-Backend f\u00fcr Laravel.<\/p>\n
Installation und Einrichtung<\/h3>\n
Wir werden es \u00fcber Composer in unserem Laravel-Projekt installieren:<\/p>\n
composer require laravel\/jetstream<\/code><\/pre>\n
Danach f\u00fchren wir den Befehl php artisan jetstream:install [stack]<\/code> aus, der die Argumente [stack]<\/code> Livewire<\/code> oder Inertia<\/code> akzeptiert. Du kannst die Option \u2013team<\/code> \u00fcbergeben, um die Teamfunktion zu aktivieren.<\/p>\n
Dadurch wird auch Pest PHP<\/a> zum Testen installiert.<\/p>\n
Zum Schluss m\u00fcssen wir das Frontend unserer Anwendung mit folgendem Befehl rendern:<\/p>\n
npm install\nnpm run dev<\/code><\/pre>\n
Laravel Fortify<\/h2>\n
Laravel Fortify ist eine Backend-Authentifizierungs-Implementierung, die nicht an das Frontend gebunden ist. Du musst Laravel Fortify nicht verwenden, um die Authentifizierungsfunktionen von Laravel zu implementieren.<\/p>\n
Es wird auch in Starter Kits wie Breeze und Jetstream verwendet. Du kannst Fortify auch eigenst\u00e4ndig verwenden, was nur eine Backend-Implementierung ist. Wenn du es allein verwendest, muss dein Frontend die Fortify-Routen aufrufen.<\/p>\n
Installation und Einrichtung<\/h3>\n
Wir k\u00f6nnen Fortify \u00fcber Composer installieren:<\/p>\n
composer require laravel\/fortify<\/code><\/pre>\n
Jetzt m\u00fcssen wir die Ressourcen von Fortify ver\u00f6ffentlichen:<\/p>\n
php artisan vendor:publish \u2013provider=\"LaravelFortifyFortifyServiceProvider\"<\/code><\/pre>\n
Danach erstellen wir ein neues App\/Actions<\/strong>-Verzeichnis sowie den neuen FortifyServiceProvider<\/strong>, die Konfigurationsdatei und die Datenbankmigrationen.<\/p>\n
Zum Schluss f\u00fchrst du aus:<\/p>\n
php artisan migrate<\/code><\/pre>\n
Oder:<\/p>\n
php artisan migrate:fresh<\/code><\/pre>\n
Und schon ist dein Fortify einsatzbereit.<\/p>\n
Laravel Socialite<\/h2>\n
Laravel enth\u00e4lt eine einfache OAuth-basierte Benutzerauthentifizierungsfunktion. Sie unterst\u00fctzt soziale Logins \u00fcber Facebook, Twitter<\/a>, LinkedIn<\/a>, Google, Bitbucket, GitHub und GitLab<\/a>.<\/p>\n
Installation<\/h3>\n
Wir k\u00f6nnen es \u00fcber Composer installieren:<\/p>\n
composer require laravel\/socialite<\/code><\/pre>\n
Einrichtung und Nutzung<\/h3>\n
Nach der Installation m\u00fcssen wir die Anmeldedaten f\u00fcr den OAuth-Anbieter hinzuf\u00fcgen, den unsere Anwendung verwendet. Wir f\u00fcgen sie in config\/services.php<\/strong> f\u00fcr jeden Dienst hinzu.<\/p>\n
In der Konfiguration sollten wir den Schl\u00fcssel mit den vorherigen Diensten abgleichen. Einige dieser Schl\u00fcssel sind:<\/p>\n