Cara Membuat REST API Menggunakan Laravel Sanctum: Panduan Lengkap untuk Developer

Membangun RESTful API yang aman dan efisien adalah kebutuhan dasar di banyak aplikasi modern, mulai dari mobile app, SPA (Single Page Application), hingga integrasi antar layanan. Otentikasi dan otorisasi seringkali menjadi bagian paling menantang. Untungnya, Laravel, dengan ekosistemnya yang kaya, menyediakan solusi elegan bernama Laravel Sanctum.

Laravel Sanctum dirancang untuk menyederhanakan proses otentikasi API berbasis token. Ini adalah solusi lightweight dan mudah digunakan, cocok untuk berbagai skenario seperti otentikasi SPA dengan API Anda (menggunakan sesi/cookie) atau otentikasi API murni dengan token sederhana untuk aplikasi mobile atau pihak ketiga. Artikel ini akan fokus pada bagaimana kita bisa memanfaatkan Laravel Sanctum untuk membangun REST API yang aman dengan otentikasi token di Laravel.

Sebagai seorang developer, saya sering dihadapkan pada pilihan otentikasi API. Dulu, Laravel Passport menjadi pilihan utama untuk fitur OAuth2 yang lengkap. Namun, untuk banyak kasus, Passport terasa overkill. Di sinilah Sanctum bersinar. Kemudahannya dalam setup dan penggunaannya, terutama untuk API berbasis token, sangat membantu saya dalam mempercepat proses pengembangan tanpa mengorbankan keamanan.

Mengenal Laravel Sanctum dan Perannya dalam REST API

Laravel Sanctum adalah paket otentikasi resmi dari Laravel yang menyediakan sistem otentikasi API ringan untuk SPA, aplikasi mobile, dan token API sederhana. Alih-alih menerapkan seluruh implementasi OAuth2 yang kompleks seperti Laravel Passport, Sanctum menawarkan pendekatan yang lebih minimalis dan fokus pada fungsionalitas inti yang sering dibutuhkan.

Sanctum bekerja dengan dua cara utama:

1. Otentikasi Token API: Ini adalah mode yang paling sering kita gunakan untuk REST API murni, seperti yang diakses oleh aplikasi mobile atau aplikasi pihak ketiga. Pengguna akan login dan menerima token API yang unik. Token ini kemudian digunakan oleh klien untuk mengotentikasi setiap permintaan ke API dengan mengirimkannya dalam header Authorization: Bearer [token]. Sanctum akan memverifikasi token ini dan memastikan pengguna memiliki akses ke resource yang diminta.
2. Otentikasi SPA (Single Page Application): Sanctum juga menyediakan cara untuk mengotentikasi SPA Anda menggunakan sistem otentikasi berbasis sesi/cookie standar Laravel. Ini menghilangkan kebutuhan untuk mengirim token API secara manual dari JavaScript di setiap permintaan, karena sesi browser akan menangani otentikasi secara otomatis setelah login awal. Fitur ini memerlukan konfigurasi tambahan, seperti setting CORS dan middleware khusus, tetapi fokus kita kali ini adalah pada token API untuk REST API.

Penting untuk diingat bahwa Sanctum bukan pengganti Passport jika Anda membutuhkan fungsionalitas OAuth2 yang lengkap seperti Authorization Codes, Refresh Tokens, atau Grants untuk aplikasi pihak ketiga. Namun, jika yang Anda butuhkan adalah otentikasi berbasis token sederhana namun aman untuk API Anda, Sanctum adalah pilihan yang sangat tepat dan seringkali lebih efisien.

Persiapan Lingkungan Pengembangan

Sebelum kita mulai membuat REST API dengan Laravel Sanctum, pastikan Anda memiliki lingkungan pengembangan yang siap. Berikut adalah hal-hal yang perlu disiapkan:

1. Instalasi Laravel Project

   Jika Anda belum memiliki project Laravel, Anda bisa membuatnya dengan Composer:

   composer create-project laravel/laravel nama-project-api

   Setelah project terbuat, masuk ke direktori project Anda:

   cd nama-project-api

