Oke, ini dia artikel SEO tentang Laravel Sanctum dalam Bahasa Indonesia, dengan memperhatikan semua instruksi yang kamu berikan.

Selamat datang! Apakah kamu sedang mencari cara untuk mengamankan API Laravel-mu dengan mudah? Jika iya, kamu berada di tempat yang tepat! Dalam artikel ini, kita akan membahas tuntas tentang Laravel Sanctum: Otentikasi API Sederhana dan Aman dengan Laravel Sanctum. Kita akan menjelajahi apa itu Laravel Sanctum, mengapa kamu harus menggunakannya, bagaimana cara kerjanya, dan bagaimana cara mengimplementasikannya langkah demi langkah. Jadi, mari kita mulai!

Apa itu Laravel Sanctum dan Mengapa Kamu Harus Menggunakannya?

Laravel Sanctum adalah paket otentikasi ringan untuk aplikasi Laravel. Bayangkan kamu punya aplikasi Laravel yang menyediakan API untuk aplikasi mobile atau frontend JavaScript modern (seperti Vue atau React). Kamu perlu cara untuk memverifikasi bahwa permintaan yang datang ke API-mu memang berasal dari pengguna yang sah. Di sinilah Laravel Sanctum hadir!

Secara sederhana, Laravel Sanctum menyediakan mekanisme otentikasi berbasis token yang ringan dan aman. Ini berbeda dengan otentikasi berbasis sesi tradisional yang biasanya digunakan untuk aplikasi web berbasis browser. Kenapa harus Sanctum? Berikut beberapa alasannya:

Related Post

Laravel Artisan: Command Line Interface yang Memudahkan Pengembangan Laravel

August 29, 2025

Laravel Eloquent: ORM yang Memudahkan Interaksi dengan Database di Laravel

August 28, 2025

Laravel Migration: Mengelola Database dengan Mudah Menggunakan Laravel Migration

August 28, 2025

Laravel Blade: Template Engine yang Memudahkan Pembuatan Tampilan Website

August 28, 2025

• Sederhana: Konfigurasi dan implementasinya relatif mudah dibandingkan dengan solusi otentikasi API lainnya seperti OAuth2 yang lebih kompleks.
• Aman: Sanctum menggunakan token API yang terenkripsi, sehingga lebih aman daripada mengirimkan kredensial pengguna langsung di setiap permintaan.
• Skalabel: Sanctum dapat digunakan untuk aplikasi dengan skala kecil maupun besar.
• Fleksibel: Sanctum cocok untuk otentikasi API untuk aplikasi mobile, SPA (Single-Page Application), dan bahkan aplikasi web biasa.
• CSRF Protection (Perlindungan CSRF): Sanctum secara otomatis menangani perlindungan CSRF untuk otentikasi berbasis cookie pada aplikasi web. Ini penting untuk mencegah serangan Cross-Site Request Forgery.

Singkatnya, jika kamu butuh otentikasi API yang cepat, aman, dan mudah diimplementasikan di aplikasi Laravelmu, Laravel Sanctum adalah pilihan yang tepat.

Bagaimana Cara Kerja Otentikasi dengan Laravel Sanctum?

Sebelum kita masuk ke kode, mari kita pahami dulu bagaimana cara kerja autentikasi API Laravel Sanctum secara garis besar:

1. Pengguna Login/Register: Pengguna melakukan login (atau register) melalui aplikasi frontend.
2. Meminta Token API: Setelah berhasil login, aplikasi frontend meminta token API dari backend Laravel menggunakan endpoint yang telah ditentukan.
3. Token Diterbitkan: Backend Laravel (menggunakan Sanctum) membuat dan memberikan token API yang unik untuk pengguna tersebut. Token ini disimpan di database.
4. Token Disimpan di Frontend: Aplikasi frontend menyimpan token API ini, biasanya di localStorage atau sessionStorage (untuk SPA) atau sebagai cookie (jika menggunakan otentikasi berbasis cookie).
5. Permintaan API dengan Token: Setiap kali aplikasi frontend membuat permintaan ke API, token API dilampirkan di header Authorization dengan format Bearer {token}.
6. Verifikasi Token: Backend Laravel (dengan Sanctum) menerima permintaan tersebut, mengekstrak token dari header Authorization, dan memvalidasinya.
7. Otentikasi Berhasil: Jika token valid, Sanctum mengotentikasi pengguna dan memberikan akses ke resource API yang diminta. Jika token tidak valid, permintaan ditolak dengan pesan error 401 (Unauthorized).

Intinya, token API bertindak sebagai “kunci” yang memungkinkan pengguna yang sah untuk mengakses API-mu.

Instalasi dan Konfigurasi Laravel Sanctum: Langkah Demi Langkah

Sekarang kita sudah paham teorinya, mari kita praktikkan! Berikut adalah langkah-langkah untuk menginstal dan mengkonfigurasi Laravel Sanctum di proyek Laravel kamu:

