คู่มือฉบับสมบูรณ์สำหรับการรับรองความถูกต้องของ Laravel

การรับรองความถูกต้องเป็นหนึ่งในคุณสมบัติที่สำคัญและจำเป็นที่สุดของเว็บแอปพลิเคชัน เว็บเฟรมเวิร์กเช่น Laravel มีหลายวิธีสำหรับผู้ใช้ในการพิสูจน์ตัวตน

คุณสามารถใช้คุณลักษณะการรับรองความถูกต้องของ Laravel ได้อย่างรวดเร็วและปลอดภัย อย่างไรก็ตาม การใช้คุณลักษณะการตรวจสอบความถูกต้องเหล่านี้อย่างไม่ถูกต้องอาจมีความเสี่ยง เนื่องจากบุคคลที่ไม่ประสงค์ดีสามารถใช้ประโยชน์จากคุณลักษณะเหล่านี้ได้

คู่มือนี้จะสอนทุกสิ่งที่คุณจำเป็นต้องรู้เพื่อเริ่มต้นใช้งานวิธีการตรวจสอบสิทธิ์ Laravel ที่คุณเลือก

อ่านต่อ!

ข้อมูลเบื้องต้นเกี่ยวกับการรับรองความถูกต้องของ Laravel

Laravel แนะนำโมดูลที่ประกอบด้วย "ผู้พิทักษ์" และ "ผู้ให้บริการ" Guards กำหนดการรับรองความถูกต้องของผู้ใช้สำหรับแต่ละคำขอ และผู้ให้บริการกำหนดการดึงข้อมูลผู้ใช้จากที่เก็บข้อมูลถาวร (เช่น ฐานข้อมูล MySQL)

เรากำหนดพารามิเตอร์การตรวจสอบสิทธิ์ในไฟล์ชื่อ config/auth.php ประกอบด้วยตัวเลือกมากมายในการปรับแต่งและแก้ไขลักษณะการพิสูจน์ตัวตนของ Laravel

ขั้นแรก คุณต้องกำหนดค่าเริ่มต้นของการรับรองความถูกต้อง ตัวเลือกนี้ควบคุมตัวเลือก "ยาม" และรีเซ็ตรหัสผ่านสำหรับการรับรองความถูกต้องเริ่มต้นของแอปพลิเคชันของคุณ คุณสามารถเปลี่ยนค่าเริ่มต้นเหล่านี้ได้ตามต้องการ แต่เป็นการเริ่มต้นที่สมบูรณ์แบบสำหรับแอปพลิเคชันส่วนใหญ่