2. Konfigurasi Database

   Laravel membutuhkan database untuk menyimpan data pengguna dan token API. Buka file .env di root project Anda dan sesuaikan konfigurasi database sesuai dengan lingkungan Anda (misalnya MySQL, PostgreSQL).

   Contoh konfigurasi untuk MySQL:

   DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database_api
DB_USERNAME=root
DB_PASSWORD=

   Pastikan Anda telah membuat database nama_database_api di server database Anda.

Setelah persiapan ini, kita siap untuk menginstal dan mengkonfigurasi Laravel Sanctum.

Instalasi dan Konfigurasi Laravel Sanctum

Proses instalasi Laravel Sanctum sangat mudah. Ikuti langkah-langkah berikut:

1. Instalasi Paket Sanctum

   Jalankan perintah Composer berikut di terminal project Anda:

   composer require laravel/sanctum

   Perintah ini akan mengunduh dan menginstal paket Sanctum ke dalam project Anda.

2. Mempublikasikan File Konfigurasi dan Migrasi

   Setelah instalasi selesai, Anda perlu mempublikasikan file konfigurasi dan migrasi Sanctum. Jalankan perintah berikut:

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

   Perintah ini akan membuat file config/sanctum.php dan beberapa file migrasi di direktori database/migrations, termasuk migrasi untuk tabel personal_access_tokens. Tabel ini akan digunakan untuk menyimpan token API yang digenerate oleh Sanctum.

3. Menjalankan Migrasi Database

   Sekarang, jalankan migrasi database untuk membuat tabel personal_access_tokens:

   php artisan migrate

   Pastikan tidak ada error saat migrasi. Jika ada, periksa kembali konfigurasi database di file .env Anda.

4. Menambahkan Trait HasApiTokens ke Model User

   Agar model User Anda dapat menggunakan fungsionalitas token API dari Sanctum, Anda perlu menambahkan trait HasApiTokens. Buka file app/Models/User.php dan tambahkan trait tersebut:

   
   <?php
   
   namespace App\Models;
   
   use Illuminate\Contracts\Auth\MustVerifyEmail;
   use Illuminate\Database\Eloquent\Factories\HasFactory;
   use Illuminate\Foundation\Auth\User as Authenticatable;
   use Illuminate\Notifications\Notifiable;
   use Laravel\Sanctum\HasApiTokens; // Import HasApiTokens
   
   class User extends Authenticatable
   {
       use HasApiTokens, HasFactory, Notifiable; // Gunakan HasApiTokens
   
       /
        * The attributes that are mass assignable.
        *
        * @var array<int, string>
        */
       protected $fillable = [
           'name',
           'email',
           'password',
       ];
   
       /
        * The attributes that should be hidden for serialization.
        *
        * @var array<int, string>
        */
       protected $hidden = [
           'password',
           'remember_token',
       ];
   
       /
        * The attributes that should be cast.
        *
        * @var array<string, string>
        */
       protected $casts = [
           'email_verified_at' => 'datetime',
           'password' => 'hashed',
       ];
   }
   
   

   Dengan penambahan trait ini, objek User kini memiliki metode seperti createToken() dan tokens() yang esensial untuk manajemen token Sanctum.

Sanctum sekarang sudah terinstal dan siap digunakan di project Laravel Anda. Langkah selanjutnya adalah membuat endpoint untuk otentikasi.

Membuat Endpoint Otentikasi (Register & Login)

Kita akan membuat dua endpoint utama: satu untuk pendaftaran (register) pengguna baru dan satu untuk login pengguna yang sudah ada. Keduanya akan menghasilkan token API yang akan digunakan untuk mengakses resource yang dilindungi.

1. Membuat Controller API

   Buat sebuah controller untuk menangani logika otentikasi. Biasanya, kita menempatkan controller khusus API di subdirektori App/Http/Controllers/Api.

   php artisan make:controller Api/AuthController

