Panduan Lengkap Untuk Otentikasi Laravel

Otentikasi adalah salah satu fitur aplikasi web yang paling penting dan penting. Kerangka kerja web seperti Laravel menyediakan banyak cara bagi pengguna untuk mengautentikasi.

Anda dapat mengimplementasikan fitur autentikasi Laravel dengan cepat dan aman. Namun, menerapkan fitur autentikasi ini dengan buruk dapat berisiko, karena pihak jahat dapat mengeksploitasinya.

Panduan ini akan mengajarkan Anda semua yang perlu Anda ketahui untuk memulai dengan metode autentikasi Laravel pilihan Anda.

Baca terus!

Pengantar Otentikasi Laravel

Laravel memperkenalkan modul yang terdiri dari "penjaga" dan "penyedia". Penjaga menentukan autentikasi pengguna untuk setiap permintaan, dan penyedia menentukan pengambilan pengguna dari penyimpanan persisten (misalnya database MySQL).

Kami mendefinisikan parameter autentikasi kami dalam file bernama config/auth.php . Ini mencakup beberapa opsi untuk men-tweak dan memodifikasi perilaku otentikasi Laravel.

Pertama, Anda harus menentukan default autentikasi. Opsi ini mengontrol opsi "penjaga" autentikasi default dan pengaturan ulang kata sandi aplikasi Anda. Anda dapat mengubah default ini sesuai kebutuhan, tetapi ini adalah awal yang sempurna untuk sebagian besar aplikasi.

Selanjutnya, Anda menentukan penjaga autentikasi untuk aplikasi Anda. Di sini, konfigurasi default kami menggunakan penyimpanan sesi dan penyedia pengguna Eloquent. Semua driver autentikasi memiliki penyedia pengguna.

 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, ];

Nanti, kami memastikan semua driver autentikasi memiliki penyedia pengguna. Ini menentukan bagaimana pengguna diambil dari database Anda atau mekanisme penyimpanan lain untuk mempertahankan data pengguna Anda. Anda dapat mengonfigurasi banyak sumber yang mewakili setiap model atau tabel jika Anda memiliki banyak tabel atau model pengguna. Sumber-sumber ini dapat ditugaskan ke penjaga autentikasi tambahan yang telah Anda tetapkan.

Pengguna mungkin juga ingin mengatur ulang kata sandi mereka. Untuk ini, Anda dapat menentukan beberapa konfigurasi pengaturan ulang kata sandi jika Anda memiliki lebih dari satu tabel pengguna atau model dalam aplikasi dan menginginkan pengaturan terpisah berdasarkan jenis pengguna tertentu. Waktu kedaluwarsa adalah jumlah menit setiap token reset akan valid. Fitur keamanan ini membuat token berumur pendek, sehingga mereka memiliki lebih sedikit waktu untuk ditebak. Anda dapat mengubah ini sesuai kebutuhan.

Pada akhirnya, Anda harus menentukan waktu sebelum waktu konfirmasi kata sandi habis, dan pengguna diminta untuk memasukkan kembali kata sandinya melalui layar konfirmasi. Secara default, batas waktu berlangsung selama tiga jam.

Jenis Metode Otentikasi Laravel

Tidak ada cara sempurna untuk mengautentikasi setiap skenario, tetapi mengetahuinya akan membantu Anda membuat keputusan yang lebih baik. Ini dan bagaimana Laravel berkembang dengan fitur-fitur baru di Laravel 9. Hal ini membuat pekerjaan kami sebagai pengembang jauh lebih mudah saat beralih mode autentikasi.

Otentikasi Berbasis Kata Sandi

Sebagai cara yang belum sempurna untuk mengautentikasi pengguna, ini masih digunakan oleh ribuan organisasi, tetapi mengingat perkembangan saat ini, ini jelas sudah ketinggalan zaman.

Vendor harus menerapkan implementasi kata sandi yang rumit sambil memastikan gesekan minimal bagi pengguna akhir.

