Laravel Sanctum Authentication Tutorial: Panduan Lengkap untuk Keamanan Aplikasi

Laravel Sanctum adalah solusi autentikasi ringan yang sangat berguna untuk aplikasi Laravel, terutama jika Anda sedang membangun API (Application Programming Interface) atau aplikasi Single Page Application (SPA). Dengan kemampuannya yang sederhana namun kuat, Sanctum memungkinkan Anda mengamankan aplikasi Anda tanpa perlu menggunakan solusi autentikasi yang lebih kompleks seperti OAuth 2.0. Artikel ini akan menjadi Laravel Sanctum Authentication Tutorial yang lengkap, memberikan panduan langkah demi langkah untuk mengimplementasikan dan memanfaatkan Sanctum secara optimal untuk keamanan aplikasi Anda. Mari kita mulai!

Daftar Isi

Apa Itu Laravel Sanctum dan Mengapa Anda Harus Menggunakannya?
Persiapan: Instalasi dan Konfigurasi Laravel Sanctum
Mengkonfigurasi Model User dan Database untuk Autentikasi Sanctum
Membuat API Routes dan Controller untuk Autentikasi (Login dan Registrasi)
Melindungi API Routes dengan Sanctum Middleware
Menangani Authentication Tokens: Pembuatan dan Pencabutan
Integrasi dengan SPA (Single Page Application) Menggunakan Sanctum
Customisasi: Mengubah Konfigurasi Default Laravel Sanctum
Praktik Terbaik: Tips Keamanan Tambahan untuk Laravel Sanctum
Debugging dan Troubleshooting Umum pada Laravel Sanctum
Laravel Sanctum vs. Laravel Passport: Kapan Menggunakan Masing-Masing?
Kesimpulan: Mengamankan Aplikasi Laravel Anda dengan Laravel Sanctum

1. Apa Itu Laravel Sanctum dan Mengapa Anda Harus Menggunakannya?

Sebelum kita masuk ke tutorial implementasi, mari kita pahami terlebih dahulu apa sebenarnya Laravel Sanctum itu. Sederhananya, Sanctum adalah paket autentikasi berbasis token yang dirancang untuk:

API Authentication: Memberikan akses aman ke API Anda untuk aplikasi frontend (seperti SPA, aplikasi mobile, atau aplikasi pihak ketiga).
SPA Authentication: Memungkinkan aplikasi Single Page Application untuk melakukan autentikasi menggunakan cookie.
Mobile App Authentication: Digunakan juga untuk memberikan akses aman ke aplikasi mobile.

Mengapa Anda Harus Menggunakan Laravel Sanctum?

Sanctum menawarkan beberapa keuntungan yang membuatnya menjadi pilihan menarik:

Laravel Livewire Tutorial Bahasa Indonesia: Interaktivitas Tanpa Refresh Halaman

October 3, 2025

Ringan dan Sederhana: Konfigurasi dan implementasi jauh lebih mudah dibandingkan OAuth 2.0. Ini membuatnya ideal untuk proyek yang tidak membutuhkan fitur kompleks OAuth.
Aman: Menggunakan enkripsi dan hash yang kuat untuk melindungi token dan informasi pengguna.
Fleksibel: Dapat digunakan untuk berbagai jenis aplikasi, mulai dari API sederhana hingga SPA yang kompleks.
Gratis dan Open Source: Tersedia gratis dan dapat diakses serta dimodifikasi sesuai kebutuhan Anda.
Integrasi Laravel yang Mulus: Dirancang khusus untuk Laravel, sehingga integrasinya sangat mudah dan intuitif.
CSRF Protection untuk SPA: Menyediakan perlindungan Cross-Site Request Forgery (CSRF) untuk SPA Anda.

Singkatnya, jika Anda membutuhkan solusi autentikasi yang cepat, aman, dan mudah diimplementasikan untuk API atau SPA Laravel Anda, Sanctum adalah pilihan yang sangat baik. Ini adalah game-changer dalam autentikasi API Laravel!

2. Persiapan: Instalasi dan Konfigurasi Laravel Sanctum

Langkah pertama dalam Laravel Sanctum Authentication Tutorial ini adalah instalasi dan konfigurasi Sanctum. Prosesnya cukup sederhana dan hanya membutuhkan beberapa perintah Composer.

Instalasi Laravel Sanctum:

Buka terminal Anda dan arahkan ke direktori proyek Laravel Anda. Kemudian, jalankan perintah berikut:

composer require laravel/sanctum

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

Konfigurasi Laravel Sanctum:

Setelah instalasi selesai, Anda perlu menjalankan migration untuk membuat tabel yang dibutuhkan oleh Sanctum. Jalankan perintah berikut:

php artisan migrate

Perintah ini akan membuat tabel personal_access_tokens di database Anda. Tabel ini akan digunakan untuk menyimpan token autentikasi Sanctum.

Selanjutnya, Anda perlu menambahkan Sanctum::routes(); ke dalam file routes/api.php Anda:

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use LaravelSanctumSanctum;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!
|
*/

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

Sanctum::routes();

Terakhir, tambahkan HasApiTokens trait ke model User Anda. Buka file app/Models/User.php dan tambahkan trait berikut:

<?php

namespace AppModels;

use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens; // Tambahkan baris ini

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    // ... kode lainnya ...
}

Dengan langkah-langkah ini, Anda telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum di proyek Anda. Sekarang kita siap untuk melangkah ke konfigurasi model User dan database.

3. Mengkonfigurasi Model User dan Database untuk Autentikasi Sanctum

Bagian ini dari Laravel Sanctum Authentication Tutorial fokus pada bagaimana mengkonfigurasi model User dan database Anda untuk bekerja dengan autentikasi Sanctum.

Memastikan Kolom yang Dibutuhkan Ada di Tabel users:

Pastikan tabel users di database Anda memiliki kolom-kolom yang dibutuhkan untuk autentikasi, seperti:

id: Primary key untuk user.
name: Nama user.
email: Alamat email user (harus unique).
password: Password user (harus di-hash).
email_verified_at: Tanggal email diverifikasi (bisa null).
created_at: Tanggal user dibuat.
updated_at: Tanggal user diupdate.

Jika Anda menggunakan migration default dari Laravel, kolom-kolom ini seharusnya sudah ada. Jika tidak, Anda perlu menambahkan migration untuk menambahkan kolom-kolom tersebut.

Membuat Seeder untuk Menambahkan User Awal (Opsional):

Untuk pengujian, Anda mungkin ingin membuat seeder untuk menambahkan beberapa user awal ke database Anda. Buat file seeder baru (misalnya UserSeeder.php) menggunakan perintah berikut:

php artisan make:seeder UserSeeder

Kemudian, buka file database/seeders/UserSeeder.php dan tambahkan kode berikut:

<?php

namespace DatabaseSeeders;

use IlluminateDatabaseSeeder;
use AppModelsUser;
use IlluminateSupportFacadesHash;

class UserSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        User::create([
            'name' => 'John Doe',
            'email' => '[email protected]',
            'password' => Hash::make('password'),
        ]);

        User::create([
            'name' => 'Jane Smith',
            'email' => '[email protected]',
            'password' => Hash::make('password'),
        ]);
    }
}

Pastikan Anda mengimpor Hash facade dan model User di bagian atas file. Kemudian, panggil seeder ini di DatabaseSeeder.php:

<?php

namespace DatabaseSeeders;

use IlluminateDatabaseSeeder;

class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        $this->call([
            UserSeeder::class,
        ]);
    }
}

Terakhir, jalankan seeder:

php artisan db:seed

Ini akan menambahkan dua user ke database Anda yang dapat Anda gunakan untuk pengujian login. Dengan model User dan database Anda yang sudah dikonfigurasi, kita siap untuk membuat API routes dan controller untuk autentikasi.

4. Membuat API Routes dan Controller untuk Autentikasi (Login dan Registrasi)

Bagian penting dari Laravel Sanctum Authentication Tutorial adalah membuat API routes dan controller untuk menangani proses autentikasi (login dan registrasi).

Membuat Controller Autentikasi:

Buat controller baru untuk menangani logika autentikasi. Anda bisa menggunakan perintah berikut:

php artisan make:controller AuthController

Kemudian, buka file app/Http/Controllers/AuthController.php dan tambahkan kode berikut:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;
use AppModelsUser;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;
use IlluminateSupportFacadesAuth;

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

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

    public function logout(Request $request) {
        auth()->user()->tokens()->delete();

        return [
            'message' => 'You have successfully logged out and the token was successfully deleted'
        ];
    }
}

Penjelasan Kode:

register(Request $request):
- Menerima data registrasi (nama, email, password).
- Melakukan validasi data menggunakan Validator.
- Membuat user baru menggunakan User::create().
- Membuat token autentikasi menggunakan $user->createToken('auth_token')->plainTextToken.
- Mengembalikan token akses dan tipe token (Bearer) dalam format JSON.
login(Request $request):
- Menerima data login (email, password).
- Mencoba melakukan autentikasi menggunakan Auth::attempt().
- Jika autentikasi gagal, mengembalikan error 401.
- Jika autentikasi berhasil, mengambil user dari database.
- Membuat token autentikasi menggunakan $user->createToken('auth_token')->plainTextToken.
- Mengembalikan token akses dan tipe token (Bearer) dalam format JSON.
- logout(Request $request):
  - Menghapus semua token autentikasi user saat ini.

Membuat API Routes:

Buka file routes/api.php dan tambahkan routes berikut:

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersAuthController;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!
|
*/

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
Route::post('/logout', [AuthController::class, 'logout'])->middleware('auth:sanctum');

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

Penjelasan Kode:

/register: Route untuk registrasi user.
/login: Route untuk login user.
/logout: Route untuk logout user. Route ini dilindungi oleh middleware auth:sanctum, yang berarti hanya user yang sudah login dan memiliki token yang valid yang dapat mengakses route ini.
/user: Route untuk mendapatkan informasi user yang sedang login. Route ini juga dilindungi oleh middleware auth:sanctum.

Dengan controller dan routes yang sudah dibuat, Anda sekarang dapat melakukan registrasi dan login user melalui API. Selanjutnya, kita akan belajar bagaimana melindungi API routes dengan Sanctum middleware.

5. Melindungi API Routes dengan Sanctum Middleware

Salah satu fitur utama Laravel Sanctum adalah kemampuannya untuk melindungi API routes dengan mudah menggunakan middleware. Ini sangat penting untuk memastikan bahwa hanya user yang terautentikasi yang dapat mengakses data dan fungsionalitas sensitif. Bagian ini dari Laravel Sanctum Authentication Tutorial akan membahas bagaimana cara menggunakan Sanctum middleware.

Menggunakan auth:sanctum Middleware:

Seperti yang telah kita lihat pada bagian sebelumnya, Anda dapat melindungi API routes dengan menggunakan middleware auth:sanctum. Middleware ini memeriksa apakah request memiliki token autentikasi yang valid. Jika tidak, request akan ditolak dan user akan mendapatkan respons error 401 (Unauthorized).

Contoh Penggunaan Middleware:

Kita sudah menggunakan middleware auth:sanctum pada route /logout dan /user di file routes/api.php:

Route::post('/logout', [AuthController::class, 'logout'])->middleware('auth:sanctum');

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

Anda juga dapat mengelompokkan beberapa routes di bawah middleware yang sama:

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/profile', [UserController::class, 'profile']);
    Route::put('/profile', [UserController::class, 'updateProfile']);
    // Tambahkan routes lain yang membutuhkan autentikasi di sini
});

Dalam contoh di atas, semua routes yang didefinisikan di dalam group() akan dilindungi oleh middleware auth:sanctum.

Bagaimana Middleware auth:sanctum Bekerja:

Ketika request masuk ke route yang dilindungi oleh middleware auth:sanctum, middleware akan melakukan hal berikut:

Mencari Token: Mencari token autentikasi di header Authorization (dengan format Bearer <token>) atau di cookie XSRF-TOKEN (jika digunakan untuk SPA).
Memvalidasi Token: Memvalidasi token tersebut terhadap database untuk memastikan bahwa token tersebut valid dan belum dicabut.
Mengautentikasi User: Jika token valid, middleware akan mengambil user yang terkait dengan token tersebut dan menetapkannya ke properti $request->user().
Melanjutkan Request: Request akan dilanjutkan ke controller dan action yang dituju.

Jika token tidak ditemukan atau tidak valid, middleware akan menghentikan request dan mengembalikan respons error 401 (Unauthorized).

Penting: Pastikan Anda selalu melindungi API routes yang sensitif dengan middleware auth:sanctum untuk menjaga keamanan aplikasi Anda. Dengan pemahaman ini, mari kita lanjutkan ke pembahasan mengenai pembuatan dan pencabutan token autentikasi.

6. Menangani Authentication Tokens: Pembuatan dan Pencabutan