2. Mendaftarkan Route API

   Buka file routes/api.php dan tambahkan route untuk register dan login:

   
   <?php
   
   use Illuminate\Http\Request;
   use Illuminate\Support\Facades\Route;
   use App\Http\Controllers\Api\AuthController; // Import AuthController
   
   /*
   |--------------------------------------------------------------------------
   | API Routes
   |--------------------------------------------------------------------------
   |
   | Here is where you can register API routes for your application. These
   | routes are loaded by the RouteServiceProvider and all of them will
   | be assigned to the "api" middleware group. Make something great!
   |
   */
   
   // Public routes (accessible without authentication)
   Route::post('/register', [AuthController::class, 'register']);
   Route::post('/login', [AuthController::class, 'login']);
   
   // Protected routes (require authentication)
   Route::middleware('auth:sanctum')->group(function () {
       Route::get('/user', function (Request $request) {
           return $request->user();
       });
       Route::post('/logout', [AuthController::class, 'logout']);
   });
   
   

   Di sini kita memisahkan route menjadi “public” (register, login) dan “protected” (user, logout). Route yang dilindungi akan menggunakan middleware auth:sanctum.

3. Implementasi Logika di AuthController

   Buka app/Http/Controllers/Api/AuthController.php dan isi dengan logika register, login, dan logout:

   
   <?php
   
   namespace App\Http\Controllers\Api;
   
   use App\Http\Controllers\Controller;
   use Illuminate\Http\Request;
   use App\Models\User;
   use Illuminate\Support\Facades\Hash;
   use Illuminate\Support\Facades\Auth;
   use Illuminate\Validation\ValidationException;
   
   class AuthController extends Controller
   {
       /
        * Handle user registration.
        *
        * @param  \Illuminate\Http\Request  $request
        * @return \Illuminate\Http\JsonResponse
        */
       public function register(Request $request)
       {
           try {
               $request->validate([
                   'name' => 'required|string|max:255',
                   'email' => 'required|string|email|max:255|unique:users',
                   'password' => 'required|string|min:8|confirmed',
               ]);
           } catch (ValidationException $e) {
               return response()->json([
                   'message' => 'Validasi gagal.',
                   'errors' => $e->errors()
               ], 422);
           }
   
           $user = User::create([
               'name' => $request->name,
               'email' => $request->email,
               'password' => Hash::make($request->password),
           ]);
   
           $token = $user->createToken('authToken')->plainTextToken;
   
           return response()->json([
               'message' => 'Registrasi berhasil.',
               'user' => $user,
               'token' => $token,
           ], 201);
       }
   
       /
        * Handle user login.
        *
        * @param  \Illuminate\Http\Request  $request
        * @return \Illuminate\Http\JsonResponse
        */
       public function login(Request $request)
       {
           try {
               $request->validate([
                   'email' => 'required|string|email',
                   'password' => 'required|string',
               ]);
           } catch (ValidationException $e) {
               return response()->json([
                   'message' => 'Validasi gagal.',
                   'errors' => $e->errors()
               ], 422);
           }
   
           if (!Auth::attempt($request->only('email', 'password'))) {
               return response()->json([
                   'message' => 'Email atau password salah.'
               ], 401);
           }
   
           $user = User::where('email', $request->email)->firstOrFail();
           
           // Hapus token lama sebelum membuat token baru (opsional, tergantung kebutuhan)
           // $user->tokens()->delete();
   
           $token = $user->createToken('authToken')->plainTextToken;
   
           return response()->json([
               'message' => 'Login berhasil.',
               'user' => $user,
               'token' => $token,
           ], 200);
       }
   
       /
        * Handle user logout (revoking current token).
        *
        * @param  \Illuminate\Http\Request  $request
        * @return \Illuminate\Http\JsonResponse
        */
       public function logout(Request $request)
       {
           // Mencabut token saat ini saja
           $request->user()->currentAccessToken()->delete();
   
           return response()->json([
               'message' => 'Logout berhasil.'
           ], 200);
       }
   }
   
   

   Beberapa poin penting dari kode di atas:

   • Validasi Input: Menggunakan $request->validate() untuk memastikan data yang diterima valid.
   • Registrasi: Membuat user baru, meng-hash password, dan kemudian menggunakan $user->createToken('authToken')->plainTextToken untuk membuat token API. 'authToken' adalah nama dari token tersebut, bisa diganti sesuai kebutuhan.
   • Login: Menggunakan Auth::attempt() untuk memverifikasi kredensial. Jika berhasil, akan mengambil objek user dan membuat token baru.
   • Logout: Menggunakan $request->user()->currentAccessToken()->delete() untuk mencabut token yang sedang digunakan user. Ini akan membuat token tersebut tidak valid lagi.
   • plainTextToken: Metode ini mengembalikan plain-text dari token yang baru dibuat. Bagian ini penting karena token ini yang akan disimpan dan digunakan oleh klien. Ingat, token ini hanya akan muncul saat pertama kali dibuat.