ถัดไป คุณกำหนดตัวป้องกันการตรวจสอบสิทธิ์สำหรับแอปพลิเคชันของคุณ ที่นี่ การกำหนดค่าเริ่มต้นของเราใช้ที่เก็บข้อมูลเซสชันและผู้ให้บริการผู้ใช้ Eloquent ไดรเวอร์การรับรองความถูกต้องทั้งหมดมีผู้ให้บริการผู้ใช้

 return [ /* Defining Authentication Defaults */ 'defaults' => [ 'guard' => 'web', 'passwords' => 'users', ], /* Defining Authentication Guards Supported: "session" */ 'guards' => [ 'web' => [ 'driver' => 'session', 'provider' => 'users', ], ], /* Defining User Providers Supported: "database", "eloquent" */ 'providers' => [ 'users' => [ 'driver' => 'eloquent', 'model' => App\Models\User::class, ], // 'users' => [ // 'driver' => 'database', // 'table' => 'users', // ], ], /* Defining Password Resetting */ 'passwords' => [ 'users' => [ 'provider' => 'users', 'table' => 'password_resets', 'expire' => 60, 'throttle' => 60, ], ], /* Defining Password Confirmation Timeout */ 'password_timeout' => 10800, ];

ในภายหลัง เราตรวจสอบให้แน่ใจว่าไดรเวอร์การตรวจสอบสิทธิ์ทั้งหมดมีผู้ให้บริการผู้ใช้ กำหนดวิธีการดึงข้อมูลผู้ใช้จากฐานข้อมูลของคุณหรือกลไกการจัดเก็บข้อมูลอื่นๆ เพื่อคงข้อมูลของผู้ใช้ของคุณ คุณสามารถกำหนดค่าแหล่งที่มาหลายรายการแทนแต่ละรุ่นหรือตาราง หากคุณมีตารางหรือรุ่นผู้ใช้หลายรายการ แหล่งที่มาเหล่านี้อาจถูกกำหนดให้กับตัวป้องกันการตรวจสอบสิทธิ์พิเศษที่คุณกำหนดไว้

ผู้ใช้อาจต้องการรีเซ็ตรหัสผ่านด้วย สำหรับสิ่งนี้ คุณสามารถระบุการกำหนดค่าการรีเซ็ตรหัสผ่านได้หลายรายการ หากคุณมีตารางหรือโมเดลผู้ใช้มากกว่าหนึ่งรายการในแอปพลิเคชัน และต้องการการตั้งค่าแยกต่างหากตามประเภทผู้ใช้เฉพาะ เวลาหมดอายุคือจำนวนนาทีที่แต่ละโทเค็นการรีเซ็ตจะใช้งานได้ คุณลักษณะด้านความปลอดภัยนี้ช่วยให้โทเค็นมีอายุสั้น ดังนั้นจึงมีเวลาน้อยลงในการคาดเดา คุณสามารถเปลี่ยนสิ่งนี้ได้ตามต้องการ

ท้ายที่สุด คุณต้องกำหนดเวลาก่อนที่การยืนยันรหัสผ่านจะหมดเวลา และผู้ใช้จะได้รับแจ้งให้ป้อนรหัสผ่านอีกครั้งผ่านหน้าจอการยืนยัน ตามค่าเริ่มต้น การหมดเวลาจะคงอยู่เป็นเวลาสามชั่วโมง

ประเภทของวิธีการรับรองความถูกต้องของ Laravel

ไม่มีวิธีที่สมบูรณ์แบบในการตรวจสอบทุกสถานการณ์ แต่การรู้สิ่งเหล่านี้จะช่วยให้คุณตัดสินใจได้ดีขึ้น สิ่งนี้และวิธีที่ Laravel พัฒนาด้วยคุณสมบัติใหม่ใน Laravel 9 สิ่งนี้ทำให้งานของเราในฐานะนักพัฒนาง่ายขึ้นเมื่อเปลี่ยนโหมดการตรวจสอบสิทธิ์

การรับรองความถูกต้องด้วยรหัสผ่าน

ในฐานะที่เป็นวิธีพื้นฐานในการรับรองความถูกต้องของผู้ใช้ องค์กรหลายพันแห่งยังคงใช้งานอยู่ แต่เมื่อพิจารณาถึงการพัฒนาในปัจจุบันแล้ว เห็นได้ชัดว่ามันล้าสมัยไปแล้ว

ผู้ขายต้องบังคับใช้รหัสผ่านที่ซับซ้อนในขณะที่ต้องแน่ใจว่ามีแรงเสียดทานน้อยที่สุดสำหรับผู้ใช้ปลายทาง

การทำงานค่อนข้างตรงไปตรงมา ผู้ใช้ป้อนชื่อและรหัสผ่าน และหากในฐานข้อมูลมีการจับคู่ระหว่างสองสิ่งนี้ เซิร์ฟเวอร์จะตัดสินใจตรวจสอบคำขอและให้ผู้ใช้เข้าถึงทรัพยากรตามเวลาที่กำหนดไว้ล่วงหน้า

การรับรองความถูกต้องตามโทเค็น

วิธีการนี้ใช้ในกรณีที่ผู้ใช้ได้รับโทเค็นเฉพาะเมื่อมีการยืนยัน

การมีโทเค็นนี้ ตอนนี้ผู้ใช้สามารถเข้าถึงทรัพยากรที่เกี่ยวข้องได้ สิทธิ์ใช้งานได้จนกว่าโทเค็นจะหมดอายุ

ขณะที่โทเค็นทำงานอยู่ ผู้ใช้ไม่จำเป็นต้องใช้ชื่อผู้ใช้หรือรหัสผ่านใดๆ แต่เมื่อได้รับโทเค็นใหม่ ทั้งสองจำเป็นต้องใช้

ปัจจุบันมีการใช้โทเค็นอย่างกว้างขวางในหลายสถานการณ์เนื่องจากเป็นเอนทิตีไร้สัญชาติที่มีข้อมูลการตรวจสอบสิทธิ์ทั้งหมด

การให้วิธีการแยกการสร้างโทเค็นออกจากการตรวจสอบโทเค็นช่วยให้ผู้ขายมีความยืดหยุ่นมาก

การรับรองความถูกต้องด้วยหลายปัจจัย

ตามชื่อที่แนะนำ หมายถึงการใช้ปัจจัยการตรวจสอบสิทธิ์อย่างน้อยสองปัจจัย เป็นการยกระดับความปลอดภัยที่มีให้

ไม่เหมือนกับการตรวจสอบสิทธิ์แบบสองปัจจัยที่เกี่ยวข้องกับสองปัจจัยเท่านั้น วิธีนี้อาจเกี่ยวข้องกับสอง สาม สี่ และอื่นๆ...

การใช้งานทั่วไปของวิธีนี้เกี่ยวข้องกับการใช้รหัสผ่าน หลังจากนั้นผู้ใช้จะได้รับรหัสยืนยันทางสมาร์ทโฟน ผู้ค้าที่ใช้วิธีนี้ควรมองหาผลบวกปลอมและการหยุดทำงานของเครือข่าย ซึ่งอาจกลายเป็นปัญหาใหญ่ในขณะที่ขยายขนาดอย่างรวดเร็ว

วิธีการใช้ Laravel Authentication

ส่วนนี้จะสอนคุณหลายวิธีในการตรวจสอบสิทธิ์ผู้ใช้แอปพลิเคชันของคุณ ห้องสมุดบางแห่งเช่น Jetstream, Breeze และ Socialite มีบทแนะนำการใช้งานฟรี

การรับรองความถูกต้องด้วยตนเอง

เริ่มจากการลงทะเบียนผู้ใช้และสร้างเส้นทางที่ต้องการใน routes/web.php web.php

เราจะสร้างสองเส้นทาง เส้นทางหนึ่งเพื่อดูแบบฟอร์มและอีกเส้นทางหนึ่งสำหรับลงทะเบียน:

 use App\Http\Contrllers\Auth\RegisterController; use Illuminate\Support\Facades\Route; /* Web Routes Register web routes for your app's RouteServiceProvider in a group containing the "web" middleware */ Route::get('/register', [RegisterController::class], 'create']); Route::post('/register', [RegisterController::class], 'store']);

และสร้างคอนโทรลเลอร์ที่จำเป็นสำหรับ:

 php artisan make controller Auth/RegisterController -r