Bagian ini dari Laravel Sanctum Authentication Tutorial akan membahas secara detail tentang bagaimana menangani token autentikasi di Laravel Sanctum, termasuk proses pembuatan dan pencabutan token.

Pembuatan Token:

Seperti yang telah kita lihat pada bagian sebelumnya, token autentikasi dibuat menggunakan method createToken() pada model User. Method ini menghasilkan token yang aman dan unik untuk setiap user.

$token = $user->createToken('auth_token')->plainTextToken;

Penjelasan Kode:

$user->createToken('auth_token'): Membuat instance NewAccessToken yang berisi token yang dienkripsi. Parameter 'auth_token' adalah nama token. Anda bisa menggunakan nama yang berbeda untuk token yang berbeda, misalnya 'api_token', 'mobile_token', dll.
->plainTextToken: Mengembalikan token dalam format plain text. Penting: Token ini hanya akan ditampilkan sekali. Anda harus menyimpan token ini di sisi klien (misalnya di local storage atau cookie) karena Anda tidak akan bisa mendapatkannya lagi setelah ini.

Pencabutan Token:

Terkadang, Anda perlu mencabut token autentikasi user. Misalnya, ketika user logout, mengganti password, atau jika token tersebut dicuri. Sanctum menyediakan beberapa cara untuk mencabut token:

Mencabut Token User Saat Ini:

Di controller AuthController yang sudah kita buat, terdapat method logout() yang mencabut semua token user yang sedang login:
```
public function logout(Request $request) {
    auth()->user()->tokens()->delete();

    return [
        'message' => 'You have successfully logged out and the token was successfully deleted'
    ];
}
```
Kode ini menggunakan auth()->user()->tokens()->delete() untuk menghapus semua token yang terkait dengan user yang sedang login.

Mencabut Token Tertentu:

Anda juga dapat mencabut token tertentu berdasarkan ID-nya. Misalnya, jika Anda ingin mencabut token dengan ID tertentu:

$token = $request->user()->tokens()->where('id', $tokenId)->first();

if ($token) {
    $token->delete();
    return response()->json(['message' => 'Token revoked successfully']);
} else {
    return response()->json(['message' => 'Token not found'], 404);
}

Mencabut Semua Token untuk User Tertentu:

Anda dapat mencabut semua token untuk user tertentu (misalnya, melalui panel admin):
```
$user = User::find($userId);
$user->tokens()->delete();
```

Penting:

Keamanan Token: Selalu perlakukan token autentikasi sebagai informasi sensitif. Jangan pernah menampilkannya di log, mengirimkannya melalui email, atau menyimpannya di tempat yang tidak aman.
Masa Berlaku Token: Sanctum tidak menyediakan fitur masa berlaku token secara default. Anda perlu mengimplementasikan fitur ini sendiri jika dibutuhkan. Salah satu caranya adalah dengan menambahkan kolom expires_at di tabel personal_access_tokens dan memvalidasi token berdasarkan kolom ini.
Refresh Token: Untuk meningkatkan keamanan, Anda bisa mengimplementasikan refresh token. Refresh token adalah token jangka panjang yang digunakan untuk mendapatkan token akses baru tanpa meminta user untuk login kembali. Namun, implementasi refresh token lebih kompleks dan tidak disediakan secara default oleh Sanctum.

Dengan pemahaman yang mendalam tentang pembuatan dan pencabutan token, Anda dapat mengelola sesi user dan mengamankan aplikasi Anda dengan lebih efektif. Selanjutnya, kita akan membahas bagaimana mengintegrasikan Sanctum dengan Single Page Application (SPA).

7. Integrasi dengan SPA (Single Page Application) Menggunakan Sanctum

Laravel Sanctum dirancang untuk bekerja dengan baik dengan Single Page Application (SPA). Namun, ada beberapa hal penting yang perlu diperhatikan agar integrasi berjalan dengan lancar dan aman. Bagian ini dari Laravel Sanctum Authentication Tutorial akan memandu Anda melalui proses integrasi Sanctum dengan SPA.

Menggunakan Cookie untuk Autentikasi SPA:

Sanctum menggunakan cookie untuk mengautentikasi SPA. Ini berarti Anda tidak perlu menyimpan token akses di local storage atau cookie secara manual. Sanctum akan secara otomatis menangani penyimpanan dan pengiriman token melalui cookie.

Konfigurasi CORS:

Karena SPA biasanya berjalan di domain yang berbeda dengan API, Anda perlu mengkonfigurasi Cross-Origin Resource Sharing (CORS) agar browser mengizinkan request dari SPA ke API Anda. Anda dapat mengkonfigurasi CORS menggunakan paket fruitcake/laravel-cors.

Instal paket fruitcake/laravel-cors:

composer require fruitcake/laravel-cors

Kemudian, tambahkan middleware HandleCors ke kernel HTTP Anda ( app/Http/Kernel.php ):

protected $middleware = [
    // ...
    FruitcakeCorsHandleCors::class,
];

Terakhir, konfigurasikan CORS di file config/cors.php. Contoh konfigurasi:

return [
    'paths' => ['api/*'],
    'allowed_methods' => ['*'],
    'allowed_origins' => ['http://localhost:3000', 'https://your-spa-domain.com'], // Ganti dengan domain SPA Anda
    'allowed_origins_patterns' => [],
    'allowed_headers' => ['*'],
    'exposed_headers' => [],
    'max_age' => 0,
    'supports_credentials' => true,
];

Penjelasan Konfigurasi CORS:

paths: Menentukan route API yang akan menerapkan konfigurasi CORS ini.
allowed_methods: Menentukan HTTP methods yang diizinkan (GET, POST, PUT, DELETE, dll.).
allowed_origins: Menentukan domain SPA yang diizinkan untuk mengakses API. Penting: Ganti http://localhost:3000 dan https://your-spa-domain.com dengan domain SPA Anda.
supports_credentials: Harus diatur ke true agar cookie dapat dikirim bersama dengan request.

Konfigurasi Sanctum:

Pastikan Anda telah mengkonfigurasi SESSION_DOMAIN di file .env Anda agar sesuai dengan domain aplikasi Anda. Ini penting untuk cookie session dan CSRF yang benar. Contoh:

SESSION_DOMAIN=.example.com

Jika aplikasi Anda berjalan di subdomain (misalnya api.example.com), atur SESSION_DOMAIN ke .example.com agar cookie dapat diakses oleh semua subdomain.

CSRF Protection:

Sanctum menyediakan perlindungan Cross-Site Request Forgery (CSRF) untuk SPA. Ketika user pertama kali mengakses aplikasi, Sanctum akan mengirimkan cookie XSRF-TOKEN yang berisi token CSRF. SPA harus mengirimkan token ini di header X-XSRF-TOKEN pada setiap request POST, PUT, DELETE, dan PATCH.

Banyak framework SPA, seperti Vue.js dengan Axios, secara otomatis menangani pengiriman header X-XSRF-TOKEN. Pastikan Anda telah mengkonfigurasi framework SPA Anda untuk mengirimkan header ini.

Contoh Integrasi dengan Axios (Vue.js):

import axios from 'axios';

axios.defaults.baseURL = 'http://your-api-domain.com/api'; // Ganti dengan domain API Anda
axios.defaults.withCredentials = true; // Penting untuk mengirim cookie

// ... kode login ...
axios.post('/login', {
    email: this.email,
    password: this.password
})
.then(response => {
    // ... proses login berhasil ...
})
.catch(error => {
    // ... proses login gagal ...
});

Penjelasan Kode:

axios.defaults.baseURL: Mengatur base URL untuk semua request Axios. Ganti http://your-api-domain.com/api dengan domain API Anda.
axios.defaults.withCredentials = true: Mengaktifkan pengiriman cookie dengan setiap request. Ini penting agar Sanctum dapat mengautentikasi user menggunakan cookie.

Dengan konfigurasi CORS dan CSRF yang benar, SPA Anda akan dapat berinteraksi dengan API Laravel Anda dengan aman menggunakan Sanctum. Sekarang kita akan membahas bagaimana Anda dapat melakukan customisasi pada konfigurasi default Laravel Sanctum.

8. Customisasi: Mengubah Konfigurasi Default Laravel Sanctum

Laravel Sanctum menyediakan beberapa opsi konfigurasi yang memungkinkan Anda untuk mengubah perilaku defaultnya sesuai dengan kebutuhan aplikasi Anda. Bagian ini dari Laravel Sanctum Authentication Tutorial akan membahas beberapa opsi konfigurasi yang paling umum digunakan.

Menerbitkan File Konfigurasi:

File konfigurasi Sanctum ( config/sanctum.php ) tidak diterbitkan secara default. Jika Anda ingin melakukan customisasi, Anda perlu menerbitkan file konfigurasi tersebut menggunakan perintah berikut:

php artisan vendor:publish --tag=sanctum-config

Perintah ini akan membuat file config/sanctum.php di direktori konfigurasi Anda.

Opsi Konfigurasi yang Tersedia:

Berikut adalah beberapa opsi konfigurasi yang paling umum digunakan di file config/sanctum.php:

stateful: Array domain yang dianggap “stateful”. Request dari domain stateful akan menggunakan cookie untuk autentikasi, sementara request dari domain lain akan menggunakan header Authorization. Secara default, stateful berisi domain aplikasi Anda (yang diambil dari APP_URL di file .env).
```
'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', sprintf(
    '%s%s',
    parse_url(config('app.url'), PHP_URL_HOST),
    $this->isValidUrl(config('app.url')) ? '' : '|localhost,127.0.0.1'
))),
```
Anda dapat menambahkan domain SPA Anda ke array ini jika Anda ingin menggunakan cookie untuk autentikasi SPA.
expiration: Masa berlaku token (dalam menit). Secara default, token tidak memiliki masa berlaku. Anda dapat mengatur masa berlaku token jika Anda ingin token secara otomatis kadaluarsa setelah periode waktu tertentu. Penting: Sanctum tidak secara otomatis menangani penghapusan token yang kadaluarsa. Anda perlu mengimplementasikan logika penghapusan token yang kadaluarsa sendiri (misalnya, menggunakan scheduled task).
```
'expiration' => null, // Secara default tidak ada masa berlaku
```
middleware: Array middleware yang akan diterapkan ke routes Sanctum. Secara default, middleware yang digunakan adalah api.
```
'middleware' => [
    'verify_csrf_token' => AppHttpMiddlewareVerifyCsrfToken::class,
    'encrypt_cookies' => AppHttpMiddlewareEncryptCookies::class,
],
```
Anda dapat menambahkan atau mengubah middleware ini sesuai dengan kebutuhan Anda.

Contoh Customisasi:

Misalnya, jika Anda ingin mengatur masa berlaku token menjadi 1 jam (60 menit), Anda dapat mengubah opsi expiration di file config/sanctum.php menjadi:

'expiration' => 60,

Kemudian, Anda perlu mengimplementasikan logika untuk menghapus token yang kadaluarsa secara berkala. Anda dapat membuat scheduled task untuk melakukan ini.

Penting:

Pastikan Anda memahami implikasi dari setiap opsi konfigurasi sebelum mengubahnya.
Selalu uji perubahan konfigurasi Anda secara menyeluruh sebelum menerapkannya ke production.

Dengan kemampuan untuk melakukan customisasi, Anda dapat menyesuaikan Sanctum agar sesuai dengan kebutuhan spesifik aplikasi Anda dan meningkatkan keamanannya. Selanjutnya, kita akan membahas beberapa praktik terbaik untuk keamanan tambahan saat menggunakan Laravel Sanctum.

9. Praktik Terbaik: Tips Keamanan Tambahan untuk Laravel Sanctum

Meskipun Laravel Sanctum menyediakan solusi autentikasi yang aman, ada beberapa praktik terbaik yang dapat Anda terapkan untuk meningkatkan keamanan aplikasi Anda lebih lanjut. Bagian ini dari Laravel Sanctum Authentication Tutorial akan membahas beberapa tips keamanan tambahan yang penting.

1. Gunakan HTTPS:

Selalu gunakan HTTPS untuk semua komunikasi antara SPA Anda dan API Anda. HTTPS mengenkripsi data yang dikirim antara klien dan server, sehingga mencegah pihak ketiga mencuri informasi sensitif, seperti token autentikasi. Pastikan server Anda telah dikonfigurasi dengan sertifikat SSL/TLS yang valid.

2. Validasi Data yang Ketat:

Validasi semua data yang diterima dari klien, termasuk data registrasi, login, dan data yang dikirim ke API yang dilindungi. Gunakan validasi Laravel yang kuat untuk mencegah serangan injeksi SQL, Cross-Site Scripting (XSS), dan serangan lainnya.

3. Hash Password dengan Aman:

Selalu gunakan fungsi hash yang kuat untuk menyimpan password user. Laravel secara default menggunakan bcrypt yang merupakan algoritma hash yang aman. Jangan pernah menyimpan password dalam bentuk plain text.