Ini bekerja sangat mudah, pengguna memasukkan nama dan kata sandi, dan jika di Database ada kecocokan antara keduanya, server memutuskan untuk mengautentikasi permintaan dan membiarkan pengguna mengakses sumber daya untuk waktu yang telah ditentukan.

Otentikasi Berbasis Token

Metodologi ini digunakan di mana pengguna diberikan token unik setelah verifikasi.

Memiliki token ini, sekarang pengguna dapat mengakses sumber daya yang relevan. Hak istimewa aktif hingga token kedaluwarsa.

Saat token aktif, pengguna tidak harus menggunakan nama pengguna atau kata sandi apa pun, tetapi setelah mengambil token baru, keduanya diperlukan.

Token banyak digunakan dalam berbagai skenario saat ini karena merupakan entitas tanpa kewarganegaraan yang berisi semua data autentikasi.

Menyediakan cara untuk memisahkan pembuatan token dari verifikasi token memberi banyak fleksibilitas kepada vendor.

Otentikasi Multi-Faktor

Seperti namanya, itu berarti menggunakan setidaknya dua faktor otentikasi, meningkatkan keamanan yang disediakannya.

Tidak seperti autentikasi dua faktor yang hanya melibatkan dua faktor, metode ini dapat melibatkan dua, tiga, empat, dan lainnya…

Implementasi khas metode ini melibatkan penggunaan kata sandi, setelah itu pengguna dikirimi kode verifikasi di ponsel cerdas mereka. Vendor yang menerapkan metode ini harus mencari positif palsu dan pemadaman jaringan, yang dapat menjadi masalah besar saat meningkatkan dengan cepat.

Bagaimana Menerapkan Otentikasi Laravel

Bagian ini akan mengajari Anda berbagai cara untuk mengautentikasi pengguna aplikasi Anda. Beberapa perpustakaan seperti Jetstream, Breeze, dan Socialite memiliki tutorial gratis tentang cara menggunakannya.

Otentikasi Manual

Dimulai dengan mendaftarkan pengguna dan membuat rute yang dibutuhkan di routes/web.php .

Kami akan membuat dua rute, satu untuk melihat formulir dan satu lagi untuk mendaftar:

 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']);

Dan buat pengontrol yang diperlukan untuk itu:

 php artisan make controller Auth/RegisterController -r

Sekarang perbarui kode sebagai berikut:

 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) { } }

Pengontrol sekarang kosong dan mengembalikan tampilan untuk didaftarkan. Mari buat tampilan itu di resources/views/auth dan beri nama register.blade.php .

Sekarang dengan semua yang ada, kita harus mengunjungi rute /register kita dan melihat form berikut:

 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.', ]); }

Sekarang kita bisa menampilkan formulir yang bisa diisi pengguna dan mendapatkan datanya, kita harus mendapatkan data pengguna, memvalidasinya, lalu menyimpannya di database jika semuanya baik-baik saja. Di sini Anda harus menggunakan transaksi database untuk memastikan data yang Anda masukkan sudah lengkap.

Kami akan menggunakan fitur validasi permintaan Laravel untuk memastikan bahwa ketiga kredensial tersebut diperlukan. Kami harus memastikan email memiliki format email dan unik di tabel users dan kata sandi dikonfirmasi dan memiliki minimal 8 karakter:

 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'); } }

Sekarang input kita divalidasi, apa pun yang bertentangan dengan validasi kita akan menimbulkan kesalahan yang akan ditampilkan dalam bentuk:

Dengan asumsi kami telah membuat akun pengguna dalam metode store , kami juga ingin memasukkan pengguna. Ada dua cara yang bisa kita lakukan. Kita bisa melakukannya secara manual atau menggunakan fasad Auth .

Setelah pengguna masuk, kita tidak boleh mengembalikannya ke layar Daftar melainkan ke halaman baru, seperti dasbor atau beranda. Itulah yang akan kita lakukan di sini:

 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'); } }

