Laravel Sanctum adalah solusi otentikasi API yang ringan dan fleksibel, dirancang khusus untuk aplikasi Laravel. Jika Anda sedang membangun API sederhana, aplikasi single-page (SPA), atau aplikasi mobile yang membutuhkan otentikasi berbasis token, Laravel Sanctum bisa menjadi pilihan yang tepat. Artikel ini akan membahas secara mendalam tentang Laravel Sanctum, termasuk apa itu, mengapa Anda harus menggunakannya, bagaimana cara menginstalnya, dan contoh implementasi praktis. Mari kita mulai!

Apa Itu Laravel Sanctum dan Mengapa Memilihnya?

Laravel Sanctum, yang sebelumnya dikenal sebagai Laravel Airlock, menyediakan sistem otentikasi API berbasis token yang sangat mudah diimplementasikan. Bayangkan Anda sedang membangun sebuah aplikasi yang terintegrasi dengan mobile app atau SPA (Single Page Application). Nah, Sanctum hadir sebagai jembatan yang aman dan praktis untuk menghubungkan mereka dengan API Laravel Anda.

Mengapa memilih Laravel Sanctum?

• Ringan dan Mudah Digunakan: Sanctum dirancang untuk menjadi ringan dan mudah diintegrasikan ke dalam proyek Laravel Anda. Proses instalasi dan konfigurasi relatif sederhana dibandingkan dengan solusi otentikasi yang lebih kompleks.
• Otentikasi Berbasis Token: Sanctum menggunakan token API untuk mengotentikasi pengguna, memungkinkan Anda untuk memberikan akses ke API Anda hanya kepada pengguna yang berwenang.
• Cocok untuk SPA, Aplikasi Mobile, dan API Sederhana: Sanctum sangat ideal untuk aplikasi single-page, aplikasi mobile, dan API sederhana yang tidak memerlukan fitur otentikasi yang rumit seperti OAuth.
• Keamanan yang Terjamin: Sanctum memanfaatkan fitur keamanan Laravel untuk melindungi aplikasi Anda dari ancaman umum seperti Cross-Site Request Forgery (CSRF).
• Manajemen Token yang Fleksibel: Anda dapat dengan mudah membuat, mencabut, dan mengelola token API untuk setiap pengguna.
• Fitur Middlewares yang Kuat: Sanctum menyediakan middlewares yang membantu Anda melindungi rute API Anda dan memastikan hanya pengguna yang terautentikasi yang dapat mengaksesnya.

Singkatnya, jika Anda mencari solusi otentikasi API sederhana untuk aplikasi Laravel, Laravel Sanctum adalah pilihan yang cerdas dan efisien.

Persiapan dan Instalasi Laravel Sanctum: Langkah Demi Langkah

Sebelum memulai implementasi Laravel Sanctum: Otentikasi API Sederhana untuk Aplikasi Laravel, pastikan Anda sudah memiliki proyek Laravel yang sudah berjalan. Jika belum, Anda bisa membuat proyek Laravel baru dengan perintah berikut:

composer create-project --prefer-dist laravel/laravel nama-proyek
cd nama-proyek

Setelah itu, ikuti langkah-langkah berikut untuk menginstal Laravel Sanctum:

1. Instal Package Laravel Sanctum:

   Buka terminal di direktori proyek Laravel Anda dan jalankan perintah berikut:

   composer require laravel/sanctum

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

2. Publish Konfigurasi dan Migrasi:

   Setelah instalasi selesai, Anda perlu mem-publish file konfigurasi dan migrasi dari Sanctum. Jalankan perintah berikut:

   php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"

   Perintah ini akan menyalin file konfigurasi config/sanctum.php dan file migrasi ke direktori database/migrations proyek Anda.

3. Jalankan Migrasi:

   Selanjutnya, jalankan migrasi untuk membuat tabel yang dibutuhkan oleh Sanctum.

   php artisan migrate

   Perintah ini akan membuat tabel personal_access_tokens di database Anda. Tabel ini akan digunakan untuk menyimpan token API yang dihasilkan oleh Sanctum.