1. Instal Paket Sanctum: Buka terminal dan masuk ke direktori proyek Laravel kamu. Kemudian, jalankan perintah berikut untuk menginstal paket Sanctum menggunakan Composer:

   composer require laravel/sanctum

2. Publish Konfigurasi dan Migrasi: Setelah instalasi selesai, publish file konfigurasi dan migrasi Sanctum dengan perintah:

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

   Perintah ini akan membuat file konfigurasi config/sanctum.php dan file migrasi di direktori database/migrations.

3. Jalankan Migrasi: Jalankan migrasi untuk membuat tabel yang dibutuhkan oleh Sanctum di database:

   php artisan migrate

   Secara default, Sanctum akan membuat tabel personal_access_tokens untuk menyimpan token API.

4. Konfigurasi Model User: Buka model AppModelsUser (atau model pengguna kamu yang lain) dan tambahkan HasApiTokens trait:

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

   Trait HasApiTokens menambahkan fungsi yang diperlukan untuk membuat dan mengelola token API.

5. Konfigurasi Middleware Sanctum: Buka file app/Http/Kernel.php dan tambahkan middleware EnsureFrontendRequestsAreStateful ke grup middleware api. Ini penting jika kamu menggunakan otentikasi berbasis cookie:

   protected $middlewareGroups = [
       'api' => [
           AppHttpMiddlewareEncryptCookies::class,  // Jika menggunakan cookie
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class, // Jika menggunakan cookie
           IlluminateSessionMiddlewareStartSession::class,  // Jika menggunakan cookie
           IlluminateViewMiddlewareShareErrorsFromSession::class, // Jika menggunakan cookie
           AppHttpMiddlewareVerifyCsrfToken::class, // Jika menggunakan cookie
           'throttle:api',
           IlluminateRoutingMiddlewareSubstituteBindings::class,
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Tambahkan ini!
       ],
   ];

   Catatan: Jika kamu hanya menggunakan otentikasi berbasis token (misalnya, untuk aplikasi mobile), kamu tidak perlu menambahkan middleware ini.

Membuat Endpoint untuk Login dan Menerbitkan Token

Setelah instalasi selesai, kita perlu membuat endpoint API untuk memungkinkan pengguna login dan mendapatkan token API. Berikut contohnya:

<?php

namespace AppHttpControllers;

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

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

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

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

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

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

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

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

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

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

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

        return [
            'message' => 'Logged out'
        ];
    }
}

Penjelasan Kode:

• login(Request $request): Menerima email dan password dari permintaan. Memvalidasi kredensial pengguna. Jika valid, membuat token API baru menggunakan $user->createToken('auth_token')->plainTextToken;. Mengembalikan token API dan tipe token (Bearer) sebagai respons JSON.
• register(Request $request): Menerima data pendaftaran (nama, email, password). Memvalidasi data. Membuat user baru di database. Membuat token API untuk user yang baru terdaftar. Mengembalikan token API dan tipe token.
• logout(Request $request): Menerima permintaan logout. Menghapus semua token API yang terkait dengan pengguna saat ini menggunakan $request->user()->tokens()->delete();. Mengembalikan pesan sukses.

Definisikan Rute:

Jangan lupa daftarkan rute untuk controller ini di routes/api.php:

<?php

use AppHttpControllersAuthController;
use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);

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

Penjelasan Rute:

• /register: Rute untuk pendaftaran user baru.
• /login: Rute untuk login user dan mendapatkan token API.
• /user: Rute yang hanya bisa diakses oleh user yang sudah terotentikasi (menggunakan middleware auth:sanctum). Mengembalikan informasi user yang sedang login.
• /logout: Rute untuk logout user dan menghapus semua token API miliknya.

Melindungi Rute API dengan Middleware auth:sanctum

Setelah kita mendapatkan token API, kita perlu menggunakannya untuk melindungi rute API kita. Caranya adalah dengan menggunakan middleware auth:sanctum. Contoh:

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

Kode di atas akan memastikan bahwa hanya pengguna yang sudah terotentikasi (memiliki token API yang valid) yang dapat mengakses rute /profile. Jika pengguna belum terotentikasi, mereka akan mendapatkan respons error 401 (Unauthorized).

Mengelola Token API: Revoking dan Expiring Token

Laravel Sanctum menyediakan cara untuk mengelola token API. Kamu bisa mencabut (revoke) token tertentu atau menentukan masa berlaku (expire) token.

Revoking Token:

Untuk mencabut token, kamu bisa menggunakan method delete() pada model PersonalAccessToken:

$token = $request->user()->tokens()->find($tokenId);

if ($token) {
    $token->delete();
}

Kode di atas akan menghapus token dengan ID $tokenId milik pengguna yang sedang login. Ini berguna jika pengguna ingin mencabut akses dari perangkat tertentu.

