Selamat datang! Dalam artikel ini, kita akan membahas tuntas cara membuat API Authentication dengan Laravel Sanctum. Jika Anda seorang pengembang web yang sedang membangun API menggunakan Laravel, dan membutuhkan cara sederhana namun aman untuk mengautentikasi aplikasi Anda, maka Anda berada di tempat yang tepat. Laravel Sanctum adalah solusi ringan yang sempurna untuk proyek-proyek seperti single-page application (SPA), aplikasi seluler, dan API sederhana. Mari kita mulai!

Apa Itu Laravel Sanctum dan Mengapa Memilihnya?

Laravel Sanctum, sebelumnya dikenal sebagai Laravel Airlock, adalah paket Laravel yang menyediakan sistem otentikasi sederhana berbasis token untuk SPA (Single Page Applications), aplikasi seluler, dan API sederhana. Ia memungkinkan aplikasi Anda untuk menghasilkan token API untuk mengautentikasi pengguna tanpa harus melalui proses OAuth2 yang rumit.

Mengapa memilih Laravel Sanctum?

• Ringan dan Mudah Digunakan: Sanctum sangat mudah diatur dan digunakan, bahkan untuk proyek-proyek yang relatif kecil.
• Cocok untuk SPA dan Aplikasi Seluler: Dirancang khusus untuk kebutuhan otentikasi API pada aplikasi berbasis JavaScript (Vue.js, React, Angular) dan aplikasi mobile (Android, iOS).
• Keamanan: Sanctum menggunakan cookie dan mekanisme proteksi CSRF untuk memastikan keamanan otentikasi.
• Fleksibel: Mendukung multiple API tokens per user, memungkinkan kontrol granular terhadap akses.
• Laravel-native: Terintegrasi dengan baik dengan ekosistem Laravel lainnya, seperti middleware dan gates.

Dengan kata lain, membuat API Authentication dengan Laravel Sanctum adalah pilihan cerdas jika Anda mencari solusi yang cepat, aman, dan mudah diintegrasikan ke dalam proyek Laravel Anda.

Related Post

Cara Meningkatkan Keamanan Website Laravel dari Serangan Hacker

June 26, 2025

Top 5 Package Laravel yang Mempermudah Pengembangan Website Anda

June 26, 2025

Cara Menggunakan Laravel Eloquent untuk Query Database: Panduan Lengkap

June 25, 2025

Tutorial Membuat CRUD dengan Laravel untuk Pemula: Step-by-Step

June 25, 2025

Persiapan Awal: Instalasi dan Konfigurasi Laravel Sanctum

Sebelum kita mulai membuat API Authentication dengan Laravel Sanctum, kita perlu mempersiapkan lingkungan pengembangan kita. Pastikan Anda telah menginstal Laravel dan composer. Jika belum, ikuti langkah-langkah berikut:

1. Instal Laravel:

   composer create-project --prefer-dist laravel/laravel your-project-name
   cd your-project-name

2. Konfigurasi Database:

   • Buat database baru di server database Anda (misalnya MySQL, PostgreSQL).
   • Buka file .env di direktori proyek Anda.
   • Isi informasi koneksi database (DB_CONNECTION, DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, DB_PASSWORD) dengan detail database yang Anda buat.

3. Instal Laravel Sanctum:

   composer require laravel/sanctum

4. Publish Konfigurasi dan Migrasi:

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

5. Migrasi Database:

   php artisan migrate

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

6. Konfigurasi Model User:

Pastikan model User Anda (AppModelsUser) menggunakan trait LaravelSanctumHasApiTokens. Buka file AppModelsUser.php dan tambahkan use HasApiTokens; ke class User.

   <?php

   namespace AppModels;

   use IlluminateContractsAuthMustVerifyEmail;
   use IlluminateDatabaseEloquentFactoriesHasFactory;
   use IlluminateFoundationAuthUser as Authenticatable;
   use IlluminateNotificationsNotifiable;
   use LaravelSanctumHasApiTokens;

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

       // ... (Kode lain dari model User)
   }