Dan sekarang setelah kita memiliki pengguna yang terdaftar dan masuk -n , kita harus memastikan dia dapat keluar dengan aman.

Laravel menyarankan agar kami membatalkan sesi dan membuat ulang token untuk keamanan setelah logout. Dan inilah tepatnya yang akan kita lakukan. Kita mulai dengan membuat rute /logout baru menggunakan metode 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');

Melewati logout melalui middleware "auth" sangatlah penting. Pengguna seharusnya tidak dapat mengakses rute jika mereka tidak masuk.

Sekarang, buat pengontrol seperti yang kita lakukan sebelumnya:

 php artisan make:controller Auth/LogoutController -r

Kami dapat memastikan bahwa kami mendapatkan permintaan sebagai parameter dalam metode destroy . Kami mengeluarkan pengguna melalui fasad Auth, membatalkan sesi dan, membuat ulang token, lalu mengarahkan pengguna ke beranda:

 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('/'); } }

Mengingat Pengguna

Sebagian besar, jika tidak semua, aplikasi web modern menyediakan kotak centang "ingat saya" di formulir login mereka.

Jika kita ingin menyediakan fungsionalitas "ingat saya", kita dapat meneruskan nilai boolean sebagai argumen kedua ke metode percobaan.

Jika valid, Laravel akan membuat pengguna diautentikasi tanpa batas waktu atau hingga mereka keluar secara manual. Tabel pengguna harus menyertakan kolom string remember_token (inilah sebabnya kami membuat ulang token), tempat kami akan menyimpan token "ingat saya".

Migrasi default untuk pengguna sudah menyertakannya.

Hal pertama yang pertama, Anda harus menambahkan bidang Ingat Saya ke formulir Anda:

Dan setelah ini, dapatkan kredensial dari permintaan dan gunakan pada metode percobaan di fasad Auth.

Jika pengguna harus diingat, kami akan memasukkannya dan mengarahkannya ke beranda kami. Jika tidak, kami akan melempar kesalahan:

 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' =>

Mengatur Ulang Kata Sandi

Sebagian besar aplikasi web saat ini menyediakan cara bagi pengguna untuk menyetel ulang kata sandi mereka.

Kami akan membuat rute lain untuk kata sandi yang terlupa dan membuat pengontrol seperti yang kami lakukan. Selain itu, kami akan menambahkan rute untuk tautan setel ulang kata sandi yang berisi token untuk seluruh proses:

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

Di dalam metode store, kami akan mengambil email dari permintaan dan memvalidasinya seperti yang kami lakukan.

Setelah ini, kita dapat menggunakan metode sendResetLink dari fasad kata sandi.

Dan kemudian, sebagai tanggapan, kami ingin mengembalikan status jika berhasil mengirimkan tautan atau kesalahan sebaliknya:

 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)]); } }

Sekarang tautan setel ulang telah dikirim ke email pengguna, kita harus menjaga logika tentang apa yang terjadi setelah itu.

Kami akan mendapatkan token, email, dan kata sandi baru dalam permintaan dan memvalidasinya.

Setelah ini, kita dapat menggunakan metode reset dari fasad kata sandi untuk membiarkan Laravel menangani semua hal lain di balik layar.

Kami akan selalu melakukan hash pada kata sandi agar tetap aman.

Pada akhirnya, kami akan memeriksa apakah kata sandi telah disetel ulang, dan jika ya, kami akan mengarahkan pengguna ke layar login dengan pesan sukses. Jika tidak, kami menampilkan kesalahan yang tidak dapat diatur ulang:

 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)]); } }

Angin Laravel

Laravel Breeze adalah implementasi sederhana dari fitur autentikasi Laravel: login, registrasi, reset kata sandi, verifikasi email, dan konfirmasi kata sandi. Anda dapat menggunakannya untuk mengimplementasikan autentikasi di aplikasi Laravel baru Anda.

