Laravel, framework PHP yang populer, menawarkan berbagai cara untuk membangun aplikasi web yang kuat dan aman. Salah satu fitur keamanan yang sangat bermanfaat adalah Laravel Sanctum, sebuah solusi autentikasi API berbasis token yang ringan. Artikel ini akan memandu Anda melalui cara membuat API dengan Laravel Sanctum, menunjukkan bagaimana Anda dapat mengamankan aplikasi web Anda dengan Laravel menggunakan metode ini. Mari kita mulai!

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

Sebelum kita masuk ke detail teknis, mari kita pahami dulu apa itu Laravel Sanctum dan mengapa ini menjadi pilihan yang baik untuk autentikasi API Anda.

Laravel Sanctum adalah paket Laravel yang menyediakan sistem autentikasi sederhana untuk aplikasi single-page (SPA), aplikasi mobile, dan API. Sanctum menggunakan token API, bukan sesi cookies, untuk mengautentikasi permintaan. Ini membuatnya sangat ideal untuk:

• Aplikasi SPA (Single-Page Application): Sanctum memungkinkan Anda mengautentikasi SPA Anda dengan mudah tanpa perlu mengelola cookie atau menggunakan autentikasi berbasis OAuth yang lebih rumit.
• Aplikasi Mobile: Aplikasi mobile dapat menggunakan Sanctum untuk mengautentikasi pengguna dengan token API yang disimpan dengan aman di perangkat.
• API Sederhana: Sanctum cocok untuk API yang tidak memerlukan otorisasi tingkat lanjut (seperti izin berbasis peran) dan hanya membutuhkan autentikasi dasar.

Keuntungan Menggunakan Laravel Sanctum:

• Ringan dan Mudah Digunakan: Dibandingkan dengan metode autentikasi API yang lebih kompleks seperti OAuth2, Sanctum lebih sederhana untuk diimplementasikan dan dikonfigurasi.
• Aman: Sanctum menggunakan token API yang dilindungi dengan baik, mengurangi risiko pencurian identitas dan serangan CSRF.
• Fleksibel: Sanctum dapat dikustomisasi untuk memenuhi kebutuhan spesifik aplikasi Anda.
• Integrasi yang Baik dengan Laravel: Sanctum terintegrasi dengan baik dengan fitur-fitur Laravel lainnya, seperti middleware autentikasi.

2. Persiapan: Menginstal Laravel dan Laravel Sanctum

Langkah pertama dalam cara membuat API dengan Laravel Sanctum adalah memastikan Anda memiliki proyek Laravel yang sudah berjalan. Jika belum, Anda dapat membuat proyek Laravel baru dengan perintah berikut:

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

Setelah proyek Laravel Anda siap, Anda perlu menginstal Laravel Sanctum menggunakan Composer:

composer require laravel/sanctum

Setelah instalasi selesai, publikasikan file konfigurasi Sanctum dan migrasikan database:

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

Perintah vendor:publish akan menyalin file konfigurasi config/sanctum.php ke direktori config Anda. Anda dapat menyesuaikan file ini sesuai kebutuhan Anda.

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

3. Konfigurasi Model User untuk Menggunakan Sanctum

Agar model User Anda dapat menggunakan fitur autentikasi Sanctum, Anda perlu menambahkan trait HasApiTokens ke model AppModelsUser. Buka file app/Models/User.php dan tambahkan use LaravelSanctumHasApiTokens; dan trait tersebut:

<?php

namespace AppModels;

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

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

    // ... kode lainnya ...
}

Trait HasApiTokens menyediakan metode yang diperlukan untuk menghasilkan dan mengelola token API untuk pengguna.

4. Membuat Endpoint API untuk Registrasi dan Login

Sekarang kita akan membuat endpoint API untuk registrasi (pendaftaran pengguna baru) dan login (masuk pengguna).

4.1. Controller untuk Registrasi dan Login (UserController.php):

Buat sebuah controller baru bernama UserController menggunakan perintah Artisan:

php artisan make:controller UserController

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

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;
use IlluminateSupportStr;

class UserController 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(['error' => $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',
        ], 201);
    }

    public function login(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email' => 'required|string|email|max:255',
            'password' => 'required|string|min:8',
        ]);

        if ($validator->fails()) {
            return response()->json(['error' => $validator->errors()], 400);
        }

        $user = User::where('email', $request->email)->first();

        if (!$user || !Hash::check($request->password, $user->password)) {
            return response()->json(['error' => 'Invalid Credentials'], 401);
        }

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

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

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

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

Penjelasan Kode:

• register(Request $request): Menerima data registrasi dari request. Memvalidasi data, membuat user baru, dan menghasilkan token API menggunakan createToken().
• login(Request $request): Menerima data login dari request. Memvalidasi data, mencari user berdasarkan email, dan memverifikasi password menggunakan Hash::check(). Jika berhasil, menghasilkan token API.
• logout(Request $request): Menghapus token API yang digunakan oleh user yang sedang login.

4.2. Route untuk Registrasi dan Login (routes/api.php):

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

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersUserController;

/*
|--------------------------------------------------------------------------
| 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', [UserController::class, 'register']);
Route::post('/login', [UserController::class, 'login']);

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

Penjelasan Kode:

• Route::post('/register', [UserController::class, 'register']);: Route untuk endpoint registrasi.
• Route::post('/login', [UserController::class, 'login']);: Route untuk endpoint login.
• Route::middleware('auth:sanctum')->group(function () { ... });: Grup route yang dilindungi oleh middleware auth:sanctum. Hanya user yang telah terautentikasi (memiliki token API yang valid) yang dapat mengakses route di dalam grup ini.
• Route::get('/user', function (Request $request) { return $request->user(); });: Route untuk mendapatkan data user yang sedang login.
• Route::post('/logout', [UserController::class, 'logout']);: Route untuk logout.

5. Menguji Endpoint Registrasi dan Login

Sekarang, mari kita uji endpoint yang baru saja kita buat menggunakan aplikasi seperti Postman atau Insomnia.

5.1. Uji Endpoint Registrasi:

• Method: POST

• URL: /api/register

• Body (JSON):

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

  Anda seharusnya mendapatkan response JSON yang berisi data user yang baru dibuat, access token, dan token type.

5.2. Uji Endpoint Login:

• Method: POST

• URL: /api/login

• Body (JSON):

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

  Anda seharusnya mendapatkan response JSON yang berisi data user yang login, access token, dan token type.

5.3. Uji Endpoint User (Membutuhkan Token):

• Method: GET

• URL: /api/user

• Header: Authorization: Bearer <access_token> (ganti <access_token> dengan token yang Anda dapatkan dari endpoint login)

  Anda seharusnya mendapatkan response JSON yang berisi data user yang sedang login.

5.4. Uji Endpoint Logout (Membutuhkan Token):

• Method: POST

• URL: /api/logout

• Header: Authorization: Bearer <access_token> (ganti <access_token> dengan token yang Anda dapatkan dari endpoint login)

  Anda seharusnya mendapatkan response JSON yang berisi pesan sukses.

6. Mengamankan Route API Lainnya dengan Laravel Sanctum

Setelah Anda berhasil membuat endpoint registrasi dan login, Anda dapat menggunakan middleware auth:sanctum untuk mengamankan route API lainnya. Caranya sama seperti yang kita lakukan pada route /api/user dan /api/logout.

Contoh:

Route::middleware('auth:sanctum')->group(function () {
    // Route API yang dilindungi
    Route::get('/products', [ProductController::class, 'index']);
    Route::post('/products', [ProductController::class, 'store']);
    // ... route lainnya ...
});

Dengan menambahkan middleware auth:sanctum ke grup route, hanya user yang telah terautentikasi (memiliki token API yang valid) yang dapat mengakses route /products.

7. Kustomisasi Konfigurasi Laravel Sanctum

Laravel Sanctum menawarkan beberapa opsi konfigurasi yang dapat Anda sesuaikan di file config/sanctum.php. Beberapa konfigurasi penting termasuk:

• stateful: Menentukan domain mana yang dianggap stateful. Ini penting jika aplikasi Anda berjalan di domain yang berbeda dengan API Anda. Secara default, localhost dan 127.0.0.1 dianggap stateful.
• expiration: Menentukan berapa lama token API akan berlaku (dalam menit). Secara default, token tidak akan kedaluwarsa kecuali secara manual dihapus. Sangat disarankan untuk mengatur masa berlaku token untuk keamanan yang lebih baik.

Pastikan untuk membaca dokumentasi resmi Laravel Sanctum untuk informasi lebih lanjut tentang opsi konfigurasi yang tersedia.

8. Tips Tambahan untuk Keamanan API dengan Sanctum

Selain menggunakan Laravel Sanctum, ada beberapa tips tambahan yang dapat Anda terapkan untuk meningkatkan keamanan API Anda:

• Validasi Input: Selalu validasi input dari user untuk mencegah serangan seperti SQL injection dan cross-site scripting (XSS).
• Rate Limiting: Terapkan rate limiting untuk membatasi jumlah request yang dapat dilakukan oleh seorang user dalam jangka waktu tertentu. Ini dapat membantu mencegah serangan brute-force dan DDoS.
• Gunakan HTTPS: Pastikan aplikasi Anda menggunakan HTTPS untuk mengenkripsi data yang dikirim antara client dan server.
• Regular Audit: Lakukan audit keamanan secara berkala untuk mengidentifikasi dan memperbaiki potensi kerentanan.
• Simpan Token dengan Aman: Instruksikan pengguna untuk menyimpan token API mereka dengan aman dan hindari menyimpan token di client-side (seperti Local Storage) jika memungkinkan. Gunakan cara yang lebih aman seperti HTTP Only cookies atau penyimpanan yang lebih terenkripsi dan aman.

9. Laravel Sanctum vs. Laravel Passport: Kapan Menggunakan yang Mana?

Laravel menawarkan dua paket autentikasi API utama: Laravel Sanctum dan Laravel Passport. Penting untuk memahami perbedaan antara keduanya untuk memilih yang paling sesuai untuk kebutuhan Anda.

• Laravel Sanctum: Sederhana, ringan, dan ideal untuk SPA, aplikasi mobile, dan API sederhana yang tidak memerlukan otorisasi tingkat lanjut.
• Laravel Passport: Implementasi OAuth2 yang lebih lengkap dan kompleks. Cocok untuk API yang memerlukan otorisasi tingkat lanjut, seperti izin berbasis peran (Role-Based Access Control – RBAC) atau kemampuan untuk memberikan akses ke aplikasi pihak ketiga.

Secara umum, jika Anda hanya memerlukan autentikasi dasar untuk aplikasi SPA atau mobile, Laravel Sanctum adalah pilihan yang lebih baik. Jika Anda membutuhkan otorisasi yang lebih kompleks, Laravel Passport mungkin lebih sesuai.

10. Kesimpulan: Mengamankan Aplikasi Web Anda dengan API Laravel Sanctum

Dalam artikel ini, kita telah membahas cara membuat API dengan Laravel Sanctum dan bagaimana ini dapat membantu Anda mengamankan aplikasi web Anda dengan Laravel. Sanctum adalah solusi autentikasi API berbasis token yang mudah digunakan, aman, dan fleksibel. Dengan mengikuti langkah-langkah yang telah kita bahas, Anda dapat dengan mudah mengintegrasikan Sanctum ke dalam proyek Laravel Anda dan melindungi API Anda dari akses yang tidak sah.

Ingatlah untuk selalu mengikuti praktik keamanan terbaik dan terus memperbarui pengetahuan Anda tentang keamanan aplikasi web untuk memastikan aplikasi Anda tetap aman dan terlindungi. Selamat mencoba!