Dengan langkah-langkah ini, Anda telah berhasil menyiapkan Laravel Sanctum dan siap untuk melanjutkan ke tahap selanjutnya.

Membuat API: Rute dan Controller untuk Autentikasi

Sekarang, kita akan membuat API yang akan kita gunakan untuk mengautentikasi pengguna. Kita akan membuat rute dan controller untuk registrasi, login, dan logout.

1. Membuat Controller:

   Gunakan Artisan untuk membuat controller AuthController:

   php artisan make:controller AuthController

   Buka file app/Http/Controllers/AuthController.php dan tambahkan kode berikut:

   <?php
   
   namespace AppHttpControllers;
   
   use AppModelsUser;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesAuth;
   use IlluminateSupportFacadesHash;
   use IlluminateSupportFacadesValidator;
   
   class AuthController extends Controller
   {
       public function register(Request $request)
       {
           $validator = Validator::make($request->all(), [
               'name' => 'required|string|max:255',
               'email' => 'required|string|email|max:255|unique:users',
               'password' => 'required|string|min:8'
           ]);
   
           if ($validator->fails()) {
               return response()->json(['errors' => $validator->errors()], 400);
           }
   
           $user = User::create([
               'name' => $request->name,
               'email' => $request->email,
               'password' => Hash::make($request->password)
           ]);
   
           $token = $user->createToken('auth_token')->plainTextToken;
   
           return response()->json([
               'data' => $user,
               '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([
               'data' => $user,
               'access_token' => $token,
               'token_type' => 'Bearer',
           ]);
       }
   
       public function logout()
       {
           auth()->user()->tokens()->delete();
   
           return [
               'message' => 'You have successfully logged out and the token was successfully deleted'
           ];
       }
   
       public function profile() {
           return response()->json(['data' => auth()->user()]);
       }
   }