Instalasi dan Pengaturan

Setelah membuat aplikasi Laravel Anda, yang harus Anda lakukan adalah mengonfigurasi database Anda, menjalankan migrasi Anda, dan menginstal paket laravel/breeze melalui komposer:

 composer require laravel/breeze –dev

Setelah ini, jalankan yang berikut ini:

 php artisan breeze:install

Yang akan menerbitkan tampilan autentikasi, rute, pengontrol, dan sumber daya lain yang digunakannya. Setelah langkah ini, Anda memiliki kendali penuh atas semua yang disediakan Breeze.

Sekarang kita harus merender aplikasi kita ke frontend, jadi kita akan menginstal dependensi JS kita (yang akan menggunakan @vite):

 npm install

:

 npm run dev

Setelah ini, tautan masuk dan daftar harus ada di beranda Anda, dan semuanya akan berfungsi dengan lancar.

Laravel Jetstream

Laravel Jetstream memperluas Laravel Breeze dengan fitur yang bermanfaat dan tumpukan frontend lainnya.

Ini menyediakan login, pendaftaran, verifikasi email, otentikasi dua faktor, manajemen sesi, dukungan API melalui Sanctum, dan manajemen tim opsional.

Anda harus memilih antara Livewire dan Inertia di frontend saat memasang Jetstream. Di backend, ia menggunakan Laravel Fortify, yang merupakan agnostik frontend, backend autentikasi "tanpa kepala" untuk Laravel.

Instalasi dan Pengaturan

Kami akan menginstalnya melalui komposer di Proyek Laravel kami:

 composer require laravel/jetstream

Setelah ini, kita akan menjalankan perintah php artisan jetstream:install [stack] , yang menerima [stack] argument Livewire atau Inertia . Anda dapat melewati opsi –team untuk mengaktifkan fitur tim.

Ini juga akan menginstal Pest PHP untuk pengujian.

Dan terakhir, kita harus merender frontend aplikasi kita menggunakan yang berikut ini:

 npm install npm run dev

Perkuat Laravel

Laravel Fortify adalah implementasi autentikasi backend yang agnostik frontend. Anda tidak harus menggunakan Laravel Fortify untuk mengimplementasikan fitur autentikasi Laravel.

Ini juga digunakan dalam starter kit seperti Breeze dan Jetstream. Anda juga dapat menggunakan Fortify mandiri, yang hanya merupakan implementasi backend. Jika Anda menggunakannya sendiri, frontend Anda harus memanggil rute Fortify.

Instalasi dan Pengaturan

Kita dapat menginstal Fortify melalui composer:

 composer require laravel/fortify

Sekarang kita harus memublikasikan sumber daya Fortify:

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

Setelah ini, kita akan membuat direktori app/Actions baru selain FortifyServiceProvider , file konfigurasi, dan migrasi database baru.

Terakhir, jalankan:

 php artisan migrate

Atau:

 php artisan migrate:fresh

Dan Fortify Anda siap digunakan.

Sosialita Laravel

Laravel menyertakan fitur autentikasi pengguna berbasis OAuth langsung. Ini mendukung login sosial melalui Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub, dan GitLab.

Instalasi

Kita dapat menginstalnya melalui komposer:

 composer require laravel/socialite

Pengaturan dan Penggunaan

Setelah kami menginstalnya, kami harus menambahkan kredensial untuk penyedia OAuth yang digunakan aplikasi kami. Kami akan menambahkannya di config/services.php untuk setiap layanan.

Dalam konfigurasi, kita harus mencocokkan kunci dengan layanan sebelumnya. Beberapa kunci tersebut antara lain:

• facebook
• twitter (Untuk OAuth 1.0)
• twitter-oauth-2 (Untuk OAuth 2.0)
• linkedin
• google
• github
• gitlab
• bitbucket

Satu konfigurasi layanan mungkin terlihat seperti ini:

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

