Laravel, framework PHP yang populer, menawarkan berbagai fitur yang memudahkan pengembangan aplikasi web. Salah satu fitur yang sangat berguna adalah Laravel Sanctum. Bagi kamu yang ingin membuat API (Application Programming Interface) dengan keamanan yang solid tapi tidak ingin repot dengan konfigurasi kompleks, Laravel Sanctum adalah jawabannya! Artikel ini akan membahas tuntas tentang Laravel Sanctum, mulai dari apa itu, mengapa menggunakannya, bagaimana cara mengimplementasikannya, hingga tips dan trik penggunaannya. Mari kita mulai!

Apa Itu Laravel Sanctum? Autentikasi API Berbasis Token yang Simpel

Laravel Sanctum adalah paket Laravel yang menyediakan sistem autentikasi berbasis token yang ringan dan mudah digunakan, terutama untuk:

• Single-Page Applications (SPA): Aplikasi yang dibuat dengan framework seperti Vue.js, React, atau Angular, yang berinteraksi dengan backend Laravel melalui API.
• Mobile Applications: Aplikasi mobile yang membutuhkan autentikasi untuk mengakses data dari server Laravel.
• API Tokens: Membuat token API untuk digunakan oleh pihak ketiga atau aplikasi lain untuk mengakses API Anda.

Intinya, Laravel Sanctum memberikan solusi stateful (berbasis cookie dan session) dan stateless (berbasis token) authentication untuk API Anda. Ini berbeda dengan Passport yang lebih kompleks dan cocok untuk kasus yang lebih rumit seperti OAuth2. Sanctum fokus pada kemudahan penggunaan dan kesederhanaan, menjadikannya ideal untuk project-project kecil hingga menengah.

Mengapa Memilih Laravel Sanctum untuk Keamanan API Anda?

Ada banyak alasan mengapa Laravel Sanctum menjadi pilihan yang tepat untuk autentikasi API Anda:

• Kemudahan Implementasi: Dibandingkan dengan solusi autentikasi API lainnya, seperti OAuth2, Sanctum sangat mudah diimplementasikan. Anda hanya perlu beberapa langkah untuk mengkonfigurasi dan mulai menggunakannya. Ini menghemat waktu dan sumber daya pengembangan.
• Keamanan yang Solid: Sanctum menggunakan mekanisme keamanan yang kuat untuk melindungi API Anda dari akses yang tidak sah. Sanctum memanfaatkan CSRF (Cross-Site Request Forgery) protection untuk request yang berasal dari browser dan token authentication untuk request dari aplikasi mobile atau pihak ketiga.
• Ringan dan Cepat: Sanctum tidak membebani aplikasi Anda dengan overhead yang berlebihan. Karena fokus pada kesederhanaan, Sanctum memiliki footprint yang kecil dan eksekusi yang cepat.
• Dukungan Laravel yang Baik: Sanctum adalah bagian dari ekosistem Laravel dan didukung secara resmi oleh tim Laravel. Ini berarti Anda dapat mengandalkan dokumentasi yang lengkap dan komunitas yang besar untuk mendapatkan bantuan jika Anda mengalami masalah.
• Fleksibilitas: Sanctum mendukung multiple API tokens per user, memungkinkan pengguna untuk memiliki token yang berbeda untuk aplikasi yang berbeda. Ini meningkatkan keamanan dan kontrol akses.
• CSRF Protection Otomatis: Untuk aplikasi SPA, Sanctum secara otomatis memberikan CSRF protection saat pengguna login melalui endpoint yang disediakan. Ini mencegah serangan CSRF yang umum terjadi pada aplikasi web modern.
• Otorisasi Sederhana: Sanctum mempermudah otorisasi. Setelah pengguna terautentikasi, Anda dapat dengan mudah memeriksa apakah pengguna memiliki izin untuk mengakses sumber daya tertentu.

Persiapan Awal: Instalasi dan Konfigurasi Laravel Sanctum