Sekarang, Anda bisa mencoba endpoint ini menggunakan tool seperti Postman atau Insomnia. Pastikan server Laravel Anda berjalan dengan php artisan serve.

Melindungi Endpoint API dengan Sanctum

Setelah kita memiliki endpoint otentikasi yang menghasilkan token, langkah selanjutnya adalah melindungi resource API lain agar hanya bisa diakses oleh pengguna yang sudah terotentikasi. Ini dilakukan dengan menggunakan middleware auth:sanctum.

Menggunakan Middleware auth:sanctum

Seperti yang sudah kita lihat di file routes/api.php sebelumnya, kita bisa melampirkan middleware auth:sanctum ke route atau grup route yang ingin dilindungi.

// Protected routes (require authentication)
Route::middleware('auth:sanctum')->group(function () {
    Route::get('/user', function (Request $request) {
        return $request->user();
    });
    
    Route::post('/logout', [AuthController::class, 'logout']);

    // Contoh endpoint lain yang dilindungi
    Route::get('/posts', [PostController::class, 'index']);
    Route::post('/posts', [PostController::class, 'store']);
});

Ketika sebuah permintaan masuk ke route yang dilindungi oleh auth:sanctum, Laravel Sanctum akan mencari token API di header Authorization (dengan format Bearer [token]). Jika token ditemukan dan valid, permintaan akan dilanjutkan. Jika tidak ditemukan, token tidak valid, atau token telah dicabut, Sanctum akan mengembalikan respons 401 Unauthorized.

Contoh Penggunaan dengan Endpoint Post

Mari kita bayangkan Anda memiliki endpoint untuk mengelola postingan. Pertama, buat controller untuk Post:

php artisan make:controller Api/PostController

Kemudian, tambahkan logika sederhana di dalamnya:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class PostController extends Controller
{
    public function index()
    {
        // Misalkan kita punya data post di database
        // Untuk contoh ini, kita hardcode saja
        $posts = [
            ['id' => 1, 'title' => 'Post Pertama', 'content' => 'Isi post pertama', 'author' => Auth::user()->name],
            ['id' => 2, 'title' => 'Post Kedua', 'content' => 'Isi post kedua', 'author' => Auth::user()->name],
        ];
        return response()->json(['posts' => $posts], 200);
    }

    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required|string|max:255',
            'content' => 'required|string',
        ]);

        // Simpan post ke database (untuk contoh ini kita hanya mengembalikan input)
        $newPost = [
            'id' => rand(3, 100), // ID random
            'title' => $request->title,
            'content' => $request->content,
            'author' => Auth::user()->name,
            'created_by_user_id' => Auth::id()
        ];

        return response()->json([
            'message' => 'Post berhasil dibuat.',
            'post' => $newPost
        ], 201);
    }
}

Dengan route dan controller ini, hanya pengguna yang sudah login dengan token Sanctum yang valid yang bisa mengakses /api/posts atau membuat post baru via /api/posts.

Menggunakan Token API dari Klien

Setelah pengguna berhasil login dan menerima token API, klien (misalnya aplikasi mobile, aplikasi desktop, atau aplikasi JavaScript frontend) harus menyimpan token tersebut dengan aman. Kemudian, untuk setiap permintaan ke endpoint API yang dilindungi, klien harus mengirimkan token ini dalam header HTTP.

Cara Mengirim Token

