Laravel Sanctum telah menjadi solusi populer untuk otentikasi API (Application Programming Interface) dalam aplikasi Laravel. Dikenal karena kemudahan implementasi dan kecepatannya, Sanctum menyediakan cara yang sederhana namun aman untuk mengelola otentikasi, terutama bagi aplikasi single-page (SPA), aplikasi mobile, dan API sederhana. Dalam artikel ini, kita akan menyelami lebih dalam tentang Laravel Sanctum untuk API Authentication, bagaimana cara kerjanya, kelebihan dan kekurangannya, serta langkah-langkah praktis untuk mengimplementasikannya dengan mudah dan cepat. Mari kita mulai!
Apa Itu Laravel Sanctum dan Mengapa Memilihnya untuk Otentikasi API?
Laravel Sanctum adalah paket otentikasi berbasis token yang ringan dan dirancang khusus untuk aplikasi single-page (SPA), aplikasi mobile, dan API sederhana yang memerlukan otentikasi. Dibandingkan dengan metode otentikasi yang lebih kompleks seperti OAuth2, Sanctum menawarkan solusi yang lebih sederhana dan lebih mudah dikelola, terutama ketika Anda tidak memerlukan fitur-fitur kompleks yang ditawarkan oleh OAuth2.
Mengapa memilih Laravel Sanctum?
- Sederhana dan Mudah Diimplementasikan: Sanctum sangat mudah diatur dan dikonfigurasi. Bahkan developer pemula pun dapat dengan cepat mengimplementasikannya.
- Ringan dan Cepat: Sanctum tidak memberatkan aplikasi Anda dengan overhead yang besar. Proses otentikasi berjalan cepat dan efisien.
- Aman: Menggunakan token berbasis API dengan enkripsi yang kuat, Sanctum memberikan lapisan keamanan yang solid untuk API Anda.
- Ideal untuk SPA, Aplikasi Mobile, dan API Sederhana: Sanctum dirancang khusus untuk kebutuhan otentikasi modern, terutama pada aplikasi single-page dan aplikasi mobile.
- Mendukung Multiple API Tokens per User: Pengguna dapat memiliki beberapa token API yang aktif secara bersamaan, memungkinkan kontrol yang lebih baik atas akses aplikasi mereka. Misalnya, satu token untuk website, satu token untuk aplikasi mobile, dan seterusnya.
Memahami Cara Kerja Laravel Sanctum: Token-Based Authentication yang Efisien
Laravel Sanctum untuk API Authentication bekerja dengan prinsip token-based authentication. Secara sederhana, berikut adalah alur kerjanya:
- Permintaan Login: Pengguna mengirimkan permintaan login (username dan password) ke server.
- Otentikasi: Server memvalidasi kredensial pengguna.
- Penerbitan Token: Jika kredensial valid, server menerbitkan API token unik untuk pengguna tersebut. Token ini disimpan dalam database.
- Pengembalian Token: Token dikembalikan kepada pengguna (biasanya dalam bentuk JSON).
- Penyimpanan Token: Pengguna menyimpan token tersebut (misalnya, dalam local storage pada SPA atau dalam shared preferences pada aplikasi mobile).
- Permintaan Terotentikasi: Untuk mengakses API yang memerlukan otentikasi, pengguna menyertakan token tersebut dalam header
Authorizationdengan formatBearer {token}. - Validasi Token: Server menerima permintaan, mengekstrak token dari header, dan memvalidasi token tersebut terhadap database.
- Akses Diizinkan: Jika token valid, pengguna diizinkan untuk mengakses resource yang diminta.
Dengan alur kerja ini, server tidak perlu menyimpan sesi (session) untuk setiap pengguna yang terotentikasi, sehingga mengurangi beban server dan meningkatkan skalabilitas.
Persiapan Awal: Instalasi dan Konfigurasi Laravel Sanctum
Sebelum kita mulai mengimplementasikan Laravel Sanctum untuk API Authentication, kita perlu melakukan beberapa persiapan awal:
-
Instalasi Paket Sanctum:
Buka terminal dan jalankan perintah berikut di direktori proyek Laravel Anda:composer require laravel/sanctum -
Publish Konfigurasi dan Migrasi:
Setelah instalasi selesai, publikasikan file konfigurasi dan migrasi Sanctum menggunakan perintah berikut:php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider" -
Migrasi Database:
Jalankan migrasi untuk membuat tabel yang diperlukan oleh Sanctum (misalnya, tabelpersonal_access_tokens):php artisan migrate -
Konfigurasi Model User:
Pastikan modelUserAnda menggunakan traitHasApiTokensdari Sanctum:<?php namespace AppModels; use IlluminateFoundationAuthUser as Authenticatable; use IlluminateNotificationsNotifiable; use LaravelSanctumHasApiTokens; class User extends Authenticatable { use HasApiTokens, Notifiable; // ... } -
Konfigurasi Middleware:
Pastikan middlewareEnsureFrontendRequestsAreStatefulterdaftar diapp/Http/Kernel.php:protected $middlewareGroups = [ 'web' => [ // ... AppHttpMiddlewareEncryptCookies::class, IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class, IlluminateSessionMiddlewareStartSession::class, IlluminateViewMiddlewareShareErrorsFromSession::class, AppHttpMiddlewareVerifyCsrfToken::class, IlluminateRoutingMiddlewareSubstituteBindings::class, ], 'api' => [ LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, 'throttle:api', IlluminateRoutingMiddlewareSubstituteBindings::class, ], ];Jika menggunakan CORS, pastikan konfigurasi CORS sudah benar. Bisa menggunakan package
fruitcake/laravel-cors.
Dengan langkah-langkah persiapan ini, Anda sudah siap untuk mulai mengimplementasikan Laravel Sanctum untuk API Authentication dalam aplikasi Anda.
Membuat Endpoint Login dan Register: Mendapatkan dan Menggunakan Token API
Langkah selanjutnya adalah membuat endpoint untuk login dan register pengguna, di mana kita akan menerbitkan token API setelah pengguna berhasil terotentikasi.
1. Membuat Controller Authentication:
Buat sebuah controller bernama AuthController:
php artisan make:controller AuthController2. Implementasi Method Register:
Dalam AuthController, tambahkan method register:
<?php
namespace AppHttpControllers;
use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;
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',
]);
if ($validator->fails()) {
return response()->json($validator->errors(), 400);
}
$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',
]);
}
}3. Implementasi Method Login:
Dalam AuthController, tambahkan method login:
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($validator->errors(), 400);
}
$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',
]);
}4. Konfigurasi Route:
Tambahkan route untuk register dan login di routes/api.php:
<?php
use AppHttpControllersAuthController;
use IlluminateSupportFacadesRoute;
Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
return $request->user();
});Sekarang, Anda memiliki endpoint /register dan /login yang akan memberikan token API setelah pengguna berhasil terotentikasi. Token ini kemudian dapat digunakan untuk mengakses endpoint yang dilindungi oleh middleware auth:sanctum.
Melindungi Endpoint API dengan Middleware auth:sanctum
Setelah mendapatkan token API, langkah selanjutnya adalah melindungi endpoint API agar hanya bisa diakses oleh pengguna yang terotentikasi. Laravel Sanctum untuk API Authentication menyediakan middleware auth:sanctum untuk melakukan ini.
1. Aplikasikan Middleware pada Route:
Untuk melindungi sebuah route, tambahkan middleware auth:sanctum ke definisi route tersebut. Contoh:
Route::middleware('auth:sanctum')->get('/profile', function (Request $request) {
return response()->json($request->user());
});Dalam contoh di atas, route /profile hanya dapat diakses oleh pengguna yang mengirimkan permintaan dengan header Authorization yang berisi token API yang valid.
2. Mengakses Informasi Pengguna:
Di dalam route yang dilindungi, Anda dapat mengakses informasi pengguna yang terotentikasi menggunakan $request->user().
3. Contoh Penggunaan:
Katakanlah Anda memiliki sebuah endpoint untuk mendapatkan daftar postingan yang hanya boleh diakses oleh pengguna yang terotentikasi:
Route::middleware('auth:sanctum')->get('/posts', function (Request $request) {
$user = $request->user();
$posts = $user->posts; // Asumsikan model User memiliki relasi dengan model Post
return response()->json($posts);
});Dengan middleware auth:sanctum, Anda dapat dengan mudah melindungi endpoint API Anda dan memastikan bahwa hanya pengguna yang terotentikasi yang dapat mengaksesnya.
Manajemen Token API: Mencabut dan Menyegarkan Token
Laravel Sanctum untuk API Authentication juga menyediakan mekanisme untuk mengelola token API. Pengguna dapat mencabut token (revoke) atau membuat token baru.
1. Mencabut Token (Logout):
Untuk mencabut token, Anda dapat menggunakan method tokens()->delete() pada model User. Contoh:
Route::middleware('auth:sanctum')->post('/logout', function (Request $request) {
$request->user()->currentAccessToken()->delete();
return response()->json(['message' => 'Logged out']);
});Endpoint /logout ini akan menghapus token yang digunakan untuk mengakses endpoint tersebut, sehingga pengguna tidak lagi terotentikasi.
2. Membuat Token Baru (Refresh Token – Opsi Lanjutan):
Meskipun Sanctum tidak secara eksplisit menyediakan fitur refresh token seperti OAuth2, Anda dapat mengimplementasikan mekanisme serupa dengan membuat token baru setiap kali token lama mendekati kadaluarsa. Anda dapat menggunakan Carbon::now()->addMinutes() untuk mengatur masa berlaku token. Contoh:
public function refreshToken(Request $request) {
$user = $request->user();
$user->tokens()->delete(); //Hapus semua token lama
$token = $user->createToken('auth_token')->plainTextToken;
return response()->json([
'access_token' => $token,
'token_type' => 'Bearer',
]);
}
Route::middleware('auth:sanctum')->post('/refresh-token', [AuthController::class, 'refreshToken']);Penting: Implementasi refresh token yang aman memerlukan perhatian lebih terhadap keamanan, termasuk memastikan bahwa hanya token yang valid yang dapat digunakan untuk membuat token baru. Pertimbangkan untuk menggunakan library pihak ketiga yang dirancang khusus untuk manajemen refresh token yang aman.
Kelebihan dan Kekurangan Laravel Sanctum
Kelebihan Laravel Sanctum:
- Implementasi Mudah: Proses instalasi dan konfigurasi yang sederhana.
- Ringan: Tidak membebani aplikasi dengan overhead yang besar.
- Aman: Menggunakan token berbasis API dengan enkripsi yang kuat.
- Ideal untuk SPA, Aplikasi Mobile, dan API Sederhana: Dirancang khusus untuk kebutuhan otentikasi modern.
- Mendukung Multiple API Tokens per User: Pengguna dapat memiliki beberapa token yang aktif secara bersamaan.
- Dokumentasi yang Baik: Dokumentasi Laravel yang komprehensif memudahkan penggunaan.
Kekurangan Laravel Sanctum:
- Tidak Cocok untuk Otentikasi Kompleks: Kurang cocok untuk skenario yang memerlukan fitur otentikasi yang sangat kompleks seperti OAuth2 (misalnya, otentikasi pihak ketiga).
- Tidak Ada Fitur Refresh Token Otomatis: Refresh token harus diimplementasikan secara manual.
- Kurang Fleksibel Dibanding OAuth2: Fitur-fitur seperti otorisasi yang sangat rinci lebih sulit diimplementasikan.
Tips dan Trik dalam Menggunakan Laravel Sanctum
Berikut adalah beberapa tips dan trik yang dapat membantu Anda memaksimalkan penggunaan Laravel Sanctum untuk API Authentication:
- Gunakan Lingkungan yang Aman: Pastikan aplikasi Anda berjalan di lingkungan yang aman (HTTPS) untuk melindungi token API.
- Validasi Input dengan Ketat: Validasi semua input yang diterima dari pengguna untuk mencegah serangan injeksi dan manipulasi data.
- Lindungi Token di Sisi Klien: Simpan token API dengan aman di sisi klien (misalnya, menggunakan
httpOnlycookie atau penyimpanan yang aman pada aplikasi mobile). Hindari menyimpan token di local storage pada browser karena rentan terhadap XSS attack. - Pertimbangkan Rate Limiting: Implementasikan rate limiting untuk mencegah penyalahgunaan API.
- Audit Log: Buat catatan (log) untuk setiap aktivitas otentikasi (login, logout, pembuatan token) untuk keperluan audit dan keamanan.
- Customisasi Response: Sesuaikan respons API agar sesuai dengan kebutuhan aplikasi Anda. Misalnya, menambahkan informasi pengguna tambahan ke respons login.
Studi Kasus: Implementasi Laravel Sanctum pada Aplikasi E-commerce Sederhana
Mari kita lihat contoh implementasi Laravel Sanctum untuk API Authentication pada aplikasi e-commerce sederhana. Dalam contoh ini, kita akan melindungi endpoint untuk menambahkan produk ke keranjang belanja.
1. Model dan Migrasi Produk dan Keranjang Belanja:
Buat model Product dan Cart beserta migrasinya.
2. Controller Keranjang Belanja:
Buat CartController untuk mengelola keranjang belanja.
3. Implementasi Method addToCart:
<?php
namespace AppHttpControllers;
use AppModelsCart;
use AppModelsProduct;
use IlluminateHttpRequest;
class CartController extends Controller
{
public function addToCart(Request $request)
{
$request->validate([
'product_id' => 'required|exists:products,id',
'quantity' => 'required|integer|min:1',
]);
$user = $request->user();
$product = Product::find($request->product_id);
$cart = Cart::firstOrCreate([
'user_id' => $user->id,
'product_id' => $product->id,
], [
'quantity' => $request->quantity,
]);
if(!$cart->wasRecentlyCreated){
$cart->quantity += $request->quantity;
$cart->save();
}
return response()->json([
'message' => 'Product added to cart',
'cart' => $cart,
]);
}
}4. Konfigurasi Route:
Lindungi route addToCart dengan middleware auth:sanctum:
Route::middleware('auth:sanctum')->post('/cart/add', [CartController::class, 'addToCart']);Dengan implementasi ini, hanya pengguna yang terotentikasi yang dapat menambahkan produk ke keranjang belanja mereka. Ini memastikan bahwa hanya pengguna yang valid yang dapat berinteraksi dengan sistem keranjang belanja.
Kesimpulan: Laravel Sanctum, Solusi Otentikasi API yang Efektif
Laravel Sanctum untuk API Authentication menawarkan solusi yang efektif dan efisien untuk mengamankan API dalam aplikasi Laravel Anda. Dengan kemudahan implementasi, keamanan yang solid, dan kinerja yang ringan, Sanctum menjadi pilihan yang ideal untuk aplikasi single-page, aplikasi mobile, dan API sederhana. Meskipun memiliki beberapa keterbatasan dibandingkan dengan solusi otentikasi yang lebih kompleks seperti OAuth2, Sanctum tetap menjadi alat yang berharga dalam toolkit setiap developer Laravel.
Dengan memahami cara kerja Sanctum, mengikuti langkah-langkah implementasi yang benar, dan menerapkan praktik keamanan yang baik, Anda dapat membangun aplikasi yang aman dan terpercaya dengan Laravel Sanctum untuk API Authentication. Jangan ragu untuk menjelajahi dokumentasi resmi Laravel Sanctum dan bereksperimen dengan fitur-fiturnya untuk mengoptimalkan otentikasi API dalam aplikasi Anda. Selamat mencoba!