Mengautentikasi Pengguna

Untuk tindakan ini, kami memerlukan dua rute, satu untuk mengarahkan ulang pengguna ke penyedia OAuth:

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

Dan satu untuk panggilan balik dari penyedia setelah otentikasi:

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

Socialite menyediakan metode pengalihan, dan fasad mengalihkan pengguna ke penyedia OAuth, sedangkan metode pengguna memeriksa permintaan yang masuk dan mengambil informasi pengguna.

Setelah kami menerima pengguna kami, kami harus memeriksa apakah itu ada di database kami dan mengautentikasinya. Jika tidak ada, kami akan membuat record baru untuk mewakili pengguna:

 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'); });

Jika kita ingin membatasi cakupan akses pengguna, kita dapat menggunakan metode scopes , yang akan disertakan dengan permintaan autentikasi. Ini akan menggabungkan semua cakupan yang ditentukan sebelumnya dengan yang ditentukan.

Alternatif untuk ini adalah dengan menggunakan metode setScopes yang menimpa setiap ruang lingkup lain yang ada:

 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();

Sekarang setelah kita mengetahui segalanya dan cara mendapatkan pengguna setelah callback, mari kita lihat beberapa data yang bisa kita dapatkan darinya.

Pengguna OAuth1 memiliki token dan tokenSecret :

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

OAuth2 menyediakan token , refreshToken , dan expiresIn :

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

Baik OAuth1 dan OAuth2 menyediakan getId , getNickname , getName , getEmail , dan getAvatar :

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

Dan jika kita ingin mendapatkan detail pengguna dari token (OAuth 2) atau token dan secret (OAuth 1), sanctum menyediakan dua metode untuk ini: userFromToken dan userFromTokenAndSecret :

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

Tempat Suci Laravel

Laravel Sanctum adalah sistem autentikasi ringan untuk SPA (Aplikasi Halaman Tunggal) dan aplikasi seluler. Ini memungkinkan pengguna membuat beberapa token API dengan cakupan tertentu. Cakupan ini menentukan tindakan yang diizinkan oleh token.

Penggunaan

Sanctum dapat digunakan untuk mengeluarkan Token API kepada pengguna tanpa kerumitan OAuth. Token tersebut biasanya memiliki waktu kedaluwarsa yang lama, seperti tahun, tetapi dapat dicabut dan dibuat ulang oleh pengguna kapan saja.

Instalasi dan Pengaturan

Kita dapat menginstalnya melalui komposer:

 composer require laravel/sanctum

Dan kami harus menerbitkan file konfigurasi dan migrasi:

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

Sekarang setelah kami membuat file migrasi baru, kami harus memigrasikannya:

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

Cara Menerbitkan Token API

Sebelum mengeluarkan token, model User kita harus menggunakan sifat Laravel\Sanctum\HasApiTokens :

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

Saat kita memiliki pengguna, kita bisa mengeluarkan token dengan memanggil metode createToken , yang mengembalikan instance Laravel\Sanctum\NewAccessToken .

Kita dapat memanggil metode plainTextToken pada instance NewAccessToken untuk melihat nilai teks biasa SHA-256 dari token.

Tips dan Praktik Terbaik untuk Otentikasi Laravel

Memvalidasi Sesi Di Perangkat Lain

Seperti yang telah kita bahas sebelumnya, membatalkan sesi sangat penting saat pengguna keluar, tetapi itu juga harus tersedia sebagai opsi untuk semua perangkat yang dimiliki.

Fitur ini biasanya digunakan saat pengguna mengubah atau memperbarui kata sandinya, dan kami ingin membatalkan sesi mereka dari perangkat lain.

Dilengkapi dengan fasad Auth, ini adalah tugas yang mudah dicapai. Mempertimbangkan bahwa rute yang kita gunakan memiliki middleware auth dan auth.session middleware , kita dapat menggunakan metode fasad logoutOtherDevices statis:

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

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