Token harus dikirim dalam header Authorization dengan format Bearer [TOKEN_YANG_DIDAPAT]. Contohnya:

Authorization: Bearer 1|abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890

Di mana 1|abcdef... adalah token yang Anda terima saat registrasi atau login.

Contoh dengan Postman

Jika Anda menggunakan Postman atau Insomnia untuk menguji API Anda:

1. Login/Register: Buat permintaan POST ke /api/login atau /api/register dengan email dan password di body (biasanya form-data atau raw/json).
2. Dapatkan Token: Setelah berhasil, Anda akan menerima respons yang berisi token. Salin token ini.
3. Akses Endpoint Terlindungi: Buat permintaan baru (misalnya GET ke /api/user atau /api/posts).
4. Tambahkan Header: Di tab “Headers” Postman, tambahkan key Authorization dan value Bearer [token_yang_disalin].
5. Kirim Permintaan: Anda sekarang seharusnya bisa mengakses endpoint yang dilindungi. Jika tidak ada token atau token salah, Anda akan menerima respons 401 Unauthorized.

Penting untuk diingat bahwa token API adalah kunci akses. Token ini harus ditangani dengan sangat hati-hati oleh klien: disimpan dengan aman (misalnya di secure storage pada mobile app, atau localStorage/sessionStorage untuk web tetapi dengan pertimbangan keamanan), dan selalu dikirim melalui koneksi HTTPS (SSL/TLS) untuk mencegah penyadapan.

Manajemen Token (Mencabut Token)

Kemampuan untuk mencabut token adalah fitur keamanan yang krusial. Ini memungkinkan Anda untuk membatalkan akses pengguna secara paksa, misalnya saat pengguna logout atau jika Anda mendeteksi aktivitas mencurigakan.

Laravel Sanctum menyediakan beberapa cara untuk mencabut token:

1. Mencabut Token Saat Ini (Logout)

   Seperti yang sudah kita implementasikan di method logout pada AuthController, Anda bisa mencabut token yang sedang digunakan oleh user yang melakukan permintaan:

   
   $request->user()->currentAccessToken()->delete();
   
   

   Perintah ini akan mencari token yang cocok dengan token yang dikirimkan dalam permintaan HTTP dan menghapusnya dari tabel personal_access_tokens.

2. Mencabut Semua Token Milik Pengguna

   Jika Anda ingin mencabut semua token yang pernah dikeluarkan untuk seorang pengguna (misalnya, jika pengguna mengubah password dan Anda ingin memaksa semua perangkat mereka logout), Anda bisa menggunakan:

   
   $user->tokens()->delete();
   
   

   Ini akan menghapus semua entri token yang terkait dengan user_id tersebut dari tabel personal_access_tokens. Ini adalah cara yang kuat untuk memastikan pengguna tersebut harus login kembali di semua perangkat.

3. Mencabut Token Berdasarkan Nama atau ID

   Setiap token yang dibuat dengan createToken('nama_token') memiliki nama. Anda bisa mencabut token berdasarkan nama:

   
   $user->tokens()->where('name', 'nama_token')->delete();
   
   

   Atau, jika Anda memiliki ID dari token tersebut (yang disimpan di database), Anda juga bisa mencabutnya:

   
   $user->tokens()->where('id', $tokenId)->delete();
   
   

   Fungsionalitas manajemen token ini sangat penting untuk menjaga keamanan dan kontrol akses terhadap API Anda.

Masalah yang Sering Terjadi

Dalam praktiknya, saat mengimplementasikan Laravel Sanctum, ada beberapa masalah umum yang sering dihadapi developer. Memahami penyebab dan solusinya akan mempercepat proses debugging Anda.