ตอนนี้ปรับปรุงรหัสดังต่อไปนี้:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use illuminate\Htpp\Request; class RegisterController extends Controller { public function create() { return view('auth.register'); } public function store(Request $request) { } }

ตัวควบคุมว่างเปล่าในขณะนี้และส่งคืนมุมมองเพื่อลงทะเบียน ลองสร้างมุมมองนั้นใน resources/views/auth และเรียกมันว่า register.blade.php

เมื่อทุกอย่างพร้อมแล้ว เราควรไปที่ /register route ของเราและดูแบบฟอร์มต่อไปนี้:

 public function store(Request $request) { $credentials = $request->only('email', 'password'); if (Auth::attempt($credentials, $request->filled('remember'))) { $request->session()->regenerate(); return redirect()->intended('/'); } return back()->withErrors([ 'email' => 'The provided credentials do not match our records.', ]); }

ตอนนี้เราสามารถแสดงฟอร์มที่ผู้ใช้สามารถกรอกและรับข้อมูลได้ เราควรได้รับข้อมูลของผู้ใช้ ตรวจสอบความถูกต้อง แล้วจัดเก็บไว้ในฐานข้อมูลหากทุกอย่างปกติดี ที่นี่คุณควรใช้ธุรกรรมฐานข้อมูลเพื่อให้แน่ใจว่าข้อมูลที่คุณใส่นั้นสมบูรณ์