Expiring Token:

Sayangnya, Laravel Sanctum secara default tidak menyediakan fitur untuk mengatur masa berlaku token secara otomatis. Namun, kamu bisa mengimplementasikannya sendiri dengan menambahkan kolom expires_at ke tabel personal_access_tokens dan membuat scheduler untuk membersihkan token yang sudah kadaluarsa.

Sebagai alternatif, kamu bisa menggunakan paket pihak ketiga seperti spatie/laravel-personal-access-tokens yang menyediakan fitur masa berlaku token secara bawaan.

Otentikasi Berbasis Cookie (Stateful Authentication) vs. Otentikasi Berbasis Token (Stateless Authentication)

Laravel Sanctum mendukung dua jenis otentikasi:

• Otentikasi Berbasis Cookie (Stateful Authentication): Cocok untuk aplikasi web berbasis browser yang menggunakan cookie untuk menyimpan informasi sesi. Middleware EnsureFrontendRequestsAreStateful diperlukan untuk memastikan bahwa permintaan dari frontend dianggap stateful. Fitur CSRF protection otomatis aktif.
• Otentikasi Berbasis Token (Stateless Authentication): Cocok untuk aplikasi mobile atau SPA yang menggunakan header Authorization untuk mengirimkan token API. Tidak memerlukan middleware EnsureFrontendRequestsAreStateful.

Pemilihan jenis otentikasi tergantung pada jenis aplikasi yang kamu bangun. Jika kamu membangun aplikasi web berbasis browser, otentikasi berbasis cookie mungkin lebih mudah dan aman. Jika kamu membangun aplikasi mobile atau SPA, otentikasi berbasis token lebih cocok.

Tips dan Trik Menggunakan Laravel Sanctum

• Gunakan HTTPS: Pastikan aplikasi kamu menggunakan HTTPS untuk mengenkripsi semua komunikasi, termasuk pengiriman token API.
• Jangan Simpan Token di Frontend dengan Sembarangan: Simpan token API dengan aman di frontend. Hindari menyimpan token di tempat yang mudah diakses oleh pihak ketiga. Pertimbangkan untuk menggunakan httpOnly cookie untuk menyimpan token (jika menggunakan otentikasi berbasis cookie) atau menggunakan secure storage yang disediakan oleh platform mobile.
• Implementasikan Fitur Logout: Sediakan fitur logout yang memungkinkan pengguna untuk menghapus token API mereka.
• Pertimbangkan Masa Berlaku Token: Walaupun Sanctum tidak menyediakan fitur masa berlaku token secara default, pertimbangkan untuk mengimplementasikannya sendiri untuk meningkatkan keamanan.
• Gunakan Middleware throttle:api: Lindungi endpoint API kamu dari serangan brute-force dengan menggunakan middleware throttle:api.

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

Laravel memiliki dua pilihan utama untuk otentikasi API: Sanctum dan Passport. Lalu, kapan kita harus menggunakan Sanctum dan kapan kita harus menggunakan Passport?

• Laravel Sanctum: Lebih sederhana dan ringan, cocok untuk proyek kecil hingga menengah yang membutuhkan otentikasi API berbasis token. Ideal untuk SPA, aplikasi mobile, dan aplikasi web yang menggunakan cookie untuk otentikasi.
• Laravel Passport: Lebih kompleks dan powerful, menyediakan implementasi OAuth2 yang lengkap. Cocok untuk proyek besar yang membutuhkan fitur-fitur OAuth2 seperti client credentials grant, authorization code grant, dan lain-lain. Ideal untuk aplikasi yang ingin menyediakan API publik yang dapat diakses oleh pihak ketiga.

Secara umum, mulailah dengan Sanctum kecuali kamu benar-benar membutuhkan fitur-fitur canggih yang ditawarkan oleh Passport. Passport lebih kompleks untuk dikonfigurasi dan diimplementasikan, jadi Sanctum adalah pilihan yang lebih baik jika kamu mencari solusi yang cepat dan mudah.

Kesimpulan: Laravel Sanctum, Pilihan Terbaik untuk Otentikasi API Sederhana

Laravel Sanctum: Otentikasi API Sederhana dan Aman dengan Laravel Sanctum telah menjadi solusi populer bagi para developer Laravel yang ingin mengamankan API mereka dengan mudah. Dengan konfigurasi yang minim dan fitur keamanan yang solid, Sanctum adalah pilihan yang tepat untuk berbagai jenis proyek, mulai dari aplikasi mobile hingga SPA.

Dengan panduan langkah demi langkah yang telah kita bahas di artikel ini, kamu sekarang memiliki semua yang kamu butuhkan untuk mengimplementasikan otentikasi API Laravel Sanctum di proyek kamu sendiri. Selamat mencoba dan semoga berhasil!