Laravel Sanctum adalah solusi otentikasi API ringan untuk aplikasi Laravel, ideal bagi Anda yang ingin membangun API sederhana namun aman. Dalam artikel ini, kita akan membahas cara mudah membuat API dengan Laravel Sanctum dan bagaimana Anda dapat memastikan keamanannya. Kita akan membahas langkah-langkah dari awal hingga akhir, sehingga Anda dapat segera mengimplementasikan API yang aman dan berfungsi dengan baik.
1. Apa itu Laravel Sanctum dan Mengapa Harus Menggunakannya?
Sebelum membahas lebih jauh cara mudah membuat API dengan Laravel Sanctum, mari pahami dulu apa itu Laravel Sanctum dan mengapa ini menjadi pilihan yang tepat untuk proyek Anda.
Laravel Sanctum menyediakan sistem otentikasi berbasis token yang memungkinkan pengguna aplikasi Anda untuk mengakses API tanpa perlu proses otentikasi yang rumit seperti OAuth. Sanctum bekerja dengan mengeluarkan personal access tokens (PAT) yang dapat digunakan pengguna untuk melakukan permintaan ke API Anda.
Keuntungan menggunakan Laravel Sanctum:
Related Post
- Ringan dan Mudah Diimplementasikan: Sanctum didesain untuk menjadi solusi yang straightforward, sehingga pengembang dapat dengan cepat mengintegrasikannya ke dalam proyek mereka.
- Keamanan Terjamin: Sanctum menggunakan enkripsi yang kuat untuk melindungi token dan informasi pengguna.
- Cocok untuk SPA dan Mobile Apps: Sanctum sangat cocok untuk Single Page Application (SPA) yang menggunakan JavaScript framework seperti Vue.js atau React, serta aplikasi mobile (Android atau iOS).
- Manajemen Token: Sanctum menyediakan cara mudah untuk me-revoke atau mencabut token akses pengguna.
- Support Multi Domain/Application: Sanctum dapat digunakan untuk mengotentikasi permintaan dari berbagai domain atau aplikasi.
Singkatnya, Laravel Sanctum adalah pilihan yang ideal jika Anda mencari solusi otentikasi API yang sederhana, aman, dan mudah diimplementasikan dalam proyek Laravel Anda. Karena itulah, mempelajari cara mudah membuat API dengan Laravel Sanctum sangat penting bagi developer Laravel.
2. Persiapan Awal: Instalasi Laravel dan Sanctum
Sebelum kita masuk ke cara mudah membuat API dengan Laravel Sanctum, pastikan Anda sudah memiliki proyek Laravel yang berjalan. Jika belum, mari kita mulai dengan membuat proyek Laravel baru dan menginstal Sanctum.
Langkah 1: Instalasi Laravel
Buka terminal Anda dan jalankan perintah berikut untuk membuat proyek Laravel baru:
composer create-project --prefer-dist laravel/laravel sanctum-api
cd sanctum-apiGanti sanctum-api dengan nama proyek yang Anda inginkan.
Langkah 2: Konfigurasi Database
Konfigurasikan koneksi database Anda pada file .env. Pastikan Anda memiliki database yang sudah dibuat.
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=sanctum_api
DB_USERNAME=root
DB_PASSWORD=Sesuaikan nilai-nilai tersebut dengan konfigurasi database Anda.
Langkah 3: Instalasi Sanctum
Jalankan perintah berikut untuk menginstal Sanctum menggunakan Composer:
composer require laravel/sanctumLangkah 4: Migrasi Database Sanctum
Setelah instalasi selesai, publikasikan konfigurasi dan migrasi Sanctum:
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"
php artisan migratePerintah ini akan membuat tabel yang dibutuhkan oleh Sanctum di database Anda.
Langkah 5: Konfigurasi Model User
Pastikan model User Anda menggunakan trait HasApiTokens. Buka file app/Models/User.php dan tambahkan use LaravelSanctumHasApiTokens; dan use HasApiTokens; ke dalam class User.
<?php
namespace AppModels;
use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens;
class User extends Authenticatable
{
use HasApiTokens, HasFactory, Notifiable;
// ... (kode lainnya) ...
}Dengan langkah-langkah ini, Anda telah berhasil menyiapkan proyek Laravel dan menginstal Laravel Sanctum. Sekarang kita bisa melanjutkan ke cara mudah membuat API dengan Laravel Sanctum, yaitu membuat endpoint dan menerapkan otentikasi.
3. Membuat Endpoint API Sederhana dengan Controller
Setelah instalasi selesai, mari buat endpoint API sederhana untuk melihat bagaimana Sanctum bekerja. Kita akan membuat controller untuk menangani permintaan API.
Langkah 1: Membuat Controller
Jalankan perintah berikut untuk membuat controller baru:
php artisan make:controller Api/UserControllerIni akan membuat file app/Http/Controllers/Api/UserController.php.
Langkah 2: Menambahkan Metode ke Controller
Buka file app/Http/Controllers/Api/UserController.php dan tambahkan metode berikut:
<?php
namespace AppHttpControllersApi;
use AppHttpControllersController;
use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;
class UserController extends Controller
{
public function index()
{
return response()->json(['message' => 'Welcome to the API!'], 200);
}
public function user(Request $request)
{
return $request->user(); // Mengembalikan data user yang terotentikasi
}
}Metode index akan menampilkan pesan selamat datang, sedangkan metode user akan mengembalikan data user yang terotentikasi.
Langkah 3: Mendefinisikan Route API
Buka file routes/api.php dan tambahkan route berikut:
<?php
use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersApiUserController;
Route::get('/welcome', [UserController::class, 'index']);
Route::middleware('auth:sanctum')->get('/user', [UserController::class, 'user']);Perhatikan bahwa route /user menggunakan middleware auth:sanctum. Middleware ini akan memastikan bahwa hanya pengguna yang memiliki token Sanctum yang valid yang dapat mengakses route ini. Inilah salah satu inti dari cara mudah membuat API dengan Laravel Sanctum: memanfaatkan middleware untuk keamanan.
4. Menerapkan Otentikasi: Registrasi dan Login
Sekarang, kita perlu menerapkan fungsi registrasi dan login untuk pengguna, sehingga mereka bisa mendapatkan token Sanctum.
Langkah 1: Membuat Controller Otentikasi
Buat controller baru untuk menangani otentikasi:
php artisan make:controller Api/AuthControllerLangkah 2: Menambahkan Metode Registrasi dan Login
Buka file app/Http/Controllers/Api/AuthController.php dan tambahkan metode berikut:
<?php
namespace AppHttpControllersApi;
use AppHttpControllersController;
use IlluminateHttpRequest;
use AppModelsUser;
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(['errors' => $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',
], 201);
}
public function login(Request $request)
{
if (!Auth::attempt($request->only('email', 'password'))) {
return response()->json([
'message' => 'Invalid login credentials'
], 401);
}
$user = User::where('email', $request['email'])->firstOrFail();
$token = $user->createToken('auth_token')->plainTextToken;
return response()->json([
'access_token' => $token,
'token_type' => 'Bearer',
], 200);
}
public function logout(Request $request)
{
$request->user()->currentAccessToken()->delete();
return response()->json([
'message' => 'Successfully logged out'
]);
}
}Metode register akan membuat pengguna baru dan menghasilkan token Sanctum. Metode login akan memvalidasi kredensial pengguna dan menghasilkan token Sanctum jika valid. Metode logout akan menghapus token yang sedang aktif.
Langkah 3: Mendefinisikan Route Otentikasi
Buka file routes/api.php dan tambahkan route berikut:
<?php
use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersApiUserController;
use AppHttpControllersApiAuthController;
Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
Route::middleware('auth:sanctum')->group(function () {
Route::get('/user', [UserController::class, 'user']);
Route::post('/logout', [AuthController::class, 'logout']);
});
Route::get('/welcome', [UserController::class, 'index']);Perhatikan bahwa route /logout juga menggunakan middleware auth:sanctum, memastikan hanya pengguna yang terotentikasi yang dapat melakukan logout. Penggunaan middleware ini adalah kunci dalam cara mudah membuat API dengan Laravel Sanctum yang aman.
5. Uji Coba API dengan Postman atau Insomnia
Setelah semua langkah di atas selesai, saatnya untuk menguji API Anda menggunakan Postman atau Insomnia.
Langkah 1: Registrasi Pengguna
Kirim permintaan POST ke endpoint /api/register dengan data berikut:
{
"name": "John Doe",
"email": "[email protected]",
"password": "password123"
}Jika berhasil, Anda akan menerima respons berupa token akses.
Langkah 2: Login Pengguna
Kirim permintaan POST ke endpoint /api/login dengan data berikut:
{
"email": "[email protected]",
"password": "password123"
}Anda akan menerima respons berupa token akses.
Langkah 3: Mengakses Endpoint yang Dilindungi
Untuk mengakses endpoint /api/user, Anda perlu menambahkan header Authorization dengan nilai Bearer <token_akses>. Ganti <token_akses> dengan token yang Anda dapatkan dari proses registrasi atau login.
Langkah 4: Logout Pengguna
Kirim permintaan POST ke endpoint /api/logout dengan menambahkan header Authorization yang sama seperti di langkah 3. Ini akan menghapus token yang sedang aktif.
Jika Anda berhasil melakukan semua langkah di atas, berarti Anda telah berhasil menerapkan cara mudah membuat API dengan Laravel Sanctum dan mengamankannya.
6. Manajemen Token: Revoking dan Expiration
Salah satu aspek penting dalam cara mudah membuat API dengan Laravel Sanctum yang aman adalah manajemen token. Anda perlu memastikan bahwa token dapat dicabut (revoke) dan memiliki masa berlaku (expiration).
Revoking Token
Kita sudah membahas cara me-logout pengguna dengan menghapus token yang sedang aktif. Sanctum juga memungkinkan Anda untuk mencabut token tertentu. Anda dapat menambahkan metode di controller untuk melakukan ini. Misalnya, Anda dapat membuat endpoint untuk menghapus token berdasarkan ID.
Expiration Token
Sanctum tidak secara otomatis mengimplementasikan expiration token. Namun, Anda dapat mengimplementasikannya sendiri dengan menambahkan kolom expires_at ke tabel personal_access_tokens dan memodifikasi logika otentikasi untuk memeriksa apakah token masih berlaku.
Langkah 1: Menambahkan Kolom expires_at
Buat migration baru untuk menambahkan kolom expires_at ke tabel personal_access_tokens:
php artisan make:migration add_expires_at_to_personal_access_tokens_tableBuka file migration yang baru dibuat dan tambahkan kode berikut:
<?php
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 migration:
php artisan migrateLangkah 2: Mengubah Logic Registrasi dan Login
Ubah metode register dan login di AuthController untuk menambahkan tanggal kadaluarsa ke token:
// Di dalam metode register dan login
$token = $user->createToken('auth_token', ['*'], now()->addDays(7))->plainTextToken; // Token berlaku selama 7 hariPerhatikan penambahan now()->addDays(7) sebagai argumen ketiga. Ini akan mengatur expires_at ke 7 hari dari sekarang.
Langkah 3: Mengubah Middleware Sanctum
Anda perlu membuat middleware custom untuk memeriksa apakah token sudah kadaluarsa. Buat middleware baru:
php artisan make:middleware CheckTokenExpirationBuka file app/Http/Middleware/CheckTokenExpiration.php dan tambahkan kode berikut:
<?php
namespace AppHttpMiddleware;
use Closure;
use IlluminateHttpRequest;
use LaravelSanctumPersonalAccessToken;
class CheckTokenExpiration
{
/**
* Handle an incoming request.
*
* @param IlluminateHttpRequest $request
* @param Closure(IlluminateHttpRequest): (IlluminateHttpResponse|IlluminateHttpRedirectResponse) $next
* @return IlluminateHttpResponse|IlluminateHttpRedirectResponse
*/
public function handle(Request $request, Closure $next)
{
$token = $request->bearerToken();
if ($token) {
$accessToken = PersonalAccessToken::findToken($token);
if ($accessToken && $accessToken->expires_at && $accessToken->expires_at->isPast()) {
$accessToken->delete();
return response()->json(['message' => 'Token has expired'], 401);
}
}
return $next($request);
}
}Langkah 4: Mendaftarkan Middleware
Buka file app/Http/Kernel.php dan tambahkan middleware CheckTokenExpiration ke $routeMiddleware:
protected $routeMiddleware = [
// ...
'token.expiration' => AppHttpMiddlewareCheckTokenExpiration::class,
];Langkah 5: Menerapkan Middleware ke Route
Ubah route yang dilindungi di routes/api.php untuk menggunakan middleware token.expiration:
Route::middleware(['auth:sanctum', 'token.expiration'])->group(function () {
Route::get('/user', [UserController::class, 'user']);
Route::post('/logout', [AuthController::class, 'logout']);
});Dengan langkah-langkah ini, Anda telah berhasil mengimplementasikan expiration token, meningkatkan keamanan API Anda secara signifikan. Manajemen token yang baik adalah kunci dalam cara mudah membuat API dengan Laravel Sanctum yang aman dan handal.
7. Menggunakan API Resources untuk Format Response yang Konsisten
Agar API Anda lebih terstruktur dan mudah dipahami, pertimbangkan untuk menggunakan API Resources untuk memformat respons. API Resources memungkinkan Anda untuk mengubah model Eloquent menjadi struktur JSON yang spesifik.
Langkah 1: Membuat API Resource
Buat API Resource untuk model User:
php artisan make:resource UserResourceIni akan membuat file app/Http/Resources/UserResource.php.
Langkah 2: Memodifikasi API Resource
Buka file app/Http/Resources/UserResource.php dan tambahkan kode berikut:
<?php
namespace AppHttpResources;
use IlluminateHttpResourcesJsonJsonResource;
class UserResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @param IlluminateHttpRequest $request
* @return array|IlluminateContractsSupportArrayable|JsonSerializable
*/
public function toArray($request)
{
return [
'id' => $this->id,
'name' => $this->name,
'email' => $this->email,
'created_at' => $this->created_at,
'updated_at' => $this->updated_at,
];
}
}Anda dapat menyesuaikan field yang ingin ditampilkan dalam respons API.
Langkah 3: Menggunakan API Resource di Controller
Ubah metode user di UserController untuk menggunakan UserResource:
use AppHttpResourcesUserResource;
public function user(Request $request)
{
return new UserResource($request->user());
}Dengan menggunakan API Resources, Anda dapat memastikan bahwa respons API Anda konsisten dan mudah di-parse oleh klien. Ini adalah praktik yang baik dalam cara mudah membuat API dengan Laravel Sanctum yang profesional.
8. Menerapkan Permission dengan Abilities Sanctum
Sanctum juga menyediakan fitur abilities untuk memberikan izin yang lebih granular ke token. Abilities memungkinkan Anda untuk menentukan tindakan apa saja yang dapat dilakukan dengan token tertentu.
Langkah 1: Mendefinisikan Abilities
Ketika membuat token, Anda dapat menentukan abilities yang diizinkan:
$token = $user->createToken('auth_token', ['server:update', 'server:delete'])->plainTextToken;Dalam contoh ini, token hanya diizinkan untuk melakukan tindakan server:update dan server:delete.
Langkah 2: Memeriksa Abilities di Middleware
Anda dapat membuat middleware custom untuk memeriksa apakah token memiliki abilities yang diperlukan. Buat middleware baru:
php artisan make:middleware CheckAbilityBuka file app/Http/Middleware/CheckAbility.php dan tambahkan kode berikut:
<?php
namespace AppHttpMiddleware;
use Closure;
use IlluminateHttpRequest;
class CheckAbility
{
/**
* Handle an incoming request.
*
* @param IlluminateHttpRequest $request
* @param Closure(IlluminateHttpRequest): (IlluminateHttpResponse|IlluminateHttpRedirectResponse) $next
* @param string $ability
* @return IlluminateHttpResponse|IlluminateHttpRedirectResponse
*/
public function handle(Request $request, Closure $next, string $ability)
{
if ($request->user()->tokenCan($ability)) {
return $next($request);
}
return response()->json(['message' => 'Unauthorized'], 403);
}
}Langkah 3: Mendaftarkan Middleware
Buka file app/Http/Kernel.php dan tambahkan middleware CheckAbility ke $routeMiddleware:
protected $routeMiddleware = [
// ...
'ability' => AppHttpMiddlewareCheckAbility::class,
];Langkah 4: Menerapkan Middleware ke Route
Ubah route yang dilindungi di routes/api.php untuk menggunakan middleware ability:
Route::middleware(['auth:sanctum', 'ability:server:update'])->put('/servers/{id}', [ServerController::class, 'update']);Dalam contoh ini, hanya token yang memiliki ability server:update yang dapat mengakses route /servers/{id}.
Dengan menggunakan abilities, Anda dapat memberikan kontrol yang lebih besar atas izin token, meningkatkan keamanan dan fleksibilitas API Anda. Ini adalah fitur lanjutan dalam cara mudah membuat API dengan Laravel Sanctum yang dapat Anda manfaatkan.
9. Keamanan Tambahan: Rate Limiting dan Input Validation
Selain otentikasi dan otorisasi, ada beberapa langkah tambahan yang dapat Anda lakukan untuk meningkatkan keamanan API Anda:
- Rate Limiting: Membatasi jumlah permintaan yang dapat dilakukan oleh pengguna dalam periode waktu tertentu untuk mencegah serangan DDoS. Laravel menyediakan fitur rate limiting yang mudah digunakan.
- Input Validation: Memastikan bahwa data yang diterima dari pengguna valid dan sesuai dengan format yang diharapkan. Gunakan fitur validator Laravel untuk melakukan validasi input.
- Sanitasi Input: Membersihkan data input dari karakter-karakter yang berpotensi berbahaya untuk mencegah serangan XSS dan SQL injection.
- Menggunakan HTTPS: Memastikan bahwa semua komunikasi antara klien dan server dienkripsi menggunakan HTTPS.
- Mengupdate Laravel dan Dependencies: Selalu menjaga Laravel dan semua dependencies up-to-date untuk mendapatkan patch keamanan terbaru.
Dengan menerapkan langkah-langkah keamanan tambahan ini, Anda dapat membuat API yang lebih aman dan tahan terhadap serangan. Keamanan adalah aspek yang sangat penting dalam cara mudah membuat API dengan Laravel Sanctum yang profesional.
10. Kesimpulan: API Aman dan Mudah dengan Laravel Sanctum
Dalam artikel ini, kita telah membahas cara mudah membuat API dengan Laravel Sanctum dan bagaimana Anda dapat memastikan keamanannya. Kita telah membahas langkah-langkah dari instalasi, pembuatan endpoint, otentikasi, manajemen token, penggunaan API Resources, implementasi abilities, hingga langkah-langkah keamanan tambahan.
Laravel Sanctum adalah solusi otentikasi API yang ringan, mudah diimplementasikan, dan aman untuk aplikasi Laravel Anda. Dengan mengikuti langkah-langkah yang telah kita bahas, Anda dapat dengan cepat membangun API yang aman dan berfungsi dengan baik.
Ingatlah bahwa keamanan API adalah proses yang berkelanjutan. Anda perlu terus memantau dan meningkatkan keamanan API Anda seiring dengan perkembangan teknologi dan ancaman keamanan yang baru. Semoga artikel ini bermanfaat dan membantu Anda dalam membangun API yang aman dan sukses dengan Laravel Sanctum!