Konfigurasi Dengan Auth::routes()

Metode rute fasad Auth hanyalah pembantu untuk menghasilkan semua rute yang diperlukan untuk otentikasi pengguna.

Rute tersebut meliputi Login (Get, Post), Logout (Post), Daftar (Get, Post), dan Password Reset/Email (Get, Post).

Saat Anda memanggil metode pada fasad, ia melakukan hal berikut:

 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); }

Kami tertarik pada apa yang terjadi ketika metode statis dipanggil di router. Ini bisa jadi rumit karena fakta cara kerja fasad, tetapi metode berikut yang dipanggil adalah seperti ini:

 /** 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(); } }

Secara default, ini menghasilkan semua rute selain verifikasi email. Kami akan selalu memiliki rute Masuk dan Keluar, tetapi yang lain dapat kami kontrol melalui rangkaian opsi.

Jika kita hanya ingin login/logout dan mendaftar, kita dapat melewati array opsi berikut:

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

Melindungi Rute dan Penjaga Kustom

Kami ingin memastikan bahwa beberapa rute hanya dapat diakses oleh pengguna yang diautentikasi dan dapat dilakukan dengan cepat dengan menambahkan baik memanggil metode middleware pada fasad Rute atau merantai metode middleware di atasnya:

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

Penjaga ini memastikan bahwa permintaan yang masuk diautentikasi.

Konfirmasi kata kunci

Untuk keamanan situs web tambahan, Anda sering ingin mengonfirmasi kata sandi pengguna sebelum melanjutkan dengan tugas lainnya.

Kita harus menentukan rute dari tampilan konfirmasi kata sandi untuk menangani permintaan. Ini akan memvalidasi dan mengarahkan pengguna ke tujuan yang dituju. Pada saat yang sama, kami akan memastikan bahwa kata sandi kami muncul dikonfirmasi di sesi tersebut. Secara default, kata sandi harus dikonfirmasi ulang setiap tiga jam, tetapi ini dapat diubah dalam file konfigurasi di 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']);

Kontrak yang Dapat Diotentikasi

Kontrak Authenticable yang terletak di Illuminate\Contracts\Auth mendefinisikan cetak biru dari apa yang harus diterapkan fasad UserProvider:

 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(); }

Antarmuka memungkinkan sistem otentikasi untuk bekerja dengan kelas "pengguna" apa pun yang mengimplementasikannya.

Ini berlaku terlepas dari ORM atau lapisan penyimpanan apa yang digunakan. Secara default, Laravel memiliki App\Models\User yang mengimplementasikan antarmuka ini, dan ini juga dapat dilihat di file konfigurasi:

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

Acara Otentikasi

Ada banyak kejadian yang dikirim selama keseluruhan proses autentikasi.

Bergantung pada tujuan Anda, Anda dapat melampirkan pendengar ke acara tersebut di EventServiceProvider .

Buat Pengguna Baru dengan Cepat

Membuat pengguna baru dengan cepat dapat dilakukan melalui App\User :

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

Atau melalui metode buat statis pada fasad Pengguna:

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

Ringkasan

Ekosistem Laravel memiliki banyak starter kit untuk mengaktifkan dan menjalankan aplikasi Anda dengan sistem Otentikasi, seperti Breeze dan Jetstream. Mereka sangat dapat disesuaikan karena kode dibuat di pihak kita, dan kita dapat memodifikasinya sebanyak yang kita mau, menggunakannya sebagai cetak biru jika perlu.

Ada banyak masalah keamanan terkait autentikasi dan kerumitannya, tetapi semua ini dapat diselesaikan dengan mudah melalui alat yang disediakan Laravel. Alat-alat ini sangat dapat disesuaikan dan mudah digunakan.

Terapkan aplikasi Laravel Anda dengan cepat dan efisien dengan layanan hosting Laravel cepat kami. Lihat aplikasi Anda beraksi dengan uji coba gratis.