1. 401 Unauthorized Saat Mengakses Endpoint Terlindungi

   Ini adalah respons paling umum saat ada masalah otentikasi. Penyebabnya bisa beragam:

   • Token Hilang atau Salah Format: Klien tidak mengirim header Authorization: Bearer [token], atau token yang dikirim salah/tidak valid. Pastikan Anda menyertakan “Bearer” sebelum token dan ada spasi di antaranya.
   • Token Kadaluarsa atau Dicabut: Token yang Anda gunakan mungkin sudah kadaluarsa (jika Anda mengimplementasikan masa berlaku token) atau sudah dicabut (misalnya saat logout).
   • Middleware Tidak Terpasang: Pastikan route atau grup route Anda memiliki middleware auth:sanctum.
   • Trait HasApiTokens Hilang: Pastikan model User Anda mengimplementasikan trait HasApiTokens.

   Solusi: Periksa request yang dikirim dari klien, pastikan format header Authorization sudah benar. Cek log Laravel untuk pesan error yang lebih spesifik. Lakukan dd($request->user()) di dalam controller endpoint yang dilindungi untuk melihat apakah user berhasil diotentikasi.

2. TokenMismatchException (Jika Menggunakan untuk SPA)

   Meskipun kita fokus pada token API, banyak developer yang juga menggunakan Sanctum untuk SPA dan sering menemui error ini. Error ini terjadi ketika Laravel tidak bisa memverifikasi token CSRF.

   Solusi: Pastikan Anda telah mengkonfigurasi CORS dengan benar di config/cors.php dan config/sanctum.php. Pastikan juga EnsureFrontendRequestsAreStateful middleware aktif dan klien mengirimkan cookie CSRF yang benar (via /sanctum/csrf-cookie).

3. Kesalahan Migrasi Database

   Saat menjalankan php artisan migrate, mungkin ada error jika konfigurasi database Anda salah atau ada masalah dengan tabel.

   Solusi: Periksa file .env Anda, pastikan DB_DATABASE, DB_USERNAME, dan DB_PASSWORD sudah benar. Pastikan database yang Anda sebutkan sudah dibuat secara manual. Anda bisa mencoba php artisan migrate:rollback lalu php artisan migrate lagi.

4. Token Tidak Muncul Saat Login/Register

   Anda mungkin lupa menggunakan plainTextToken saat membuat token.

   Solusi: Pastikan baris kode Anda seperti $token = $user->createToken('authToken')->plainTextToken;. Jika Anda hanya memanggil createToken(), itu akan mengembalikan objek NewAccessToken, bukan string token-nya.

5. CORS (Cross-Origin Resource Sharing) Issues

   Jika frontend Anda (misalnya React, Vue) berada di domain atau port yang berbeda dari backend Laravel Anda, Anda mungkin akan menemui error CORS.

   Solusi: Pastikan Anda telah menginstal dan mengkonfigurasi paket laravel/cors. Di file config/cors.php, pastikan paths dan allowed_origins telah diatur dengan benar untuk mengizinkan permintaan dari domain frontend Anda. Middleware CORS harus ditempatkan sebelum middleware lain di App\Http\Kernel.php.

Pengalaman dan Pertimbangan Praktis

Sebagai seorang praktisi, saya telah menggunakan Laravel Sanctum di berbagai proyek. Ada beberapa pengalaman dan pertimbangan penting yang perlu Anda perhatikan untuk memastikan API Anda tidak hanya berfungsi, tetapi juga aman dan scalable.

1. Masa Berlaku Token (Token Expiration)

   Secara default, token Sanctum tidak memiliki masa berlaku (expires_at di tabel personal_access_tokens adalah null). Ini berarti token akan valid selamanya sampai dicabut. Dalam beberapa kasus, ini mungkin bukan praktik terbaik dari segi keamanan.

   Pertimbangan: Untuk meningkatkan keamanan, terutama jika token dapat disalahgunakan, Anda bisa menambahkan logika kedaluwarsa. Anda bisa menambahkan kolom expires_at ke tabel personal_access_tokens melalui migrasi dan mengaturnya secara manual saat membuat token:

   
   $token = $user->createToken('authToken', ['*'], now()->addMinutes(60))->plainTextToken;
   
   

   Ini akan membuat token kedaluarsa dalam 60 menit. Jangan lupa untuk memperbarui migrasi dan model untuk mendukung fitur ini.