Sebelum kita mulai menggunakan Laravel Sanctum, kita perlu menginstalnya dan mengkonfigurasinya terlebih dahulu. Berikut adalah langkah-langkahnya:

1. Instalasi Package:

   Gunakan Composer untuk menginstal package Laravel Sanctum:

   composer require laravel/sanctum

2. Publish Configuration dan Migrations:

   Setelah package terinstal, jalankan perintah berikut untuk mem-publish file konfigurasi dan migrations:

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

3. Jalankan Migrations:

   Jalankan migrations untuk membuat tabel yang dibutuhkan oleh Sanctum:

   php artisan migrate

   Perintah ini akan membuat tabel personal_access_tokens yang digunakan untuk menyimpan token API.

4. Tambahkan HasApiTokens Trait ke Model User:

   Tambahkan trait HasApiTokens ke model User Anda:

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

5. Konfigurasi Middleware:

   Pastikan middleware EnsureFrontendRequestsAreStateful diaktifkan di file app/Http/Kernel.php Bagian $middlewareGroups['web']. Middleware ini penting untuk CSRF protection dan stateful authentication pada SPA. Jika belum ada, tambahkan:

       'web' => [
           AppHttpMiddlewareEncryptCookies::class,
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
           IlluminateSessionMiddlewareStartSession::class,
           IlluminateViewMiddlewareShareErrorsFromSession::class,
           AppHttpMiddlewareVerifyCsrfToken::class, // Pastikan ini ada
           IlluminateRoutingMiddlewareSubstituteBindings::class,
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class,
       ],

6. Konfigurasi Domain dan Path Cookie (Penting untuk SPA):

   Di file config/sanctum.php, pastikan konfigurasi stateful sesuai dengan domain frontend Anda. Ini krusial agar cookie dapat dikirim dengan benar dari backend ke frontend.

   'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', 'localhost,127.0.0.1,127.0.0.1:8000,::1')),
   'supports_cors' => env('SANCTUM_SUPPORTS_CORS', false),
   'middleware' => [
       'verify_csrf_token' => AppHttpMiddlewareVerifyCsrfToken::class,
   ],

   Ubah nilai SANCTUM_STATEFUL_DOMAINS di file .env sesuai dengan domain aplikasi frontend Anda. Contoh:

   SANCTUM_STATEFUL_DOMAINS=example.com,localhost:3000,127.0.0.1:3000

   Juga, periksa opsi supports_cors. Jika API Anda diakses dari domain lain, pastikan ini diatur ke true dan konfigurasi CORS di server Anda sudah benar.

Dengan langkah-langkah ini, Anda telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum. Sekarang, kita bisa mulai menggunakan fitur-fiturnya.

Membuat dan Menggunakan API Tokens dengan Laravel Sanctum

Setelah konfigurasi selesai, mari kita lihat bagaimana cara membuat dan menggunakan API tokens:

1. Membuat Token:

   Anda dapat membuat token API untuk pengguna dengan menggunakan method createToken pada instance model User. Biasanya, ini dilakukan setelah pengguna berhasil login.

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

   nama-token-anda adalah nama deskriptif untuk token tersebut. plainTextToken adalah token yang akan diberikan kepada pengguna. Penting: Simpan token ini dengan aman di sisi client karena Anda tidak dapat melihatnya lagi setelah dibuat.

2. Menggunakan Token untuk Autentikasi:

   Untuk melakukan autentikasi dengan token, kirimkan token dalam header Authorization dengan format Bearer <token>.

   Contoh (menggunakan cURL):

   curl -H "Authorization: Bearer <token>" http://example.com/api/resource

   Contoh (menggunakan JavaScript dengan Axios):

   axios.get('/api/resource', {
     headers: {
       Authorization: `Bearer ${token}`
     }
   });

3. Melindungi Rute API:

   Anda dapat melindungi rute API dengan menggunakan middleware auth:sanctum.

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

   Hanya pengguna yang terautentikasi dengan token yang valid yang dapat mengakses rute ini.

Autentikasi Berbasis Cookie untuk SPA: Alur Login dan Logout