2. Membuat Rute API:

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

   <?php
   
   use AppHttpControllersAuthController;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesRoute;
   
   /*
   |--------------------------------------------------------------------------
   | 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::middleware('auth:sanctum')->group( function () {
       Route::post('/logout', [AuthController::class, 'logout']);
       Route::get('/profile', [AuthController::class, 'profile']);
   });

   Perhatikan penggunaan middleware auth:sanctum untuk melindungi rute yang memerlukan autentikasi (seperti logout dan profile). Middleware ini akan memastikan bahwa hanya pengguna yang terautentikasi dengan token Sanctum yang valid yang dapat mengakses rute ini.

Dengan kode ini, kita telah berhasil membuat API dasar untuk registrasi, login, logout, dan mendapatkan profil pengguna.

Menguji API Authentication dengan Postman

Setelah kita membuat API Authentication dengan Laravel Sanctum dan rute yang diperlukan, saatnya untuk menguji apakah API kita berfungsi dengan benar. Kita akan menggunakan Postman untuk melakukan ini.

1. Registrasi Pengguna:

   • Buka Postman dan buat permintaan POST ke http://localhost:8000/api/register.

   • Di tab “Body”, pilih “raw” dan “JSON”.

   • Masukkan data berikut:

     {
         "name": "John Doe",
         "email": "[email protected]",
         "password": "password123"
     }

   • Klik “Send”. Anda seharusnya menerima respons JSON yang berisi data pengguna, access token, dan token type.

2. Login Pengguna:

   • Buat permintaan POST ke http://localhost:8000/api/login.

   • Di tab “Body”, pilih “raw” dan “JSON”.

   • Masukkan data berikut:

     {
         "email": "[email protected]",
         "password": "password123"
     }

   • Klik “Send”. Anda seharusnya menerima respons JSON yang sama seperti saat registrasi.

3. Mengakses Rute yang Dilindungi (Profile):

   • Buat permintaan GET ke http://localhost:8000/api/profile.
   • Di tab “Authorization”, pilih “Bearer Token”.
   • Masukkan access token yang Anda terima saat registrasi atau login.
   • Klik “Send”. Anda seharusnya menerima respons JSON yang berisi data profil pengguna.

4. Logout Pengguna:

   • Buat permintaan POST ke http://localhost:8000/api/logout.
   • Di tab “Authorization”, pilih “Bearer Token”.
   • Masukkan access token yang Anda terima saat registrasi atau login.
   • Klik “Send”. Anda seharusnya menerima respons dengan pesan sukses.

   Setelah logout, jika Anda mencoba mengakses rute http://localhost:8000/api/profile lagi dengan token yang sama, Anda akan menerima respons error 401 Unauthorized.

Dengan pengujian ini, kita telah memvalidasi bahwa proses membuat API Authentication dengan Laravel Sanctum kita berfungsi dengan benar.

Mengamankan API Anda dengan Lebih Lanjut: Rate Limiting dan Validasi Input

Meskipun Laravel Sanctum menyediakan mekanisme otentikasi yang aman, ada beberapa langkah tambahan yang dapat Anda ambil untuk lebih mengamankan API Anda.

1. Rate Limiting:

   Rate limiting membatasi jumlah permintaan yang dapat dibuat oleh pengguna dalam jangka waktu tertentu. Ini membantu mencegah serangan brute-force dan DDoS.

   • Buka file app/Http/Kernel.php.

   • Di properti $routeMiddleware, tambahkan middleware throttle (jika belum ada).

   • Di file routes/api.php, terapkan middleware throttle ke rute yang ingin Anda batasi:

     Route::middleware('auth:sanctum', 'throttle:60,1')->group( function () {
         Route::post('/logout', [AuthController::class, 'logout']);
         Route::get('/profile', [AuthController::class, 'profile']);
     });

     throttle:60,1 berarti pengguna hanya dapat membuat 60 permintaan per menit.

2. Validasi Input yang Ketat:

   Pastikan Anda selalu memvalidasi input dari pengguna untuk mencegah serangan injeksi dan manipulasi data. Kita sudah menggunakan validasi di controller Auth, tetapi selalu periksa dan validasi data lain yang dikirim oleh pengguna.

3. Menggunakan HTTPS:

   Pastikan semua komunikasi antara klien dan server Anda menggunakan HTTPS untuk mengenkripsi data yang sensitif. Ini penting terutama untuk token API.

4. Menyimpan Token dengan Aman di Klien:

   Jika Anda menggunakan aplikasi JavaScript, simpan token API di lokasi yang aman, seperti localStorage atau cookie yang hanya dapat diakses oleh server (HTTP-only cookie). Hindari menyimpan token di kode sumber atau tempat lain yang rentan.

5. Rotasi Token:

   Implementasikan mekanisme untuk merotasi token secara berkala. Ini berarti menghasilkan token baru dan menonaktifkan token lama. Ini mengurangi dampak jika token dicuri.

Dengan menerapkan langkah-langkah ini, Anda dapat meningkatkan keamanan API Anda secara signifikan.

Memvalidasi Token API dan Menangani Kesalahan

Ketika membuat API Authentication dengan Laravel Sanctum, penting untuk memastikan bahwa token API yang diberikan oleh pengguna valid dan menangani kesalahan otentikasi dengan benar.

1. Middleware auth:sanctum:

   Middleware auth:sanctum secara otomatis memvalidasi token API. Jika token tidak valid atau tidak ada, middleware ini akan mengembalikan respons error 401 Unauthorized.

2. Menangani Kesalahan 401 Unauthorized:

   Anda dapat menyesuaikan respons error 401 Unauthorized dengan menggunakan exception handler. Buka file app/Exceptions/Handler.php dan tambahkan kode berikut ke metode render():

   public function render($request, Throwable $exception)
   {
       if ($exception instanceof IlluminateAuthAuthenticationException && $request->wantsJson()) {
           return response()->json(['message' => 'Unauthenticated.'], 401);
       }
   
       return parent::render($request, $exception);
   }

   Ini akan memastikan bahwa API selalu mengembalikan respons JSON dengan pesan yang jelas jika otentikasi gagal.

3. Mengakses Pengguna yang Terautentikasi:

   Di controller Anda, Anda dapat mengakses pengguna yang terautentikasi menggunakan fungsi auth()->user().

4. Memeriksa Izin (Authorization):

   Selain otentikasi, Anda mungkin juga perlu mengimplementasikan authorization untuk menentukan apa yang dapat dilakukan oleh pengguna yang terautentikasi. Laravel menyediakan fitur gates dan policies untuk melakukan ini.

Integrasi Laravel Sanctum dengan SPA (Single Page Application)

Salah satu kasus penggunaan utama Laravel Sanctum adalah integrasi dengan SPA. Berikut adalah langkah-langkah untuk mengintegrasikan Sanctum dengan aplikasi JavaScript seperti Vue.js atau React:

1. Konfigurasi Sanctum untuk CORS:

   Pastikan CORS (Cross-Origin Resource Sharing) dikonfigurasi dengan benar untuk mengizinkan permintaan dari domain SPA Anda. Buka file config/cors.php dan sesuaikan pengaturan paths dan allowed_origins.

   'paths' => ['api/*', 'sanctum/csrf-cookie'], // Tambahkan 'sanctum/csrf-cookie'
   'allowed_origins' => ['http://localhost:3000'], // Ganti dengan domain SPA Anda
   'allowed_methods' => ['*'],
   'allowed_headers' => ['*'],
   'exposed_headers' => [],
   'supports_credentials' => true, // Penting untuk Cookie
   'max_age' => 0,

2. Mendapatkan CSRF Cookie:

   Sebelum mengirim permintaan otentikasi ke API, SPA Anda perlu mendapatkan CSRF cookie. Buat permintaan GET ke rute /sanctum/csrf-cookie sebelum melakukan permintaan login atau registrasi. Ini akan mengatur cookie XSRF-TOKEN yang diperlukan untuk proteksi CSRF.

   // Contoh menggunakan Axios
   axios.get('/sanctum/csrf-cookie').then(response => {
       // Lanjutkan dengan permintaan login atau registrasi
   });

3. Mengirim Permintaan Otentikasi:

   Kirim permintaan POST ke API untuk registrasi dan login. Sertakan cookie XSRF-TOKEN di header permintaan. Axios secara otomatis akan menambahkan cookie ini jika dikonfigurasi dengan benar.

4. Menyimpan Token API (dengan Hati-hati):

   Simpan token API yang diterima dari respons login di localStorage atau cookie yang hanya dapat diakses oleh server (HTTP-only cookie). Pilih metode penyimpanan yang paling sesuai dengan kebutuhan keamanan Anda.

5. Menambahkan Token API ke Header Permintaan:

   Tambahkan token API ke header Authorization setiap kali Anda mengirim permintaan ke rute yang dilindungi.

   // Contoh menggunakan Axios
   axios.defaults.headers.common['Authorization'] = `Bearer ${localStorage.getItem('token')}`;

Dengan langkah-langkah ini, Anda dapat mengintegrasikan Laravel Sanctum dengan SPA Anda dan mengamankan API Anda.

Kesimpulan: Membuat API Authentication dengan Laravel Sanctum adalah Mudah dan Aman

Dalam artikel ini, kita telah membahas secara mendalam cara membuat API Authentication dengan Laravel Sanctum. Kita telah membahas instalasi, konfigurasi, pembuatan API, pengujian, keamanan tambahan, penanganan kesalahan, dan integrasi dengan SPA.

Membuat API Authentication dengan Laravel Sanctum adalah proses yang relatif mudah dan memberikan solusi yang aman untuk mengautentikasi aplikasi Anda. Dengan mengikuti panduan ini dan menyesuaikannya dengan kebutuhan proyek Anda, Anda dapat membangun API yang kuat dan aman dengan Laravel. Jangan lupa untuk selalu memprioritaskan keamanan dan mengikuti praktik terbaik untuk melindungi data pengguna Anda. Selamat mencoba!