2. Scope Token

   Sanctum memungkinkan Anda untuk mendefinisikan “scope” atau cakupan token. Ini sangat berguna jika Anda ingin memberikan akses yang berbeda berdasarkan jenis token.

   Contoh: Anda bisa memiliki token dengan scope ['read', 'write'] atau ['admin']. Ini memberikan kontrol yang lebih granular atas apa yang bisa dilakukan token tersebut. Saya pribadi sering menggunakan ini untuk membedakan antara token yang digunakan oleh mobile app (scope terbatas) dan token untuk admin panel (scope lebih luas).

   
   // User can read and update posts, but not delete
   $token = $user->createToken('mobile-token', ['post:read', 'post:update'])->plainTextToken;
   
   

   Kemudian Anda bisa memeriksa scope ini di middleware atau controller:

   
   Route::middleware(['auth:sanctum', 'ability:post:read'])->get('/posts', function (Request $request) {
       // Hanya bisa diakses jika token memiliki scope 'post:read'
   });
   
   

3. Penanganan Error yang Konsisten

   Pastikan API Anda mengembalikan respons error yang konsisten dan informatif, terutama untuk kesalahan otentikasi (401 Unauthorized), validasi (422 Unprocessable Entity), atau server (500 Internal Server Error).

   Saran: Buat struktur respons error standar (misalnya, selalu berupa JSON dengan kunci message dan errors). Laravel sudah cukup baik dalam hal ini, tetapi Anda bisa mengkustomisasi exception handler di App/Exceptions/Handler.php.

4. Keamanan Token di Sisi Klien

   Ini adalah salah satu aspek terpenting. Jika token API jatuh ke tangan yang salah, itu sama saja dengan memberikan kunci rumah Anda. Klien harus menyimpan token dengan aman:

   • Web Browser (SPA): Jangan simpan token di localStorage atau sessionStorage jika itu adalah token API yang digunakan sebagai “Bearer” header. Lebih baik gunakan otentikasi berbasis sesi/cookie dari Sanctum untuk SPA yang mana Laravel akan mengurus token CSRF dan cookie otentikasi. Jika terpaksa menggunakan localStorage, selalu pertimbangkan risiko XSS.
   • Aplikasi Mobile: Gunakan secure storage yang disediakan oleh sistem operasi (misalnya Keychain di iOS, Keystore di Android).
   • Aplikasi Desktop/Server: Simpan token di lokasi yang dilindungi, tidak dalam teks biasa.

   Selalu gunakan HTTPS/SSL untuk semua komunikasi API Anda untuk mencegah penyadapan token saat dalam perjalanan.

5. Rate Limiting

   Untuk melindungi API Anda dari serangan brute-force atau penyalahgunaan, terapkan rate limiting. Laravel menyediakan fitur rate limiting yang sangat mudah digunakan.

   Implementasi: Anda bisa menambahkan throttle:api middleware ke grup route API Anda di app/Providers/RouteServiceProvider.php atau secara langsung di routes/api.php.

   
   // Di RouteServiceProvider.php
   protected function configureRateLimiting()
   {
       RateLimiter::for('api', function (Request $request) {
           return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
       });
   }
   
   

   Ini akan membatasi 60 permintaan per menit per pengguna atau per IP jika tidak ada pengguna yang login.

6. Sanctum vs Passport: Kapan Memilih yang Mana?

   Pilih Sanctum jika:

   • Anda membuat API untuk aplikasi Anda sendiri (mobile app, SPA dengan Laravel sebagai backend API).
   • Anda hanya membutuhkan otentikasi token sederhana atau otentikasi berbasis sesi untuk SPA.
   • Anda ingin solusi yang ringan dan mudah di-setup.

   Pilih Passport jika:

   • Anda perlu mengimplementasikan otentikasi OAuth2 secara penuh (Authorization Code, Client Credentials, Implicit, Password Grant).
   • Anda ingin memberikan akses API ke aplikasi pihak ketiga yang memerlukan alur otorisasi standar OAuth2.
   • Anda membutuhkan fitur manajemen klien dan scope yang lebih canggih.

   Dalam pengalaman saya, untuk 90% kasus API yang saya kembangkan untuk aplikasi internal atau mobile app, Sanctum sudah lebih dari cukup dan jauh lebih efisien.