Untuk aplikasi SPA, Laravel Sanctum juga mendukung autentikasi berbasis cookie. Alur kerjanya sedikit berbeda:

1. Login:

   • Frontend mengirimkan request login (biasanya dengan username dan password) ke endpoint login Laravel.
   • Laravel melakukan autentikasi pengguna.
   • Setelah autentikasi berhasil, Laravel membuat session dan mengatur cookie XSRF-TOKEN dan laravel_session. Middleware EnsureFrontendRequestsAreStateful memastikan ini bekerja dengan benar.
   • Backend tidak mengembalikan token. Autentikasi berbasis cookie sudah cukup.

2. Request Selanjutnya:

   • Setiap request selanjutnya dari frontend ke API Laravel akan otomatis menyertakan cookie XSRF-TOKEN dan laravel_session.
   • Laravel menggunakan cookie ini untuk mengidentifikasi dan mengautentikasi pengguna.
   • Middleware auth:sanctum akan secara otomatis mengautentikasi pengguna berdasarkan session.

3. Logout:

   • Frontend mengirimkan request logout ke endpoint logout Laravel.
   • Laravel menghapus session dan cookie, sehingga pengguna keluar dari sistem.

Contoh Kode (Login Controller):

public function login(Request $request)
{
    $credentials = $request->validate([
        'email' => 'required|email',
        'password' => 'required',
    ]);

    if (Auth::attempt($credentials)) {
        $request->session()->regenerate();

        return response()->json(['message' => 'Login successful']);
    }

    return response()->json(['message' => 'Invalid credentials'], 401);
}

Contoh Kode (Logout Controller):

public function logout(Request $request)
{
    Auth::logout();

    $request->session()->invalidate();

    $request->session()->regenerateToken();

    return response()->json(['message' => 'Logout successful']);
}

Contoh Kode (Frontend – Axios):

// Login
axios.post('/login', {
  email: '[email protected]',
  password: 'password'
}).then(response => {
  // Setelah login berhasil, cookie akan otomatis diatur oleh browser.
  // Tidak perlu menyimpan token secara manual.
  console.log(response.data.message);
});

// Logout
axios.post('/logout').then(response => {
  console.log(response.data.message);
});

// Request ke API yang dilindungi
axios.get('/api/user').then(response => {
  console.log(response.data);
});

Perhatikan bahwa dalam autentikasi berbasis cookie, Anda tidak perlu menyimpan token di sisi frontend. Semua proses autentikasi dilakukan melalui cookie yang dikelola secara otomatis oleh browser dan Laravel.

Otorisasi dengan Laravel Sanctum: Memberikan Akses Terbatas

Setelah pengguna terautentikasi, Anda mungkin ingin memberikan akses terbatas ke sumber daya tertentu. Laravel Sanctum memungkinkan Anda untuk melakukan otorisasi dengan mudah.

• Menggunakan Policies: Laravel Policies adalah cara yang bagus untuk mengatur logika otorisasi Anda. Anda dapat membuat policies untuk model Anda dan mendefinisikan aturan siapa yang boleh melakukan apa.

  Contoh:

  // Membuat policy untuk model Post
  php artisan make:policy PostPolicy --model=Post

  Di dalam PostPolicy, Anda dapat mendefinisikan method seperti update, delete, dll. yang menentukan apakah pengguna tertentu boleh melakukan tindakan tersebut.

  public function update(User $user, Post $post)
  {
      return $user->id === $post->user_id;
  }

  Kemudian, di dalam controller, Anda dapat menggunakan method authorize untuk memeriksa izin pengguna:

  public function update(Request $request, Post $post)
  {
      $this->authorize('update', $post);
  
      // ...
  }

• Menggunakan Gate: Laravel Gates memberikan cara sederhana berbasis closure untuk mendefinisikan aturan otorisasi.

  Contoh:

  Gate::define('update-post', function (User $user, Post $post) {
      return $user->id === $post->user_id;
  });

  Kemudian, di dalam controller, Anda dapat menggunakan method allows atau denies untuk memeriksa izin pengguna:

  public function update(Request $request, Post $post)
  {
      if (Gate::allows('update-post', $post)) {
          // ...
      } else {
          abort(403);
      }
  }