4. Konfigurasi Model User:

   Buka model AppModelsUser (atau model user yang Anda gunakan) dan tambahkan trait HasApiTokens dari Sanctum.

   <?php
   
   namespace AppModels;
   
   use IlluminateContractsAuthMustVerifyEmail;
   use IlluminateDatabaseEloquentFactoriesHasFactory;
   use IlluminateFoundationAuthUser as Authenticatable;
   use IlluminateNotificationsNotifiable;
   use LaravelSanctumHasApiTokens;
   
   class User extends Authenticatable
   {
       use HasApiTokens, HasFactory, Notifiable;
   
       // ...
   }

   Trait HasApiTokens akan menambahkan method-method yang diperlukan untuk berinteraksi dengan token API.

5. Konfigurasi Middleware (Optional):

   Jika Anda menggunakan SPA, tambahkan EnsureFrontendRequestsAreStateful middleware ke kernel HTTP Anda ( app/Http/Kernel.php). Ini penting untuk memastikan sesi cookie berfungsi dengan benar.

   protected $middlewareGroups = [
       'web' => [
           AppHttpMiddlewareEncryptCookies::class,
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
           IlluminateSessionMiddlewareStartSession::class,
           // IlluminateSessionMiddlewareAuthenticateSession::class, // Remove or comment this out
           IlluminateViewMiddlewareShareErrorsFromSession::class,
           AppHttpMiddlewareVerifyCsrfToken::class,
           IlluminateRoutingMiddlewareSubstituteBindings::class,
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Tambahkan baris ini
       ],
   
       'api' => [
           'throttle:api',
           IlluminateRoutingMiddlewareSubstituteBindings::class,
       ],
   ];

   Penting: Pastikan Anda telah menonaktifkan atau mengomentari middleware IlluminateSessionMiddlewareAuthenticateSession::class di grup middleware web. Middleware ini akan mengganggu otentikasi Sanctum berbasis token.

Dengan langkah-langkah di atas, Anda telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum di proyek Laravel Anda. Sekarang, mari kita lanjutkan ke implementasi otentikasi dengan Sanctum.

Membuat Token API: Implementasi createToken Laravel Sanctum

Setelah menginstal dan mengkonfigurasi Sanctum, langkah selanjutnya adalah membuat token API untuk pengguna. Berikut adalah contoh cara membuat token API menggunakan method createToken() yang disediakan oleh trait HasApiTokens.

Contoh Kode:

<?php

use AppModelsUser;

Route::post('/api/register', function (Request $request) {
    $request->validate([
        'name' => 'required|string',
        'email' => 'required|email|unique:users',
        'password' => 'required|string|min:8',
    ]);

    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => bcrypt($request->password),
    ]);

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

    return response()->json([
        'access_token' => $token,
        'token_type' => 'Bearer',
    ]);
});

Route::post('/api/login', function (Request $request) {
    if (!Auth::attempt($request->only('email', 'password'))) {
        return response()->json([
            'message' => 'Invalid login details'
        ], 401);
    }

    $user = User::where('email', $request['email'])->firstOrFail();

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

    return response()->json([
        'access_token' => $token,
        'token_type' => 'Bearer',
    ]);
});

Penjelasan:

• $user->createToken('auth_token'): Method ini membuat token baru untuk pengguna $user. String 'auth_token' adalah nama token yang akan digunakan untuk mengidentifikasi token ini. Anda bisa mengganti nama ini sesuai kebutuhan. Penting untuk dicatat bahwa setiap kali Anda memanggil createToken, token baru akan dibuat di database.
• ->plainTextToken: Method ini mengembalikan token dalam format plain text. Ini hanya bisa diakses segera setelah pembuatan token. Setelah Anda mengembalikan token ini ke klien, Anda tidak akan bisa mengaksesnya lagi dari server. Ini adalah fitur keamanan yang penting.

Penting: Simpan access_token yang dikembalikan dengan aman di sisi klien (misalnya, di localStorage browser atau secure storage aplikasi mobile). Klien akan menggunakan token ini untuk mengotentikasi setiap permintaan API.

Melindungi Rute API dengan Middleware Sanctum

Setelah mendapatkan token API, Anda perlu melindungi rute API Anda agar hanya dapat diakses oleh pengguna yang terautentikasi. Sanctum menyediakan middleware yang dapat Anda gunakan untuk tujuan ini.

Contoh Kode:

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;

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

Penjelasan:

• Route::middleware('auth:sanctum'): Baris ini menerapkan middleware auth:sanctum ke rute /api/user. Middleware ini akan memeriksa keberadaan token API yang valid di header Authorization dari permintaan.
• 'auth:sanctum': Ini adalah nama guard yang digunakan oleh Sanctum. Ini memberi tahu Laravel untuk menggunakan Sanctum sebagai driver otentikasi.
• $request->user(): Jika token valid, middleware akan mengautentikasi pengguna dan mengisi properti $request->user() dengan instance model User yang sesuai. Anda kemudian dapat mengakses informasi pengguna yang terautentikasi di dalam closure rute.

Bagaimana klien mengirimkan token?

Klien harus mengirimkan token API di header Authorization dengan format Bearer <token>. Contoh:

Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...

Jika token tidak valid atau tidak ada, middleware akan mengembalikan respons error 401 Unauthorized.

Refreshing Token API: Memperbarui Sesi Otentikasi

Laravel Sanctum sendiri tidak secara eksplisit menyediakan mekanisme refresh token seperti pada implementasi OAuth. Namun, Anda bisa mengimplementasikan logika serupa secara manual dengan mudah.

Strategi Umum:

• Buat rute baru untuk “refresh” token: Rute ini akan menerima token lama sebagai input dan menghasilkan token baru.
• Cek validitas token lama: Anda dapat menggunakan fitur revoking token Sanctum untuk memastikan token lama masih valid sebelum memberikan token baru.
• Hasilkan token baru: Gunakan createToken() untuk membuat token baru untuk pengguna yang sama.
• Cabut token lama (opsional): Anda bisa mencabut token lama untuk meningkatkan keamanan, namun ini akan memaksa klien untuk segera menggunakan token baru.

Contoh Implementasi (Konsep):

Route::post('/api/refresh-token', function (Request $request) {
    $request->validate([
        'old_token' => 'required|string',
    ]);

    $user = auth('sanctum')->user(); // Coba dapatkan pengguna dari token yang diberikan (jika valid)

    if (!$user) {
        return response()->json(['message' => 'Invalid old token'], 401);
    }


    // Hasilkan token baru
    $newToken = $user->createToken('new_auth_token')->plainTextToken;

    // Cabut semua token lama (opsional, hati-hati!)
    //$user->tokens()->delete(); // Cabut *semua* token pengguna ini.

    return response()->json([
        'access_token' => $newToken,
        'token_type' => 'Bearer',
    ]);
});

Penting:

• Implementasi di atas adalah contoh sederhana. Anda perlu menyesuaikannya dengan kebutuhan spesifik aplikasi Anda.
• Pertimbangkan untuk menambahkan logika kedaluwarsa untuk token API.
• Berhati-hatilah saat mencabut semua token pengguna. Ini akan memengaruhi semua sesi yang sedang berjalan.

Mencabut Token API: Mengakhiri Sesi Pengguna

Laravel Sanctum memungkinkan Anda untuk mencabut token API, yang secara efektif mengakhiri sesi pengguna. Ini berguna dalam situasi seperti logout, perubahan password, atau ketika token dicuri.

Contoh Kode:

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;

Route::middleware('auth:sanctum')->post('/api/logout', function (Request $request) {
    $request->user()->currentAccessToken()->delete();

    return response()->json(['message' => 'Successfully logged out']);
});

Penjelasan:

• $request->user()->currentAccessToken(): Method ini mengembalikan instance PersonalAccessToken yang terkait dengan token API yang digunakan untuk mengautentikasi permintaan saat ini.
• ->delete(): Method ini menghapus token dari database, sehingga token tersebut tidak lagi valid.

Setelah token dicabut, pengguna tidak akan lagi dapat mengakses rute API yang dilindungi dengan token tersebut. Mereka harus mendapatkan token baru untuk mendapatkan akses kembali.

Kustomisasi Konfigurasi Laravel Sanctum

Laravel Sanctum menyediakan beberapa opsi konfigurasi yang dapat Anda sesuaikan sesuai dengan kebutuhan aplikasi Anda. File konfigurasi terletak di config/sanctum.php.

Beberapa opsi konfigurasi yang penting:

• stateful: Array ini menentukan domain yang dianggap “stateful”. Permintaan dari domain-domain ini akan menerima cookie sesi selain token API. Ini penting untuk SPA yang berada di domain yang berbeda dari API Anda.
• guard: Menentukan guard otentikasi default yang digunakan oleh Sanctum. Biasanya diatur ke web.
• expiration: Anda bisa mengatur lama token berlaku. Secara default, token berlaku selamanya.