FAQ

Apa perbedaan utama antara Laravel Sanctum dan Laravel Passport?

Laravel Sanctum adalah solusi otentikasi API yang ringan, berfokus pada token API sederhana untuk aplikasi mobile atau SPA, dan otentikasi berbasis sesi untuk SPA. Laravel Passport adalah implementasi penuh OAuth2 server, yang menyediakan berbagai “grant” OAuth2 untuk otorisasi aplikasi pihak ketiga yang lebih kompleks.

Apakah saya bisa menggunakan Laravel Sanctum untuk SPA dan API murni secara bersamaan?

Ya, Sanctum dirancang untuk mendukung keduanya. Untuk SPA, Anda akan mengandalkan cookie dan sesi Laravel, sementara untuk API murni (misalnya aplikasi mobile), Anda akan menggunakan token API. Konfigurasi sanctum.php dan EnsureFrontendRequestsAreStateful middleware adalah kuncinya untuk SPA.

Bagaimana cara mengamankan token API setelah diterima oleh klien?

Token harus disimpan dengan aman di sisi klien. Untuk aplikasi mobile, gunakan secure storage sistem operasi (Keychain iOS, Keystore Android). Untuk aplikasi web, hindari localStorage untuk token API yang sensitif jika menggunakan otentikasi Bearer, lebih disarankan menggunakan otentikasi berbasis sesi/cookie dengan Laravel Sanctum untuk SPA. Selalu gunakan HTTPS untuk transmisi token.

Apakah token API Sanctum bisa kedaluarsa secara otomatis?

Secara default, token yang dibuat dengan createToken() tidak memiliki masa berlaku dan akan valid selamanya hingga dicabut secara manual. Anda bisa menambahkan kedaluwarsa secara manual saat membuat token dengan menambahkan parameter waktu (misalnya now()->addMinutes(60)).

Bisakah saya membatasi hak akses token menggunakan scope?

Tentu, Laravel Sanctum mendukung scope token. Saat membuat token, Anda bisa mendefinisikan array scope (misalnya ['post:read', 'post:write']). Kemudian, Anda bisa memeriksa scope ini di route atau middleware menggunakan abilities atau tokenCan.

Kesimpulan

Laravel Sanctum adalah pilihan yang sangat solid dan efisien untuk kebutuhan otentikasi REST API di Laravel. Dengan setup yang relatif sederhana dan fungsionalitas yang kuat untuk manajemen token, ia memungkinkan developer untuk membangun API yang aman dengan cepat, baik untuk aplikasi mobile, aplikasi pihak ketiga, maupun SPA. Saya pribadi sangat merekomendasikan Sanctum untuk sebagian besar proyek API yang tidak memerlukan kompleksitas penuh dari spesifikasi OAuth2.

Penting untuk diingat bahwa keamanan API tidak hanya berhenti pada otentikasi. Selalu terapkan praktik terbaik seperti validasi input yang ketat, penggunaan HTTPS, penanganan error yang konsisten, dan rate limiting untuk memastikan API Anda tetap tangguh dan terlindungi dari potensi ancaman. Dengan panduan ini, Anda kini memiliki dasar yang kuat untuk mulai membuat REST API Anda sendiri menggunakan Laravel Sanctum.

TAGS: Laravel, Sanctum, REST API, API Authentication, PHP, Web Development, Backend Development, Token Authentication, Developer Tools, Coding Tutorial

Baca Juga

• Panduan Lengkap Belajar Coding untuk Pemula hingga Profesional

Related posts:

Cara Menggunakan ChatGPT untuk Coding (Studi Kasus: Membuat Aplikasi Manajemen Keuangan dari Nol) Fitur Cursor AI yang Jarang Diketahui Programmer: Rahasia Produktivitas Coding Modern Perbedaan List, Tuple, Set, dan Dictionary di Python: Panduan Lengkap untuk Developer Cara Mengembalikan Commit yang Terlanjur Dipush: Panduan Aman Git untuk Developer