• Middleware Custom: Anda juga dapat membuat middleware custom untuk melakukan otorisasi yang lebih kompleks.

Multiple API Tokens: Memberikan Kontrol Lebih Baik

Laravel Sanctum memungkinkan setiap pengguna untuk memiliki beberapa API tokens. Ini berguna jika Anda ingin memberikan akses ke aplikasi yang berbeda dengan izin yang berbeda.

Contoh:

// Membuat token untuk aplikasi mobile
$mobileToken = $user->createToken('mobile-app')->plainTextToken;

// Membuat token untuk website
$webToken = $user->createToken('web-app')->plainTextToken;

Anda dapat melacak token yang berbeda dan mencabutnya secara individual jika diperlukan.

Tips dan Trik Laravel Sanctum untuk Pengembangan yang Efisien

Berikut beberapa tips dan trik yang dapat membantu Anda menggunakan Laravel Sanctum secara lebih efektif:

• Jangan Pernah Simpan plainTextToken di Database: plainTextToken hanya boleh ditampilkan sekali kepada pengguna dan harus disimpan dengan aman di sisi client. Laravel Sanctum menyimpan hash dari token di database, bukan token aslinya.
• Gunakan Nama Token yang Deskriptif: Berikan nama yang jelas dan deskriptif untuk setiap token agar Anda dapat dengan mudah mengidentifikasi aplikasi atau layanan yang menggunakan token tersebut.
• Implementasikan Revoke Token: Berikan fitur kepada pengguna untuk mencabut token mereka jika mereka mencurigai token tersebut telah disusupi. Anda dapat menggunakan method tokens()->delete() pada model User untuk menghapus semua token pengguna atau tokens()->where('id', $tokenId)->delete() untuk menghapus token tertentu.
• Konfigurasi CORS dengan Benar: Jika API Anda diakses dari domain lain, pastikan Anda telah mengkonfigurasi CORS dengan benar agar browser tidak memblokir request. Anda dapat menggunakan package fruitcake/laravel-cors untuk mempermudah konfigurasi CORS.
• Gunakan Sanctum dengan Inertia.js atau Livewire: Sanctum bekerja dengan baik dengan framework seperti Inertia.js atau Livewire. Pastikan Anda mengkonfigurasi middleware EnsureFrontendRequestsAreStateful dengan benar.
• Uji Autentikasi dan Otorisasi Secara Menyeluruh: Pastikan Anda menguji semua endpoint API Anda untuk memastikan bahwa autentikasi dan otorisasi berfungsi dengan benar. Gunakan tools seperti Postman atau Insomnia untuk melakukan pengujian API.
• Perbarui Sanctum Secara Teratur: Pastikan Anda selalu menggunakan versi terbaru dari Laravel Sanctum untuk mendapatkan perbaikan bug dan fitur keamanan terbaru.

Kesimpulan: Laravel Sanctum, Pilihan Terbaik untuk Autentikasi API yang Mudah dan Aman

Laravel Sanctum adalah solusi autentikasi API yang sederhana, aman, dan mudah digunakan. Baik Anda sedang membangun SPA, aplikasi mobile, atau API untuk pihak ketiga, Sanctum dapat membantu Anda mengamankan aplikasi Anda tanpa perlu konfigurasi yang rumit. Dengan fitur-fitur seperti autentikasi berbasis token, autentikasi berbasis cookie, otorisasi, dan multiple API tokens, Sanctum memberikan fleksibilitas dan kontrol yang Anda butuhkan.

Jangan ragu untuk mencoba Laravel Sanctum di project Anda berikutnya! Dengan dokumentasi yang lengkap dan komunitas yang besar, Anda akan dengan mudah menemukan semua yang Anda butuhkan untuk memulai. Selamat mencoba dan semoga artikel ini bermanfaat!