Contoh Kustomisasi:

Untuk mengubah domain stateful, buka config/sanctum.php dan ubah array stateful seperti ini:

'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', 'localhost,127.0.0.1,::1')),

Kemudian, pastikan Anda mengatur variabel environment SANCTUM_STATEFUL_DOMAINS di file .env Anda:

SANCTUM_STATEFUL_DOMAINS=example.com,subdomain.example.com

Pastikan untuk menjalankan php artisan config:cache setelah mengubah file konfigurasi Anda untuk menerapkan perubahan.

Keamanan dalam Laravel Sanctum: Praktik Terbaik

Meskipun Laravel Sanctum menyediakan otentikasi API yang aman, penting untuk mengikuti praktik terbaik untuk memastikan keamanan aplikasi Anda.

• Gunakan HTTPS: Pastikan semua komunikasi antara klien dan server menggunakan HTTPS untuk melindungi token API dari penyadapan.
• Simpan Token dengan Aman: Jangan menyimpan token API di tempat yang tidak aman, seperti cookie yang tidak dienkripsi atau local storage tanpa perlindungan tambahan. Pertimbangkan untuk menggunakan secure storage yang disediakan oleh platform (misalnya, Keychain di iOS atau Keystore di Android).
• Implementasikan Refresh Token: Gunakan mekanisme refresh token untuk memperbarui token API secara berkala tanpa memaksa pengguna untuk login ulang.
• Batasi Akses Token: Berikan hak akses yang minimal kepada setiap token API. Jangan memberikan token dengan akses penuh jika tidak diperlukan.
• Monitor dan Audit: Pantau aktivitas API dan audit log untuk mendeteksi aktivitas mencurigakan.
• Lindungi dari CSRF: Jika Anda menggunakan SPA, pastikan Anda melindungi API Anda dari serangan Cross-Site Request Forgery (CSRF). Sanctum secara otomatis menyediakan perlindungan CSRF untuk permintaan dari domain stateful.

Troubleshooting Masalah Umum dengan Laravel Sanctum

Meskipun Laravel Sanctum relatif mudah digunakan, Anda mungkin menghadapi beberapa masalah umum selama implementasi. Berikut adalah beberapa solusi untuk masalah yang sering terjadi:

• 401 Unauthorized: Pastikan token API valid dan dikirim dengan benar di header Authorization. Periksa juga apakah Anda telah mengaktifkan middleware auth:sanctum pada rute yang sesuai.
• Token tidak berfungsi setelah deploy: Pastikan variabel environment APP_KEY konsisten di semua lingkungan (development, staging, production). Jalankan php artisan key:generate jika APP_KEY belum diatur dengan benar.
• Masalah dengan SPA dan cookie: Pastikan Anda telah menambahkan domain SPA ke array stateful di file konfigurasi Sanctum. Periksa juga apakah Anda telah mengaktifkan middleware EnsureFrontendRequestsAreStateful di kernel HTTP.
• Token tidak disimpan di database: Pastikan Anda telah menjalankan migrasi setelah menginstal Sanctum.

Jika Anda masih mengalami masalah, periksa dokumentasi resmi Laravel Sanctum dan cari solusi di forum dan komunitas online.

Kesimpulan: Laravel Sanctum Solusi Terbaik untuk Otentikasi API?

Laravel Sanctum: Otentikasi API Sederhana untuk Aplikasi Laravel adalah pilihan yang sangat baik untuk aplikasi yang membutuhkan otentikasi berbasis token yang sederhana dan mudah diimplementasikan. Dengan fitur-fitur seperti otentikasi berbasis token, middleware yang kuat, dan manajemen token yang fleksibel, Sanctum menyediakan solusi yang aman dan efisien untuk melindungi API Anda.

Meskipun Sanctum mungkin tidak cocok untuk aplikasi yang membutuhkan fitur otentikasi yang lebih kompleks seperti OAuth, ia tetap menjadi pilihan yang ideal untuk SPA, aplikasi mobile, dan API sederhana. Dengan mengikuti panduan dan praktik terbaik yang dibahas dalam artikel ini, Anda dapat dengan mudah mengimplementasikan Laravel Sanctum dan mengamankan aplikasi Laravel Anda dengan efektif. Jadi, jika Anda mencari solusi otentikasi API sederhana untuk aplikasi Laravel, jangan ragu untuk mencoba Laravel Sanctum!