4. Batasi Percobaan Login yang Gagal (Rate Limiting):

Implementasikan rate limiting untuk membatasi jumlah percobaan login yang gagal dalam periode waktu tertentu. Ini dapat mencegah serangan brute-force yang mencoba menebak password user. Laravel menyediakan fitur rate limiting yang mudah digunakan.

5. Pantau Aktivitas Akun:

Pantau aktivitas akun user untuk mendeteksi aktivitas yang mencurigakan. Misalnya, Anda dapat memantau login dari lokasi yang tidak dikenal, perubahan password yang tidak sah, atau akses ke data sensitif.

6. Gunakan CORS dengan Bijak:

Konfigurasi CORS dengan hati-hati untuk hanya mengizinkan domain yang terpercaya untuk mengakses API Anda. Jangan menggunakan wildcard (*) untuk allowed_origins di lingkungan production.

7. Implementasikan Fitur Logout yang Tepat:

Pastikan Anda mengimplementasikan fitur logout yang tepat untuk menghapus token autentikasi user saat mereka logout. Ini mencegah token dicuri dan digunakan oleh pihak ketiga.

8. Perbarui Laravel dan Sanctum Secara Teratur:

Selalu perbarui Laravel dan Sanctum ke versi terbaru untuk mendapatkan perbaikan bug keamanan dan fitur keamanan terbaru.

9. Enkripsi Data Sensitif:

Enkripsi data sensitif yang disimpan di database, seperti informasi pribadi user atau data keuangan. Laravel menyediakan fitur enkripsi yang mudah digunakan.

10. Gunakan Audit Logging:

Implementasikan audit logging untuk mencatat semua aktivitas penting di aplikasi Anda, seperti login, logout, perubahan data, dan akses ke data sensitif. Ini membantu Anda melacak aktivitas yang mencurigakan dan memecahkan masalah keamanan.

Dengan menerapkan praktik terbaik ini, Anda dapat meningkatkan keamanan aplikasi Laravel Anda yang menggunakan Sanctum secara signifikan dan melindungi data user Anda dari ancaman keamanan. Selanjutnya, kita akan membahas beberapa masalah umum yang mungkin Anda temui saat menggunakan Sanctum dan bagaimana cara memecahkannya.

10. Debugging dan Troubleshooting Umum pada Laravel Sanctum

Meskipun Laravel Sanctum relatif mudah digunakan, Anda mungkin menghadapi beberapa masalah umum selama pengembangan. Bagian ini dari Laravel Sanctum Authentication Tutorial akan membahas beberapa masalah umum dan memberikan solusi untuk membantu Anda melakukan debugging dan troubleshooting.

1. Masalah CORS:

Gejala: Error CORS di browser saat melakukan request dari SPA ke API.
Penyebab: Konfigurasi CORS yang salah.
Solusi:
- Pastikan Anda telah menginstal dan mengkonfigurasi paket fruitcake/laravel-cors dengan benar.
- Pastikan allowed_origins di file config/cors.php berisi domain SPA Anda.
- Pastikan supports_credentials diatur ke true.

2. Token Tidak Terkirim ke API:

Gejala: Request ke API yang dilindungi menghasilkan error 401 (Unauthorized).
Penyebab: Token tidak terkirim dengan request.
Solusi:
- Pastikan axios.defaults.withCredentials = true diatur di SPA Anda jika Anda menggunakan cookie untuk autentikasi.
- Pastikan Anda mengirimkan token di header Authorization (dengan format Bearer <token>) jika Anda menggunakan header untuk autentikasi.
- Periksa apakah ada middleware yang menghapus header Authorization.

3. Error “Attempt to read property “id” on null”:

Gejala: Error ini sering terjadi saat mencoba mengakses auth()->user() setelah melakukan login.
Penyebab: Session tidak terinisialisasi dengan benar setelah login.
Solusi:
- Pastikan konfigurasi session Anda benar. Periksa file config/session.php dan pastikan SESSION_DOMAIN diatur dengan benar di .env.
- Coba jalankan php artisan config:cache dan php artisan route:cache untuk membersihkan cache konfigurasi.

4. Token Tidak Dihapus saat Logout:

Gejala: Setelah logout, token masih valid dan dapat digunakan untuk mengakses API.
Penyebab: Logika logout tidak menghapus token dengan benar.
Solusi:
- Pastikan method logout() di AuthController menghapus semua token user dengan memanggil auth()->user()->tokens()->delete().
- Pastikan Anda menghapus token dari sisi klien (misalnya, menghapus cookie atau local storage).

5. Masalah dengan XSRF-TOKEN Cookie:

Gejala: Request POST, PUT, DELETE, atau PATCH menghasilkan error CSRF.
Penyebab: Token CSRF tidak terkirim dengan request.
Solusi:
- Pastikan SPA Anda mengirimkan header X-XSRF-TOKEN dengan token CSRF yang ada di cookie XSRF-TOKEN.
- Pastikan middleware VerifyCsrfToken diaktifkan di kernel HTTP Anda.

6. Masalah dengan Masa Berlaku Token:

Gejala: Token tetap valid setelah masa berlaku yang seharusnya.
Penyebab: Logika masa berlaku token tidak diimplementasikan dengan benar.
Solusi:
- Pastikan Anda memiliki kolom expires_at di tabel personal_access_tokens.
- Pastikan Anda memvalidasi token berdasarkan kolom expires_at sebelum mengizinkan akses ke API.
- Pastikan Anda memiliki scheduled task untuk menghapus token yang kadaluarsa secara berkala.

Tips Debugging Umum:

Periksa Log Laravel: Periksa file storage/logs/laravel.log untuk melihat error atau pengecualian yang terjadi.
Gunakan Debugger: Gunakan debugger seperti Xdebug untuk menelusuri kode dan melihat nilai variabel.
Gunakan Network Tab di Browser: Gunakan network tab di browser untuk melihat request dan respons HTTP.
Cetak Log: Gunakan Log::info() untuk mencetak log ke file laravel.log untuk membantu Anda memahami alur kode.

Dengan mengikuti tips debugging dan troubleshooting ini, Anda dapat dengan cepat mengidentifikasi dan memperbaiki masalah yang mungkin Anda temui saat menggunakan Laravel Sanctum. Terakhir, kita akan membandingkan Laravel Sanctum dengan Laravel Passport untuk membantu Anda menentukan solusi autentikasi mana yang tepat untuk proyek Anda.

11. Laravel Sanctum vs. Laravel Passport: Kapan Menggunakan Masing-Masing?

Laravel Sanctum dan Laravel Passport adalah dua solusi autentikasi populer untuk Laravel. Meskipun keduanya memiliki tujuan yang sama, yaitu mengamankan aplikasi, mereka memiliki pendekatan dan fitur yang berbeda. Bagian ini dari Laravel Sanctum Authentication Tutorial akan membandingkan kedua paket ini untuk membantu Anda menentukan mana yang paling sesuai dengan kebutuhan proyek Anda.

Laravel Sanctum:

Tags: API Aplikasi Authentication Laravel Sanctum panduan PHP Sanctum Security SPA tutorial

Laravel Sanctum Authentication Tutorial: Panduan Lengkap untuk Keamanan Aplikasi

Laravel vs CodeIgniter: Mana Framework PHP Terbaik untuk Anda?

Belajar HTML CSS JavaScript untuk Pemula: Panduan Lengkap Web Development

Cara Deploy Aplikasi Laravel ke Server: Panduan Lengkap dan Mudah Diikuti

Laravel Livewire Tutorial Bahasa Indonesia: Interaktivitas Tanpa Refresh Halaman

Seraphina

Related Posts

Laravel vs CodeIgniter: Mana Framework PHP Terbaik untuk Anda?

Belajar HTML CSS JavaScript untuk Pemula: Panduan Lengkap Web Development

Cara Deploy Aplikasi Laravel ke Server: Panduan Lengkap dan Mudah Diikuti

Laravel Blade Template Engine Tutorial: Membuat Tampilan Website Lebih Menarik

Leave a Reply Cancel reply

Recommended

Belajar HTML CSS JavaScript untuk Pemula: Langkah Awal Menjadi Web Developer

Hosting Cloud dengan Uptime Tinggi Indonesia: Jaminan Website Online Terus

Hosting VPS Murah untuk Aplikasi Web Indonesia: Skalabilitas Tinggi, Budget Rendah

Hosting Domain Gratis Indonesia untuk Pemula: Mulai Website Tanpa Ribet

Hosting WordPress Tercepat dan Stabil di Indonesia: Panduan Lengkap 2024

m.techreview.click

Recent Posts

Categories

Resource