เราจะใช้คุณสมบัติการตรวจสอบคำขอของ Laravel เพื่อให้แน่ใจว่าจำเป็นต้องมีข้อมูลรับรองทั้งสามรายการ เราต้องแน่ใจว่าอีเมลมีรูปแบบอีเมลและไม่ซ้ำกันในตาราง users และรหัสผ่านได้รับการยืนยันและมีอักขระอย่างน้อย 8 ตัว:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Foundation\Auth\User; use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; class RegisterController extends Controller { public function store(Request $request) { /* Validation */ $request->validate([ 'name' => 'required', 'email' => 'required|email|unique:users', 'password' => 'required|confirmed|min:8', ]); /* Database Insert */ $user = User:;create([ 'name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password), ]); return back(); } public function create() { return view('auth.register'); } }

เมื่อข้อมูลที่ป้อนของเราได้รับการตรวจสอบความถูกต้องแล้ว สิ่งใดที่ขัดต่อการตรวจสอบของเราจะโยนข้อผิดพลาดที่จะแสดงในรูปแบบ:

สมมติว่าเราสร้างบัญชีผู้ใช้ในวิธี store เราต้องการเข้าสู่ระบบผู้ใช้ด้วย มีสองวิธีที่เราสามารถทำได้ เราสามารถทำได้ด้วยตนเองหรือใช้ Auth Facade

หลังจากที่ผู้ใช้เข้าสู่ระบบ เราไม่ควรกลับไปที่หน้าจอลงทะเบียน แต่กลับไปที่หน้าใหม่ เช่น แดชบอร์ดหรือหน้าแรก นั่นคือสิ่งที่เราจะทำที่นี่:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use App\Providers\RouteServiceProvider; use Illuminate\Foundation\Auth\User; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; use Illuminate\Support\Facades\Hash; class RegisterController extends Controller { public function store(Request $request) { /* Validation */ $request->validate([ 'name' => 'required', 'email' => 'required|email|unique:users', 'password' => 'required|confirmed|min:8', ]); /* Database Insert */ $user = User:;create([ 'name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password), ]); Auth::login($user): return redirect(RouteServiceProvider::HOME); } public function create() { return view('auth.register'); } }

และตอนนี้เรามีผู้ใช้ที่ลงทะเบียนและเข้าสู่ระบบ -n เราควรตรวจสอบให้แน่ใจว่าเขาสามารถออกจากระบบได้อย่างปลอดภัย

Laravel แนะนำให้เราทำให้เซสชันเป็นโมฆะและสร้างโทเค็นใหม่เพื่อความปลอดภัยหลังจากออกจากระบบ และนี่คือสิ่งที่เรากำลังจะทำ เราเริ่มต้นด้วยการสร้าง /logout เส้นทางใหม่โดยใช้วิธี destroy ของ LogoutController :

 use App\Http\Controllers\Auth\RegisterController; use App\Http\Controllers\Auth\LogoutController; use Illuminate\Support\Facades\Route; /* Web Routes Here is where you can register web routes for your application. These routes are loaded by the RrouteServiceProvider with a group which contains the "web" middleware group. Now create something great! */ Route::get('/register', [RegisterController::class, 'create']); Route::post('/register', ['RegisterController::class, 'store']); Route::post('/logout', [Logoutcontroller::class, 'destroy']) ->middleware('auth');

การออกจากระบบผ่านมิดเดิลแวร์ "auth" นั้นสำคัญมาก ผู้ใช้ไม่ควรเข้าถึงเส้นทางหากไม่ได้เข้าสู่ระบบ

ตอนนี้ สร้างตัวควบคุมเหมือนที่เราเคยทำมาก่อน:

 php artisan make:controller Auth/LogoutController -r

เราสามารถมั่นใจได้ว่าเราได้รับคำขอเป็นพารามิเตอร์ในวิธี destroy เราล็อกเอาต์ผู้ใช้ผ่านส่วนหน้าการตรวจสอบสิทธิ์ ทำให้เซสชันเป็นโมฆะ และสร้างโทเค็นใหม่ จากนั้นเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าแรก:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; class LogoutController extends Controller { public function destroy(Request $request) { Auth::logout(); $request->session()->invalidate(); $request->session()->regenerateToken(); return redirect('/'); } }

จดจำผู้ใช้

เว็บแอปพลิเคชันสมัยใหม่ส่วนใหญ่ (หากไม่ใช่ทั้งหมด) จะมีช่องทำเครื่องหมาย "จดจำฉัน" ในแบบฟอร์มการเข้าสู่ระบบ

หากเราต้องการให้ฟังก์ชัน "จดจำฉัน" เราอาจส่งค่าบูลีนเป็นอาร์กิวเมนต์ที่สองให้กับเมธอดการพยายาม

เมื่อถูกต้อง Laravel จะให้การรับรองความถูกต้องแก่ผู้ใช้อย่างไม่มีกำหนดหรือจนกว่าพวกเขาจะออกจากระบบด้วยตนเอง ตารางผู้ใช้ต้องมีสตริง remember_token (นี่คือเหตุผลที่เราสร้างโทเค็นใหม่) ซึ่งเราจะเก็บโทเค็น “remember me” ไว้

การย้ายข้อมูลเริ่มต้นสำหรับผู้ใช้มีอยู่แล้ว

ก่อนอื่น คุณต้องเพิ่มฟิลด์ จดจำฉัน ลงในแบบฟอร์มของคุณ:

และหลังจากนี้ รับข้อมูลรับรองจากคำขอและนำไปใช้กับวิธีการพยายามบนส่วนหน้าการตรวจสอบสิทธิ์

หากจำผู้ใช้ได้ เราจะเข้าสู่ระบบและเปลี่ยนเส้นทางเขาไปยังหน้าแรกของเรา มิฉะนั้นเราจะส่งข้อผิดพลาด:

 public function store(Request $request) { $credentials = $request->only('email', 'password'); if (Auth::attempt($credentials, $request->filled('remember'))) { $request->session()->regenerate(); return redirect()->intended('/'); } return back()->withErrors([ 'email' =>

การรีเซ็ตรหัสผ่าน

ปัจจุบันเว็บแอปพลิเคชันส่วนใหญ่มีวิธีให้ผู้ใช้สามารถรีเซ็ตรหัสผ่านได้

เราจะสร้างเส้นทางอื่นสำหรับรหัสผ่านที่ลืมและสร้างตัวควบคุมเหมือนที่เราทำ นอกจากนี้ เราจะเพิ่มเส้นทางสำหรับลิงก์รีเซ็ตรหัสผ่านที่มีโทเค็นสำหรับกระบวนการทั้งหมด:

 Route::post('/forgot-password', [ForgotPasswordLinkController::class, 'store']); Route::post('/forgot-password/{token}', [ForgotPasswordController::class, 'reset']);

ภายในวิธีการจัดเก็บ เราจะรับอีเมลจากคำขอและตรวจสอบความถูกต้องเช่นเดียวกับที่เราทำ

หลังจากนี้ เราสามารถใช้เมธอด sendResetLink จากซุ้มรหัสผ่านได้

และเพื่อเป็นการตอบกลับ เราต้องการคืนสถานะหากการส่งลิงก์สำเร็จหรือมีข้อผิดพลาดอย่างอื่น:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Password; class ForgotPasswordLinkController extends Controller { public function store(Request $request) { $request->validate([ 'email' => 'required|email', ]); $status = Password::sendResetLink( $request->only('email'); ); return $status === Password::RESET_LINK_SENT ? back()->with('status', __($status)) : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]); } }

เมื่อลิงก์รีเซ็ตถูกส่งไปยังอีเมลของผู้ใช้แล้ว เราควรดูแลเหตุผลของสิ่งที่เกิดขึ้นหลังจากนั้น

เราจะได้รับโทเค็น อีเมล และรหัสผ่านใหม่ในคำขอและตรวจสอบความถูกต้อง

หลังจากนี้ เราสามารถใช้วิธีรีเซ็ตจากส่วนหน้าของรหัสผ่านเพื่อให้ Laravel ดูแลทุกอย่างเบื้องหลัง

เราจะแฮชรหัสผ่านเสมอเพื่อรักษาความปลอดภัย

ในตอนท้าย เราจะตรวจสอบว่ามีการรีเซ็ตรหัสผ่านหรือไม่ และหากรีเซ็ตแล้ว เราจะเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าจอเข้าสู่ระบบพร้อมข้อความแสดงความสำเร็จ มิฉะนั้น เราจะแสดงข้อผิดพลาดที่ไม่สามารถรีเซ็ตได้:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; use Illuminate\Support\Facades\Password; use Illuminate\Support\Str; class ForgotPasswordController extends Controller { public function store(Request $request) { $request->validate([ 'token' => 'required', 'email' => 'required|email', 'password' => 'required|string|confirmed|min:8', ]); $status = Password::reset( $request->only('email', 'password', 'password_confirmation', 'token'), function ($user) use ($request) { $user->forceFill( 'password' => Hash::make($request->password), 'remember_token' => Str::random(60) ])->save(); } ); return $status == Password::PASSWORD_RESET ? redirect()->route('login')->with('status', __($status)) : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]); } }

ลาราเวล บรีซ

Laravel Breeze เป็นการนำคุณลักษณะการตรวจสอบความถูกต้องของ Laravel ไปใช้อย่างง่าย: การเข้าสู่ระบบ การลงทะเบียน การรีเซ็ตรหัสผ่าน การยืนยันอีเมล และการยืนยันรหัสผ่าน คุณสามารถใช้เพื่อใช้การรับรองความถูกต้องในแอปพลิเคชัน Laravel ใหม่ของคุณ

การติดตั้งและตั้งค่า

หลังจากสร้างแอปพลิเคชัน Laravel แล้ว สิ่งที่คุณต้องทำคือกำหนดค่าฐานข้อมูล เรียกใช้การย้ายข้อมูล และติดตั้งแพ็คเกจ laravel/breeze ผ่านตัวเขียน:

 composer require laravel/breeze –dev

หลังจากนี้ ให้รันสิ่งต่อไปนี้:

 php artisan breeze:install

ซึ่งจะเผยแพร่มุมมองการรับรองความถูกต้อง เส้นทาง ตัวควบคุม และทรัพยากรอื่นๆ ที่ใช้ หลังจากขั้นตอนนี้ คุณจะสามารถควบคุมทุกสิ่งที่ Breeze มอบให้ได้อย่างสมบูรณ์

ตอนนี้เราต้องแสดงแอปพลิเคชันของเราไปที่ส่วนหน้า ดังนั้นเราจะติดตั้งการอ้างอิง JS ของเรา (ซึ่งจะใช้ @vite):

 npm install

:

 npm run dev

หลังจากนี้ ลิงก์เข้าสู่ระบบและลงทะเบียนควรอยู่ในหน้าแรกของคุณ และทุกอย่างจะทำงานได้อย่างราบรื่น

Laravel Jetstream

Laravel Jetstream ขยาย Laravel Breeze ด้วยคุณสมบัติที่มีประโยชน์และสแต็กส่วนหน้าอื่นๆ

โดยจะให้การเข้าสู่ระบบ การลงทะเบียน การยืนยันอีเมล การยืนยันตัวตนแบบสองปัจจัย การจัดการเซสชัน การรองรับ API ผ่าน Sanctum และการจัดการทีมเพิ่มเติม

คุณต้องเลือกระหว่าง Livewire และ Inertia ที่ส่วนหน้าเมื่อติดตั้ง Jetstream ในส่วนแบ็กเอนด์ จะใช้ Laravel Fortify ซึ่งเป็นแบ็กเอนด์การตรวจสอบสิทธิ์แบบ "หัวขาด" ส่วนหน้าสำหรับ Laravel

การติดตั้งและตั้งค่า

เราจะติดตั้งผ่านผู้แต่งในโครงการ Laravel ของเรา:

 composer require laravel/jetstream

หลังจากนี้ เราจะเรียกใช้คำสั่ง php artisan jetstream:install [stack] ซึ่งยอมรับอาร์กิวเมนต์ [stack] Livewire หรือ Inertia คุณสามารถส่งตัวเลือก –team เพื่อเปิดใช้งานคุณสมบัติทีมได้

นอกจากนี้ยังจะติดตั้ง Pest PHP สำหรับการทดสอบ

และสุดท้าย เราต้องเรนเดอร์ส่วนหน้าของแอปพลิเคชันของเราโดยใช้สิ่งต่อไปนี้:

 npm install npm run dev

Laravel เสริมความแข็งแกร่ง

Laravel Fortify เป็นการใช้งานการตรวจสอบสิทธิ์แบ็กเอนด์ที่ไม่เชื่อเรื่องพระเจ้าส่วนหน้า คุณไม่จำเป็นต้องใช้ Laravel Fortify เพื่อใช้คุณลักษณะการรับรองความถูกต้องของ Laravel

นอกจากนี้ยังใช้ในชุดเริ่มต้นเช่น Breeze และ Jetstream คุณยังสามารถใช้ Fortify แบบสแตนด์อโลน ซึ่งเป็นเพียงการใช้งานแบ็กเอนด์ หากคุณใช้แบบสแตนด์อโลน ส่วนหน้าของคุณจะต้องเรียกเส้นทาง Fortify

การติดตั้งและตั้งค่า

เราสามารถติดตั้ง Fortify ผ่านทางผู้แต่ง:

 composer require laravel/fortify

ตอนนี้เราต้องเผยแพร่แหล่งข้อมูลของ Fortify:

 php artisan vendor:publish –provider="Laravel\Fortify\FortifyServiceProvider"

หลังจากนี้ เราจะสร้างไดเร็กทอรี app/Actions ใหม่ นอกเหนือจาก FortifyServiceProvider ใหม่ ไฟล์คอนฟิกูเรชัน และการย้ายฐานข้อมูล

สุดท้ายให้เรียกใช้:

 php artisan migrate

หรือ:

 php artisan migrate:fresh

และ Fortify ของคุณพร้อมใช้งานแล้ว

Laravel Socialite

Laravel มีคุณสมบัติการตรวจสอบผู้ใช้ที่ใช้ OAuth ที่ตรงไปตรงมา รองรับการเข้าสู่ระบบโซเชียลผ่าน Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub และ GitLab

การติดตั้ง

เราสามารถติดตั้งผ่านผู้แต่ง:

 composer require laravel/socialite

การตั้งค่าและการใช้งาน

หลังจากที่เราติดตั้งแล้ว เราต้องเพิ่มข้อมูลรับรองสำหรับผู้ให้บริการ OAuth ที่แอปพลิเคชันของเราใช้ เราจะเพิ่มใน config/services.php สำหรับแต่ละบริการ

ในการกำหนดค่า เราควรจับคู่คีย์กับบริการก่อนหน้า บางส่วนของคีย์เหล่านี้รวมถึง:

• เฟสบุ๊ค
• ทวิตเตอร์ (สำหรับ OAuth 1.0)
• twitter-oauth-2 (สำหรับ OAuth 2.0)
• เชื่อมโยงใน
• Google
• GitHub
• กิทแล็บ
• บิตบัคเก็ต

การกำหนดค่าบริการเดียวอาจมีลักษณะดังนี้:

 'google' => [ 'client_id' => env("GOOGLE_CLIENT_ID"), 'client_secret' => env("GOOGLE_CLIENT_SECRET"), 'redirect' => "http://example.com/callback-url", ],

รับรองผู้ใช้

สำหรับการดำเนินการนี้ เราต้องการสองเส้นทาง เส้นทางหนึ่งสำหรับเปลี่ยนเส้นทางผู้ใช้ไปยังผู้ให้บริการ OAuth:

 use Laravel\Socialite\Facades\Sociliate; Route::get('/auth/redirect', function () { return Socialite:;driver('google')->redirect(); });

และอีกอันสำหรับการโทรกลับจากผู้ให้บริการหลังจากการตรวจสอบสิทธิ์:

 use Laravel\Socialite\Facades\Socialite; Route:;get('/auht/callback', function () { $user = Socialite:;driver('google')->user(); // Getting the user data $user->token; });

Socialite จัดเตรียมวิธีการเปลี่ยนเส้นทาง และส่วนหน้าเปลี่ยนเส้นทางผู้ใช้ไปยังผู้ให้บริการ OAuth ในขณะที่วิธีการของผู้ใช้ตรวจสอบคำขอที่เข้ามาและดึงข้อมูลผู้ใช้

หลังจากที่เราได้รับผู้ใช้แล้ว เราต้องตรวจสอบว่ามีอยู่ในฐานข้อมูลของเราหรือไม่และรับรองความถูกต้อง หากไม่มี เราจะสร้างบันทึกใหม่เพื่อเป็นตัวแทนของผู้ใช้:

 use App\Models\User; use Illuminate\Support\Facades\Auth; use Laravel\Socialite\Facades\Socialite; Route::get('/auth/callback', function () { /* Get the user */ $googleUser = Socialite::driver('google')->user(); /* Create the user if it does not exist Update the user if it exists Check for google_id in database */ $user = User::updateOrCreate([ 'google_id' => $googleUser->id, ], [ 'name' => $googleUser->name, 'email' => $googleUser->email, 'google_token' => $googleUser->token, 'google_refresh_token' => $googleUser->refreshToken, ]); /* Authenticates the user using the Auth facade */ Auth::login($user); return redirect('/dashboard'); });

หากเราต้องการจำกัดขอบเขตการเข้าถึงของผู้ใช้ เราอาจใช้วิธี scopes ซึ่งเราจะรวมไว้กับคำขอการตรวจสอบสิทธิ์ สิ่งนี้จะรวมขอบเขตที่ระบุก่อนหน้านี้ทั้งหมดเข้ากับขอบเขตที่ระบุ

อีกทางเลือกหนึ่งคือการใช้เมธอด setScopes ที่เขียนทับขอบเขตที่มีอยู่ทั้งหมด:

 use Laravel\Socialite\Facades\Socialite; return Socialite::driver('google') ->scopes(['read:user', 'write:user', 'public_repo']) ->redirect(); return Socialite::driver('google') ->setScopes(['read:user', 'public_repo') ->redirect();

ตอนนี้เรารู้ทุกอย่างแล้วและวิธีรับผู้ใช้หลังจากการโทรกลับ มาดูข้อมูลบางส่วนที่เราจะได้รับจากข้อมูลดังกล่าว

ผู้ใช้ OAuth1 มี token และ tokenSecret :

 $user = Socialite::driver('google')->user(); $token = $user->token; $tokenSecret = $user->tokenSecret;

OAuth2 ให้ token refreshToken และ expiresIn :

 $user = Socialite::driver('google')->user(); $token = $user->token; $refreshToken = $user->refreshToken; $expiresIn = $user->expiresIn;

ทั้ง OAuth1 และ OAuth2 มี getId , getNickname , getName , getEmail และ getAvatar :

 $user = Socialite::driver('google')->user(); $user->getId(); $user->getNickName(); $user->getName(); $user->getEmail(); $user->getAvatar();

และถ้าเราต้องการรับรายละเอียดผู้ใช้จากโทเค็น (OAuth 2) หรือโทเค็นและความลับ (OAuth 1) sanctum มีสองวิธีสำหรับสิ่งนี้: userFromToken และ userFromTokenAndSecret :

 use Laravel\Socialite\Facades\Socialite; $user = Socialite:;driver('google')->userFromToken($token); $user = Socialite::driver('twitter')->userFromTokenAndSecret($token, $secret);

สถานที่ศักดิ์สิทธิ์ Laravel

Laravel Sanctum เป็นระบบยืนยันตัวตนแบบเบาสำหรับ SPA (Single Page Applications) และแอพมือถือ ช่วยให้ผู้ใช้สร้างโทเค็น API หลายรายการด้วยขอบเขตเฉพาะ ขอบเขตเหล่านี้ระบุการดำเนินการที่อนุญาตโดยโทเค็น

การใช้งาน

สามารถใช้ Sanctum เพื่อออกโทเค็น API ให้กับผู้ใช้โดยไม่ต้องใช้ OAuth ที่ซับซ้อน โทเค็นเหล่านั้นมักมีเวลาหมดอายุนาน เช่น เป็นปี แต่ผู้ใช้อาจเพิกถอนและสร้างใหม่ได้ทุกเมื่อ

การติดตั้งและตั้งค่า

เราสามารถติดตั้งผ่านนักแต่งเพลง:

 composer require laravel/sanctum

และเราต้องเผยแพร่ไฟล์การกำหนดค่าและการโยกย้าย:

 php artisan vendor:publish –provider="Laravel\Sanctum\SanctumServiceProvider"

เมื่อเราสร้างไฟล์การย้ายข้อมูลใหม่แล้ว เราต้องย้ายข้อมูลเหล่านี้:

 php artisan migrate </code> or <code> php artisan migrate:fresh

วิธีออกโทเค็น API

ก่อนออกโทเค็น โมเดลผู้ใช้ของเราควรใช้คุณลักษณะ Laravel\Sanctum\HasApiTokens :

 use Laravel\Sanctum\HasApiTokens; class User extends Authenticable { use HasApiTokens; }

เมื่อเรามีผู้ใช้ เราสามารถออกโทเค็นได้โดยการเรียกใช้เมธอด createToken ซึ่งส่งคืนอินสแตนซ์ Laravel\Sanctum\NewAccessToken

เราสามารถเรียกใช้เมธอด plainTextToken บนอินสแตนซ์ NewAccessToken เพื่อดูค่าข้อความธรรมดา SHA-256 ของโทเค็น

เคล็ดลับและแนวทางปฏิบัติที่ดีที่สุดสำหรับการรับรองความถูกต้องของ Laravel

ทำให้เซสชันไม่ถูกต้องบนอุปกรณ์อื่น

ดังที่เราได้กล่าวไปแล้วก่อนหน้านี้ การทำให้เซสชันเป็นโมฆะมีความสำคัญอย่างยิ่งเมื่อผู้ใช้ออกจากระบบ แต่ควรเป็นตัวเลือกสำหรับอุปกรณ์ทุกเครื่องที่เป็นเจ้าของด้วย

คุณลักษณะนี้มักใช้เมื่อผู้ใช้เปลี่ยนหรืออัปเดตรหัสผ่าน และเราต้องการทำให้เซสชันของผู้ใช้เป็นโมฆะจากอุปกรณ์อื่น

มาพร้อมกับ Auth Facade สิ่งนี้ทำให้สำเร็จได้ง่าย เมื่อพิจารณาว่าเส้นทางที่เราใช้มีมิดเดิลแวร์ auth และ auth.session middleware เราสามารถใช้วิธีคง logoutOtherDevices ของส่วนหน้า:

 Route::get('/logout', [LogoutController::class, 'invoke']) ->middleware(['auth', 'auth.session']);

 use Illuminate\Support\Facades\Auth; Auth::logoutOtherDevices($password);

การกำหนดค่าด้วย Auth::route()

วิธีการกำหนดเส้นทางของ Auth Facade เป็นเพียงตัวช่วยในการสร้างเส้นทางทั้งหมดที่จำเป็นสำหรับการตรวจสอบผู้ใช้

เส้นทางประกอบด้วยการเข้าสู่ระบบ (รับ โพสต์) ออกจากระบบ (โพสต์) ลงทะเบียน (รับ โพสต์) และรีเซ็ตรหัสผ่าน/อีเมล (รับ โพสต์)

เมื่อคุณเรียกเมธอดบนส่วนหน้า มันทำสิ่งต่อไปนี้:

 public static fucntion routes(array $options = []) { if (!static::$app->providerIsLoaded(UiServiceProvider::class)) { throw new RuntimeException('In order to use the Auth:;routes() method, please install the laravel/ui package.'); } static::$app->make('router')->auth($options); }

เราสนใจว่าจะเกิดอะไรขึ้นเมื่อมีการเรียกใช้เมธอดแบบสแตติกบนเราเตอร์ อาจเป็นเรื่องยุ่งยากเนื่องจากการทำงานของส่วนหน้า แต่วิธีการต่อไปนี้เรียกว่าเป็นดังนี้:

 /** Register the typical authentication routes for an application. @param array $options @return void */ public function auth(array $options = []) { // Authentication Routes... $this->get('login', 'Auth\[email protected]')->name('login'); $this->post('login', 'Auth\[email protected]'); $this->post('logout', 'Auth\[email protected]')->name('logout'); // Registration Routes... if ($options['register'] ?? true) { $this->get('register', 'Auth\[email protected]')->name('register'); $this->post('register', 'Auth\[email protected]'); } // Password Reset Routes... if ($options['reset'] ?? true) { $this->resetPassword(); } // Email Verification Routes... if ($options['verify'] ?? false) { $this->emailVerification(); } }

โดยค่าเริ่มต้น จะสร้างเส้นทางทั้งหมดนอกเหนือจากการยืนยันอีเมล เราจะมีเส้นทางการเข้าสู่ระบบและออกจากระบบเสมอ แต่เส้นทางอื่น ๆ เราสามารถควบคุมได้ผ่านอาร์เรย์ตัวเลือก

หากเราต้องการมีเพียงการเข้าสู่ระบบ/ออกจากระบบและลงทะเบียน เราสามารถส่งอาร์เรย์ตัวเลือกต่อไปนี้:

 $options = ["register" => true, "reset" => false, "verify" => false];

ปกป้องเส้นทางและ Custom Guards

เราต้องการให้แน่ใจว่าเส้นทางบางเส้นทางสามารถเข้าถึงได้โดยผู้ใช้ที่รับรองความถูกต้องเท่านั้น และสามารถทำได้อย่างรวดเร็วโดยการเพิ่มการเรียกใช้เมธอดมิดเดิลแวร์บนส่วนหน้าของรูทหรือการผูกมัดเมธอดมิดเดิลแวร์บนนั้น:

 Route::middleware('auth')->get('/user', function (Request $request) { return $request->user(); }); Route::get('/user', function (Request $request) { return $request->user(); })->middleware('auth');

ตัวป้องกันนี้ทำให้แน่ใจว่าคำขอที่เข้ามานั้นได้รับการรับรองความถูกต้อง

การยืนยันรหัสผ่าน

เพื่อเพิ่มความปลอดภัยของเว็บไซต์ คุณมักต้องการยืนยันรหัสผ่านของผู้ใช้ก่อนที่จะดำเนินการอื่นๆ ต่อไป

เราต้องกำหนดเส้นทางจากมุมมองยืนยันรหัสผ่านเพื่อจัดการกับคำขอ มันจะตรวจสอบและเปลี่ยนเส้นทางผู้ใช้ไปยังปลายทางที่ต้องการ ในขณะเดียวกัน เราจะตรวจสอบให้แน่ใจว่ารหัสผ่านของเราได้รับการยืนยันในเซสชั่น ตามค่าเริ่มต้น รหัสผ่านจะต้องได้รับการยืนยันใหม่ทุก ๆ สามชั่วโมง แต่สามารถเปลี่ยนได้ในไฟล์กำหนดค่าที่ config/auth.php :

 use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; use Illuminate\Support\Facades\Redirect; Route::post('/confirm-password', function (Request $request) { if (!Hash::check($request->password, $request->user()->password)) { return back()->withErrors([ 'password' => ['The provided password does not match our records.'] ]); } $request->session()->passwordConfirmed(); return redirect()->intended(); })->middleware(['auth']);

สัญญาที่แท้จริง

สัญญาที่ตรวจสอบได้ซึ่งอยู่ที่ Illuminate\Contracts\Auth กำหนดพิมพ์เขียวของสิ่งที่ UserProvider Facade ควรนำไปใช้:

 namespace Illuminate\Contracts\Auth; interface Authenticable { public function getAuthIdentifierName(); public function getAuthIdentifier(); public function getAuthPassord(); public function getRememberToken(); public function setRememberToken($value); public function getrememberTokenName(); }

อินเทอร์เฟซช่วยให้ระบบการตรวจสอบความถูกต้องสามารถทำงานร่วมกับคลาส "ผู้ใช้" ใดๆ ที่นำระบบไปใช้ได้

สิ่งนี้จะเก็บไว้โดยไม่คำนึงว่าจะใช้ ORM หรือเลเยอร์หน่วยเก็บข้อมูลใด ตามค่าเริ่มต้น Laravel มี App\Models\User ที่ใช้อินเทอร์เฟซนี้ และสิ่งนี้สามารถเห็นได้ในไฟล์การกำหนดค่า:

 return [ 'providers' => [ 'users' => [ 'driver' => 'eloquent', 'model' => App\Models\User::class, ], ], ];

เหตุการณ์การรับรองความถูกต้อง

มีกิจกรรมมากมายที่จัดส่งในระหว่างกระบวนการตรวจสอบสิทธิ์ทั้งหมด

คุณสามารถแนบผู้ฟังเข้ากับเหตุการณ์เหล่านั้นในของคุณ ทั้งนี้ขึ้นอยู่กับเป้าหมายของคุณ ผู้ ให้ EventServiceProvider

สร้างผู้ใช้ใหม่อย่างรวดเร็ว

การสร้างผู้ใช้ใหม่สามารถทำได้อย่างรวดเร็วผ่าน App\User :

 $user = new App\User(); $user->password = Hash::make('strong_password'); $user->email = '[email protected]'; $user->name = 'Username'; $user->save();

หรือผ่านวิธีการสร้างสแตติกบนส่วนหน้าผู้ใช้:

 User::create([ 'password' => Hash::make('strong-password'), 'email' => '[email protected]', 'name' => 'username' ]);

สรุป

ระบบนิเวศของ Laravel มีชุดเครื่องมือเริ่มต้นมากมายเพื่อให้แอปของคุณพร้อมใช้งานกับระบบการตรวจสอบสิทธิ์ เช่น Breeze และ Jetstream สามารถปรับแต่งได้สูงเนื่องจากโค้ดถูกสร้างขึ้นจากฝั่งของเรา และเราสามารถแก้ไขได้มากเท่าที่เราต้องการ โดยใช้เป็นพิมพ์เขียวหากจำเป็น

มีข้อกังวลด้านความปลอดภัยมากมายเกี่ยวกับการพิสูจน์ตัวตนและความซับซ้อน แต่สิ่งเหล่านี้สามารถแก้ไขได้อย่างง่ายดายผ่านเครื่องมือที่ Laravel มอบให้ เครื่องมือเหล่านี้ปรับแต่งได้สูงและใช้งานง่าย

ปรับใช้แอป Laravel ของคุณอย่างรวดเร็วและมีประสิทธิภาพด้วยบริการโฮสติ้ง Laravel ที่รวดเร็วของเรา ดูการใช้งานแอปของคุณด้วยการทดลองใช้ฟรี