Keamanan aplikasi adalah prioritas utama bagi setiap developer. Authentication, atau otentikasi, merupakan gerbang pertama yang harus dijaga. Di ekosistem Laravel, terdapat banyak cara untuk menangani otentikasi, dan salah satu yang paling populer dan modern adalah Laravel Sanctum. Dalam artikel ini, kita akan membahas secara mendalam cara menggunakan Laravel Sanctum untuk authentication, bagaimana ia bekerja, dan mengapa ia menjadi pilihan ideal untuk mengamankan aplikasi Laravelmu, terutama untuk aplikasi yang menggunakan API dan Single Page Applications (SPA).
Apa Itu Laravel Sanctum dan Mengapa Kamu Harus Menggunakannya? (Pengantar Laravel Sanctum)
Laravel Sanctum menyediakan sistem otentikasi ringan untuk aplikasi Laravel yang berfungsi sebagai API backend untuk aplikasi SPA (seperti Vue.js, React, atau Angular), aplikasi seluler, dan API pihak ketiga. Sanctum menggunakan token API untuk otentikasi, tetapi dengan cara yang lebih aman dan mudah dikelola.
Mengapa memilih Laravel Sanctum?
- Ringan dan Mudah Digunakan: Konfigurasi dan implementasinya relatif sederhana dibandingkan dengan solusi otentikasi yang lebih kompleks seperti OAuth2.
- Aman: Sanctum memanfaatkan CSRF protection (perlindungan terhadap serangan Cross-Site Request Forgery) dan session authentication, memberikan lapisan keamanan tambahan.
- Skalabilitas: Didesain untuk bekerja dengan baik dengan aplikasi yang berskala besar.
- Ideal untuk SPA dan Mobile Apps: Sanctum sangat cocok untuk mengotentikasi pengguna dari aplikasi frontend yang terpisah dari backend Laravel.
- Token API yang Fleksibel: Memberikan kontrol lebih besar atas token yang dikeluarkan, seperti membatasi kemampuan (abilities) token.
- Session-Based Authentication untuk Web: Tetap bisa digunakan untuk otentikasi berbasis sesi pada aplikasi web konvensional.
Jadi, jika kamu mencari solusi otentikasi yang powerful, aman, dan mudah digunakan untuk aplikasi Laravelmu, Laravel Sanctum adalah pilihan yang sangat baik.
Instalasi dan Konfigurasi Laravel Sanctum: Langkah Demi Langkah
Sebelum kita menyelam lebih dalam ke penggunaan, kita perlu menginstal dan mengkonfigurasi Laravel Sanctum di proyek Laravel kita. Berikut adalah langkah-langkahnya:
-
Instal Package Sanctum menggunakan Composer:
Buka terminal atau command prompt kamu dan arahkan ke direktori proyek Laravel. Kemudian jalankan perintah berikut:
composer require laravel/sanctum
Perintah ini akan mengunduh dan menginstal package Laravel Sanctum ke dalam proyekmu.
-
Publish Configuration dan Migration Files:
Setelah instalasi selesai, kamu perlu mem-publish file konfigurasi dan migrasi dari Sanctum. Jalankan perintah berikut:
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"
Perintah ini akan menyalin file konfigurasi
config/sanctum.php
dan file migrasi ke direktoridatabase/migrations
. -
Jalankan Migration:
Selanjutnya, jalankan migrasi untuk membuat tabel yang dibutuhkan oleh Sanctum.
php artisan migrate
Perintah ini akan membuat tabel
personal_access_tokens
yang akan digunakan untuk menyimpan token API. -
Konfigurasi Middleware:
Tambahkan
EnsureFrontendRequestsAreStateful
middleware ke kernel HTTP kamu (app/Http/Kernel.php
). Pastikan middleware ini berada di paling atas grup middlewareapi
. Ini sangat penting untuk memastikan Sanctum dapat memvalidasi token yang berasal dari frontend.protected $middlewareGroups = [ 'api' => [ LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, 'throttle:api', IlluminateRoutingMiddlewareSubstituteBindings::class, ], ];
Penting: Jika kamu tidak menambahkan middleware ini atau menempatkannya di posisi yang salah, Sanctum mungkin tidak berfungsi dengan benar.
-
Tambahkan
HasApiTokens
Trait ke Model User:Buka model
AppModelsUser
dan tambahkan traitHasApiTokens
ke kelasUser
.namespace AppModels; use IlluminateContractsAuthMustVerifyEmail; use IlluminateDatabaseEloquentFactoriesHasFactory; use IlluminateFoundationAuthUser as Authenticatable; use IlluminateNotificationsNotifiable; use LaravelSanctumHasApiTokens; class User extends Authenticatable { use HasApiTokens, HasFactory, Notifiable; // ... }
Trait ini menyediakan method-method yang dibutuhkan untuk berinteraksi dengan token API Sanctum.
Selesai! Kamu telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum di proyekmu.
Membuat Endpoint Login dan Register dengan Sanctum (Implementasi Authentication)
Sekarang, mari kita implementasikan endpoint Login dan Register untuk memungkinkan pengguna membuat akun dan mendapatkan token API menggunakan Sanctum.
-
Controller Authentication:
Buat controller baru bernama
AuthController
menggunakan perintah Artisan:php artisan make:controller AuthController
Kemudian, buka
app/Http/Controllers/AuthController.php
dan tambahkan kode berikut:namespace AppHttpControllers; use AppModelsUser; use IlluminateHttpRequest; use IlluminateSupportFacadesHash; use IlluminateSupportFacadesValidator; use IlluminateSupportStr; class AuthController extends Controller { 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:8|confirmed', ]); if ($validator->fails()) { return response()->json(['errors' => $validator->errors()], 422); } $user = User::create([ 'name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password), ]); $token = $user->createToken('auth_token')->plainTextToken; return response()->json([ 'access_token' => $token, 'token_type' => 'Bearer', ]); } public function login(Request $request) { $validator = Validator::make($request->all(), [ 'email' => 'required|string|email|max:255', 'password' => 'required|string|min:8', ]); if ($validator->fails()) { return response()->json(['errors' => $validator->errors()], 422); } $user = User::where('email', $request->email)->first(); if (!$user || !Hash::check($request->password, $user->password)) { return response()->json(['message' => 'Invalid credentials'], 401); } $token = $user->createToken('auth_token')->plainTextToken; return response()->json([ 'access_token' => $token, 'token_type' => 'Bearer', ]); } public function logout(Request $request) { $request->user()->currentAccessToken()->delete(); return response()->json(['message' => 'Successfully logged out']); } }
Kode di atas melakukan hal berikut:
- Register: Menerima data name, email, dan password. Melakukan validasi. Membuat user baru. Membuat token API baru untuk user tersebut. Mengembalikan token API ke frontend.
- Login: Menerima data email dan password. Melakukan validasi. Memeriksa apakah user ada dan password sesuai. Membuat token API baru untuk user tersebut. Mengembalikan token API ke frontend.
- Logout: Mencabut token API yang sedang digunakan.
-
Routes:
Buka
routes/api.php
dan tambahkan route untuk endpoint Login, Register, dan Logout.use AppHttpControllersAuthController; use IlluminateSupportFacadesRoute; Route::post('/register', [AuthController::class, 'register']); Route::post('/login', [AuthController::class, 'login']); Route::middleware('auth:sanctum')->group(function () { Route::post('/logout', [AuthController::class, 'logout']); Route::get('/user', function (Request $request) { return $request->user(); }); });
Perhatikan penggunaan
auth:sanctum
middleware untuk melindungi route Logout danuser
. Middleware ini memastikan bahwa hanya user yang terotentikasi yang dapat mengakses route tersebut.
Sekarang, kamu dapat menggunakan endpoint api/register
dan api/login
untuk mendaftarkan user baru dan mendapatkan token API. Token API ini kemudian dapat digunakan untuk mengakses route yang dilindungi oleh auth:sanctum
middleware.
Mengamankan API dengan Middleware auth:sanctum
(Proteksi Route)
Seperti yang kita lihat pada contoh sebelumnya, middleware auth:sanctum
digunakan untuk melindungi route API. Middleware ini memeriksa keberadaan token API yang valid pada request dan memastikan bahwa hanya user yang terotentikasi yang dapat mengakses route tersebut.
Cara menggunakan middleware auth:sanctum
:
-
Di Route Definition:
Route::middleware('auth:sanctum')->get('/profile', function (Request $request) { return $request->user(); });
Ini adalah cara yang paling umum untuk menggunakan middleware
auth:sanctum
. Middleware ini akan diterapkan hanya pada route/profile
. -
Di Controller Constructor:
public function __construct() { $this->middleware('auth:sanctum'); }
Ini akan menerapkan middleware
auth:sanctum
ke semua method pada controller. Kamu dapat mengecualikan method tertentu dengan menggunakan opsiexcept
:public function __construct() { $this->middleware('auth:sanctum')->except(['index', 'show']); }
Dalam contoh ini, middleware
auth:sanctum
akan diterapkan ke semua method kecualiindex
danshow
.
Jika middleware auth:sanctum
tidak menemukan token API yang valid pada request, ia akan mengembalikan response dengan kode status 401 Unauthorized
.
Mengelola Token API: Abilities dan Scopes (Kontrol Akses)
Salah satu fitur powerful dari Laravel Sanctum adalah kemampuannya untuk memberikan abilities atau scopes pada token API. Ini memungkinkan kamu untuk memberikan kontrol akses yang lebih granular ke API kamu.
- Abilities: Mendefinisikan apa yang dapat dilakukan oleh token.
- Scopes: Sinonim dari abilities, tetapi sering digunakan dalam konteks OAuth2.
Contoh penggunaan abilities:
-
Membuat Token dengan Abilities:
Saat membuat token API, kamu dapat menentukan abilities yang diizinkan untuk token tersebut.
$token = $user->createToken('auth_token', ['server:update'])->plainTextToken;
Dalam contoh ini, token API hanya memiliki ability
server:update
. -
Memeriksa Abilities:
Kamu dapat memeriksa apakah token API memiliki ability tertentu menggunakan method
tokenCan
:Route::get('/servers', function (Request $request) { if ($request->user()->tokenCan('server:update')) { // Lakukan sesuatu yang hanya boleh dilakukan oleh token dengan ability server:update return response()->json(['message' => 'You can update servers']); } return response()->json(['message' => 'You are not authorized to update servers'], 403); });
Dalam contoh ini, hanya token API yang memiliki ability
server:update
yang dapat mengakses route/servers
dan melakukan operasi pembaruan server.
Dengan menggunakan abilities, kamu dapat membatasi apa yang dapat dilakukan oleh token API, sehingga meningkatkan keamanan aplikasi kamu.
Integrasi dengan SPA (Single Page Application): Best Practices
Laravel Sanctum sangat cocok untuk digunakan dengan SPA (Single Page Application). Berikut adalah beberapa best practices untuk integrasi dengan SPA:
-
Pastikan
EnsureFrontendRequestsAreStateful
Middleware Dikonfigurasi dengan Benar: Seperti yang disebutkan sebelumnya, middleware ini sangat penting untuk memastikan Sanctum dapat memvalidasi token dari frontend. Pastikan middleware ini berada di posisi yang tepat di kernel HTTP kamu. -
Simpan Token API di Memori Browser (Bukan di Local Storage): Menyimpan token API di local storage rentan terhadap serangan XSS (Cross-Site Scripting). Lebih aman untuk menyimpan token API di memori browser, misalnya menggunakan variabel global atau state management library seperti Vuex atau Redux.
-
Kirim Token API dalam Header
Authorization
: Saat membuat request ke API Laravel, kirim token API dalam headerAuthorization
dengan formatBearer <token>
.axios.get('/api/profile', { headers: { Authorization: 'Bearer ' + accessToken } });
-
Gunakan Cookie untuk Menjaga Sesi (Opsional): Sanctum juga dapat menggunakan cookie untuk menjaga sesi pengguna. Ini berguna jika kamu ingin mengintegrasikan Sanctum dengan aplikasi web konvensional.
-
Perhatikan CORS (Cross-Origin Resource Sharing): Pastikan kamu telah mengkonfigurasi CORS dengan benar untuk memungkinkan frontend SPA kamu mengakses API Laravel kamu.
Dengan mengikuti best practices ini, kamu dapat mengintegrasikan Laravel Sanctum dengan SPA kamu dengan aman dan efisien.
Customization dan Advanced Usage Laravel Sanctum
Laravel Sanctum menawarkan beberapa opsi customization dan penggunaan lanjutan.
-
Mengubah Masa Berlaku Token:
Secara default, token API tidak memiliki masa berlaku. Kamu dapat mengubah ini dengan menambahkan column
expires_at
ke tabelpersonal_access_tokens
dan mengkonfigurasi modelPersonalAccessToken
.Pertama, tambahkan migrasi untuk menambahkan column
expires_at
:php artisan make:migration add_expires_at_to_personal_access_tokens_table
Kemudian, buka file migrasi dan tambahkan kode berikut:
use IlluminateDatabaseMigrationsMigration; use IlluminateDatabaseSchemaBlueprint; use IlluminateSupportFacadesSchema; class AddExpiresAtToPersonalAccessTokensTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::table('personal_access_tokens', function (Blueprint $table) { $table->timestamp('expires_at')->nullable(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::table('personal_access_tokens', function (Blueprint $table) { $table->dropColumn('expires_at'); }); } }
Jalankan migrasi:
php artisan migrate
Selanjutnya, tambahkan kode berikut ke model
LaravelSanctumPersonalAccessToken
:namespace LaravelSanctum; use IlluminateDatabaseEloquentFactoriesHasFactory; use IlluminateDatabaseEloquentModel; class PersonalAccessToken extends Model { use HasFactory; /** * The attributes that are mass assignable. * * @var array */ protected $fillable = [ 'name', 'token', 'abilities', 'expires_at', // Tambahkan ini ]; // ... }
Terakhir, tambahkan masa berlaku saat membuat token:
$token = $user->createToken('auth_token', [], now()->addDays(7))->plainTextToken; // Token berlaku selama 7 hari
-
Custom Guard:
Kamu dapat membuat custom guard untuk Sanctum jika kamu memiliki kebutuhan yang spesifik.
-
Menangani Token yang Dicuri:
Jika token API dicuri, kamu dapat mencabut token tersebut. Cara termudah adalah dengan menggunakan endpoint Logout yang telah kita buat sebelumnya. Kamu juga dapat mencabut semua token user dengan menggunakan method
tokens()
pada modelUser
.$user->tokens()->delete(); // Mencabut semua token user
Dengan customization dan penggunaan lanjutan ini, kamu dapat menyesuaikan Laravel Sanctum agar sesuai dengan kebutuhan aplikasi kamu.
Troubleshooting Masalah Umum dengan Laravel Sanctum
Meskipun Laravel Sanctum relatif mudah digunakan, kamu mungkin menghadapi beberapa masalah umum. Berikut adalah beberapa tips troubleshooting:
-
401 Unauthorized: Pastikan kamu mengirim token API yang valid dalam header
Authorization
. Periksa juga apakah middlewareauth:sanctum
dikonfigurasi dengan benar. -
CSRF Token Mismatch: Pastikan kamu telah mengkonfigurasi CSRF protection dengan benar, terutama jika kamu menggunakan cookie untuk menjaga sesi.
-
Token Tidak Valid: Pastikan token API belum dicabut atau kadaluarsa (jika kamu mengaktifkan masa berlaku token).
-
Masalah CORS: Pastikan kamu telah mengkonfigurasi CORS dengan benar untuk memungkinkan frontend SPA kamu mengakses API Laravel kamu.
-
Middleware
EnsureFrontendRequestsAreStateful
Tidak Berfungsi: Pastikan middleware ini ditempatkan di posisi yang paling atas pada grup middlewareapi
diapp/Http/Kernel.php
.
Jika kamu masih mengalami masalah, periksa log aplikasi Laravel kamu untuk mendapatkan informasi lebih lanjut.
Kesimpulan: Mengamankan Aplikasi Laravelmu dengan Laravel Sanctum
Dalam artikel ini, kita telah membahas secara mendalam cara menggunakan Laravel Sanctum untuk authentication. Kita telah melihat bagaimana menginstal dan mengkonfigurasi Sanctum, membuat endpoint Login dan Register, mengamankan API dengan middleware auth:sanctum
, mengelola token API dengan abilities dan scopes, dan mengintegrasikan Sanctum dengan SPA. Kita juga telah membahas beberapa opsi customization dan troubleshooting masalah umum.
Dengan menggunakan Laravel Sanctum, kamu dapat mengamankan aplikasi Laravelmu dengan mudah dan efisien, terutama untuk aplikasi yang menggunakan API dan SPA. Sanctum menyediakan solusi otentikasi yang ringan, aman, dan fleksibel, yang memungkinkan kamu untuk fokus pada pengembangan fitur-fitur penting lainnya dari aplikasi kamu. Jadi, jangan ragu untuk mengimplementasikan Laravel Sanctum dan amankan aplikasi Laravelmu sekarang juga!