Selamat datang, para developer! Apakah kamu sedang mencari cara untuk mengamankan API Laravel kamu dengan mudah dan cepat? Kalau iya, kamu berada di tempat yang tepat! Dalam tutorial ini, kita akan membahas secara lengkap tentang Laravel Sanctum, sebuah package otentikasi API yang simpel namun powerful. Kita akan membahas langkah demi langkah, dari instalasi hingga implementasi, semuanya dalam Bahasa Indonesia yang mudah dimengerti. Jadi, mari kita mulai petualangan Laravel Sanctum Tutorial Bahasa Indonesia: Otentikasi API Aman dan Mudah ini!

1. Apa Itu Laravel Sanctum dan Mengapa Memilihnya?

Sebelum kita menyelam lebih dalam, mari kita pahami dulu apa sebenarnya Laravel Sanctum itu. Sederhananya, Laravel Sanctum adalah sebuah package untuk otentikasi API berbasis token di aplikasi Laravel. Ini memungkinkan kita untuk melakukan otentikasi request dari berbagai sumber, seperti:

• Single-Page Applications (SPA): Seperti aplikasi Vue.js, React, atau Angular.
• Mobile Applications: Aplikasi native di Android dan iOS.
• Browser-Based Applications: Aplikasi web konvensional yang menggunakan cookie.

Lalu, mengapa memilih Laravel Sanctum dibandingkan solusi otentikasi lainnya?

Ada beberapa alasan utama:

Related Post

Paket Belajar Laravel dari Dasar Sampai Mahir: Kuasai Framework PHP Populer

August 23, 2025

Tutorial Laravel untuk Pemula Bahasa Indonesia: Membangun Aplikasi Web Modern

August 23, 2025

Kursus Web Development Online Bahasa Indonesia: Kuasai Pemrograman dari Rumah!

August 21, 2025

Laravel Sanctum Authentication Tutorial Indonesia: Autentikasi Aman dan Mudah dengan Laravel

August 13, 2025

• Kesederhanaan: Sanctum sangat mudah diinstal dan dikonfigurasi. Tidak perlu setup yang rumit.
• Ringan: Sanctum dirancang untuk menjadi ringan dan efisien, tidak memberatkan performa aplikasi.
• Keamanan: Menggunakan token untuk otentikasi, sehingga lebih aman daripada menggunakan session-based authentication di API.
• Out-of-the-box Functionality: Sanctum menyediakan fungsionalitas dasar yang dibutuhkan untuk otentikasi API, seperti login, logout, dan pengelolaan token.
• Kemudahan Integrasi: Sangat mudah diintegrasikan dengan aplikasi Laravel yang sudah ada.

Dengan semua kelebihan ini, Laravel Sanctum adalah pilihan yang tepat untuk mengamankan API kamu dengan cara yang aman dan mudah.

2. Persiapan: Instalasi dan Konfigurasi Laravel Sanctum

Sebelum kita bisa menggunakan Sanctum, tentu saja kita perlu menginstalnya terlebih dahulu. Berikut adalah langkah-langkahnya:

2.1. Instalasi Package Laravel Sanctum

Buka terminal kamu dan arahkan ke direktori project Laravel kamu. Kemudian, jalankan perintah berikut menggunakan Composer:

composer require laravel/sanctum

Perintah ini akan mengunduh dan menginstal package Laravel Sanctum ke project kamu.

2.2. Konfigurasi Database dan Migrasi

Setelah package terinstal, selanjutnya kita perlu melakukan migrasi database. Migrasi ini akan membuat tabel personal_access_tokens yang digunakan Sanctum untuk menyimpan token otentikasi.

Jalankan perintah berikut:

php artisan migrate

Jika kamu belum memiliki database yang terkonfigurasi, pastikan kamu sudah mengatur konfigurasi database di file .env kamu. Contohnya:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database_kamu
DB_USERNAME=username_database
DB_PASSWORD=password_database

2.3. Setup Model User

Selanjutnya, kita perlu menambahkan HasApiTokens trait ke model User kamu. Trait ini menyediakan method yang diperlukan untuk mengelola token API.

Buka file app/Models/User.php dan tambahkan trait HasApiTokens:

<?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 ...
}

2.4. Konfigurasi Middleware

Terakhir, kita perlu memastikan bahwa middleware Sanctum sudah terdaftar di app/Http/Kernel.php. Biasanya, ini sudah dilakukan secara otomatis saat instalasi Sanctum, tetapi tidak ada salahnya untuk memeriksa.

Buka file app/Http/Kernel.php dan pastikan middleware EnsureFrontendRequestsAreStateful terdaftar di $middlewareGroups dan $routeMiddleware:

    protected $middlewareGroups = [
        'web' => [
            AppHttpMiddlewareEncryptCookies::class,
            IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
            IlluminateSessionMiddlewareStartSession::class,
            // IlluminateSessionMiddlewareAuthenticateSession::class,
            IlluminateViewMiddlewareShareErrorsFromSession::class,
            AppHttpMiddlewareVerifyCsrfToken::class,
            IlluminateRoutingMiddlewareSubstituteBindings::class,
        ],

        'api' => [
            LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Tambahkan ini
            'throttle:api',
            IlluminateRoutingMiddlewareSubstituteBindings::class,
        ],
    ];

    protected $routeMiddleware = [
        'auth' => AppHttpMiddlewareAuthenticate::class,
        'cache.headers' => IlluminateHttpMiddlewareSetCacheHeaders::class,
        'guest' => AppHttpMiddlewareRedirectIfAuthenticated::class,
        'throttle' => IlluminateRoutingMiddlewareThrottleRequests::class,
        'signed' => IlluminateRoutingMiddlewareValidateSignature::class,
        'bindings' => IlluminateRoutingMiddlewareSubstituteBindings::class,
        'cacheResponse' => AppHttpMiddlewareCacheResponse::class,
        'doNotCacheResponse' => AppHttpMiddlewareDoNotCacheResponse::class,
        'auth.basic' => IlluminateAuthMiddlewareAuthenticateWithBasicAuth::class,
        'auth.session' => IlluminateAuthMiddlewareAuthenticateSession::class,
        'can' => IlluminateAuthMiddlewareAuthorize::class,
        'verified' => AppHttpMiddlewareEnsureEmailIsVerified::class,
        'stateful' => LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Tambahkan ini
    ];

Dengan langkah-langkah ini, kamu sudah berhasil menginstal dan mengkonfigurasi Laravel Sanctum. Sekarang kita siap untuk mulai mengimplementasikan otentikasi API!

3. Membuat Endpoint Login dan Logout dengan Laravel Sanctum

Endpoint login dan logout adalah inti dari sistem otentikasi. Mari kita buat kedua endpoint ini menggunakan Laravel Sanctum.

3.1. Membuat Controller untuk Otentikasi

Kita akan membuat sebuah controller baru untuk menangani logika otentikasi. Jalankan perintah berikut di terminal:

php artisan make:controller AuthController

Perintah ini akan membuat file app/Http/Controllers/AuthController.php.

3.2. Implementasi Endpoint Login

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

<?php

namespace AppHttpControllers;

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

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

        $credentials = $request->only('email', 'password');

        if (Auth::attempt($credentials)) {
            $user = Auth::user();
            $token = $user->createToken('auth_token')->plainTextToken;

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

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

Penjelasan Kode:

• $request->validate(): Melakukan validasi terhadap inputan email dan password.
• Auth::attempt($credentials): Mencoba melakukan login menggunakan email dan password yang diberikan.
• $user->createToken('auth_token')->plainTextToken: Jika login berhasil, maka akan dibuat sebuah token baru untuk user tersebut. 'auth_token' adalah nama token yang bisa kamu ganti sesuai kebutuhan. plainTextToken mengembalikan token yang bisa kamu gunakan untuk otentikasi.
• response()->json(): Mengembalikan response JSON yang berisi access token dan tipe token (Bearer).
• Jika login gagal, maka akan dikembalikan response dengan status code 401 (Unauthorized).

3.3. Implementasi Endpoint Logout

Tambahkan method logout ke app/Http/Controllers/AuthController.php:

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

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

Penjelasan Kode:

• $request->user(): Mendapatkan instance user yang sedang login. Middleware Sanctum secara otomatis menambahkan instance user ke request jika token yang diberikan valid.
• currentAccessToken()->delete(): Menghapus token yang sedang digunakan oleh user.
• response()->json(): Mengembalikan response JSON yang mengindikasikan logout berhasil.

3.4. Menambahkan Routes

Sekarang, kita perlu menambahkan routes untuk endpoint login dan logout. Buka file routes/api.php dan tambahkan kode berikut:

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersAuthController;

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

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

Penjelasan Kode:

• Route::post('/login', [AuthController::class, 'login']): Mendefinisikan route untuk endpoint login yang akan menangani request POST ke /api/login.
• Route::middleware('auth:sanctum')->group(function () { ... }): Mengelompokkan route-route yang membutuhkan otentikasi. Middleware auth:sanctum akan memastikan bahwa hanya user yang sudah login dan memiliki token yang valid yang bisa mengakses route-route ini.
• Route::post('/logout', [AuthController::class, 'logout']): Mendefinisikan route untuk endpoint logout yang akan menangani request POST ke /api/logout. Route ini berada di dalam grup middleware auth:sanctum, sehingga hanya bisa diakses oleh user yang sudah login.

Dengan langkah ini, kamu sudah berhasil membuat endpoint login dan logout dengan Laravel Sanctum.

4. Mengamankan Route dengan Middleware auth:sanctum

Seperti yang sudah kita lihat sebelumnya, middleware auth:sanctum digunakan untuk mengamankan route-route API kita. Middleware ini akan memeriksa apakah request yang masuk memiliki token yang valid. Jika token valid, maka request akan diteruskan ke controller yang dituju. Jika token tidak valid atau tidak ada, maka request akan ditolak dan dikembalikan response error.

Contoh Penggunaan:

Misalkan kita memiliki sebuah endpoint untuk mendapatkan data user. Endpoint ini hanya boleh diakses oleh user yang sudah login. Kita bisa mengamankan endpoint ini dengan menambahkan middleware auth:sanctum ke route-nya:

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

Pada contoh di atas, hanya user yang sudah login dan memiliki token yang valid yang bisa mengakses endpoint /api/user. Middleware auth:sanctum akan secara otomatis menambahkan instance user yang sedang login ke $request, sehingga kita bisa mengaksesnya melalui $request->user().

5. Menggunakan Token di Frontend: Single-Page Application (SPA)

Setelah kita mendapatkan token dari endpoint login, kita perlu menyimpannya di frontend dan menggunakannya untuk setiap request API yang membutuhkan otentikasi. Cara penyimpanan dan penggunaan token ini berbeda-beda tergantung pada jenis aplikasi frontend yang kita gunakan.

Contoh untuk Single-Page Application (SPA) dengan JavaScript:

Biasanya, token disimpan di localStorage atau sessionStorage. Berikut adalah contoh cara menyimpan dan menggunakan token di SPA:

5.1. Menyimpan Token setelah Login:

Setelah mendapatkan response dari endpoint login, simpan token di localStorage:

fetch('/api/login', {
  method: 'POST',
  body: JSON.stringify({
    email: '[email protected]',
    password: 'password'
  }),
  headers: {
    'Content-Type': 'application/json'
  }
})
.then(response => response.json())
.then(data => {
  localStorage.setItem('token', data.access_token);
  // Redirect ke halaman dashboard atau halaman lainnya
});

5.2. Menambahkan Token ke Header setiap Request:

Sebelum mengirim request API, tambahkan token ke header Authorization dengan format Bearer <token>:

const token = localStorage.getItem('token');

fetch('/api/user', {
  headers: {
    'Authorization': 'Bearer ' + token
  }
})
.then(response => response.json())
.then(data => {
  // Tampilkan data user
});

Pastikan untuk menghapus token dari localStorage atau sessionStorage saat user melakukan logout.

Penting:

• Gunakan HTTPS untuk semua request API untuk mencegah token dicuri.
• Simpan token di localStorage atau sessionStorage dengan hati-hati. Pertimbangkan untuk menggunakan teknik enkripsi tambahan jika diperlukan.
• Hindari menyimpan token di cookie jika memungkinkan, karena cookie lebih rentan terhadap serangan CSRF.

6. Personal Access Tokens (PAT) untuk Aplikasi Third-Party

Laravel Sanctum juga mendukung Personal Access Tokens (PAT). PAT ini sangat berguna jika kamu ingin memberikan akses API ke aplikasi third-party (aplikasi pihak ketiga). Dengan PAT, user dapat membuat token khusus untuk aplikasi third-party tanpa perlu memberikan kredensial login utama mereka.

Cara Membuat PAT:

1. Di Controller atau Route:

   Route::middleware('auth:sanctum')->get('/create-token', function (Request $request) {
       $token = $request->user()->createToken('nama-aplikasi-third-party')->plainTextToken;
   
       return ['token' => $token];
   });

   Pada contoh di atas, user yang sudah login dapat mengakses endpoint /api/create-token untuk membuat PAT dengan nama ‘nama-aplikasi-third-party’.

2. Di Frontend:

   Setelah user membuat PAT, tampilkan token tersebut kepada user. PENTING: Token ini hanya akan ditampilkan sekali saja. User harus menyimpan token ini dengan aman, karena mereka tidak akan bisa melihatnya lagi.

Cara Menggunakan PAT:

Aplikasi third-party dapat menggunakan PAT untuk mengakses API kamu dengan cara yang sama seperti token biasa, yaitu dengan menambahkan PAT ke header Authorization dengan format Bearer <PAT>.

Keuntungan Menggunakan PAT:

• Keamanan: User tidak perlu memberikan kredensial login utama mereka ke aplikasi third-party.
• Revokasi: User dapat dengan mudah mencabut akses aplikasi third-party dengan menghapus token yang bersangkutan.
• Granular Access: Kamu dapat memberikan akses yang lebih spesifik ke aplikasi third-party dengan menggunakan scopes (akan dibahas di bagian selanjutnya).

7. Scopes: Mengontrol Akses API Lebih Detail

Scopes memungkinkan kamu untuk mengontrol akses API lebih detail. Dengan scopes, kamu dapat menentukan permission apa saja yang dimiliki oleh sebuah token. Contohnya, kamu bisa membuat token yang hanya bisa digunakan untuk membaca data, atau token yang hanya bisa digunakan untuk menulis data.

Cara Menggunakan Scopes:

1. Mendefinisikan Scopes:

   Kamu bisa mendefinisikan scopes di model User.php atau di file konfigurasi. Contoh mendefinisikan scopes di model User.php:

   class User extends Authenticatable
   {
       use HasApiTokens, HasFactory, Notifiable;
   
       /**
        * The access token scopes that are available for this user.
        *
        * @var array
        */
       public static $abilities = [
           'read' => 'Read data',
           'write' => 'Write data',
           'update' => 'Update data',
           'delete' => 'Delete data',
       ];
   }

2. Membuat Token dengan Scopes:

   Saat membuat token, kamu bisa menentukan scopes yang ingin diberikan ke token tersebut:

   $token = $request->user()->createToken('nama-aplikasi-third-party', ['read', 'write'])->plainTextToken;

   Pada contoh di atas, token yang dibuat hanya memiliki permission read dan write.

3. Memeriksa Scopes di Middleware:

   Kamu bisa menggunakan middleware ability untuk memeriksa apakah token yang diberikan memiliki scope yang dibutuhkan:

   Route::middleware(['auth:sanctum', 'ability:read'])->get('/data', function () {
       // Hanya user dengan scope "read" yang bisa mengakses endpoint ini
   });

   Atau dengan menggunakan array untuk multiple scopes

   Route::middleware(['auth:sanctum', 'ability:read,write'])->post('/data', function () {
       // Hanya user dengan scope "read" DAN "write" yang bisa mengakses endpoint ini
   });

Keuntungan Menggunakan Scopes:

• Keamanan: Kamu bisa memberikan akses yang lebih spesifik ke aplikasi third-party, sehingga mengurangi risiko penyalahgunaan.
• Fleksibilitas: Kamu bisa dengan mudah mengubah permission yang dimiliki oleh sebuah token dengan mengubah scopes-nya.
• Control: Kamu memiliki kontrol penuh atas akses API kamu.

8. Refresh Token: Memperpanjang Masa Berlaku Token

Masa berlaku token yang singkat dapat meningkatkan keamanan, namun juga dapat membuat user merasa tidak nyaman karena harus sering login. Refresh token adalah sebuah mekanisme untuk memperpanjang masa berlaku token tanpa perlu meminta user untuk login ulang.

Cara Kerja Refresh Token:

1. Saat login, selain access token, juga diberikan refresh token.
2. Access token memiliki masa berlaku yang singkat (misalnya 1 jam).
3. Jika access token sudah expired, aplikasi frontend dapat menggunakan refresh token untuk meminta access token baru.
4. Refresh token memiliki masa berlaku yang lebih lama (misalnya 30 hari).
5. Jika refresh token sudah expired, user harus login ulang.

Implementasi Refresh Token dengan Laravel Sanctum:

Sayangnya, Laravel Sanctum tidak menyediakan fitur refresh token secara native. Namun, kita bisa mengimplementasikan refresh token secara manual.

Berikut adalah contoh implementasi sederhana:

1. Menambahkan Kolom refresh_token ke Tabel personal_access_tokens:

   Buat migration baru untuk menambahkan kolom refresh_token ke tabel personal_access_tokens:

   php artisan make:migration add_refresh_token_to_personal_access_tokens

   Kemudian, tambahkan kode berikut ke file migration:

   public function up()
   {
       Schema::table('personal_access_tokens', function (Blueprint $table) {
           $table->string('refresh_token')->nullable();
       });
   }
   
   public function down()
   {
       Schema::table('personal_access_tokens', function (Blueprint $table) {
           $table->dropColumn('refresh_token');
       });
   }

   Jalankan migration:

   php artisan migrate

2. Membuat Endpoint untuk Mendapatkan Access Token Baru dengan Refresh Token:

   public function refreshToken(Request $request)
   {
       $request->validate([
           'refresh_token' => 'required|string',
       ]);
   
       $token = PersonalAccessToken::where('refresh_token', $request->refresh_token)->first();
   
       if (!$token) {
           return response()->json([
               'message' => 'Invalid refresh token'
           ], 401);
       }
   
       // Hapus token lama
       $token->delete();
   
       // Buat token baru
       $user = $token->tokenable;
       $newToken = $user->createToken('auth_token')->plainTextToken;
       $newRefreshToken = Str::random(40);
   
       // Simpan refresh token baru
       $newTokenModel = $user->tokens()->where('id', $token->id)->first();
       $newTokenModel->update(['refresh_token' => $newRefreshToken]);
   
       return response()->json([
           'access_token' => $newToken,
           'token_type' => 'Bearer',
           'refresh_token' => $newRefreshToken,
       ]);
   }

3. Menambahkan Route untuk Endpoint refreshToken:

   Route::post('/refresh-token', [AuthController::class, 'refreshToken']);

Catatan:

Implementasi refresh token di atas adalah contoh sederhana. Kamu perlu menyesuaikannya dengan kebutuhan aplikasi kamu. Pastikan untuk mengamankan refresh token dengan baik, karena jika refresh token dicuri, attacker dapat menggunakan refresh token tersebut untuk mendapatkan access token baru.

9. Tips Keamanan Tambahan untuk Laravel Sanctum

Selain menggunakan fitur-fitur yang sudah disediakan oleh Laravel Sanctum, ada beberapa tips keamanan tambahan yang bisa kamu terapkan untuk meningkatkan keamanan API kamu:

• Validasi Input: Selalu validasi semua inputan dari user untuk mencegah serangan injection.
• Rate Limiting: Batasi jumlah request yang bisa dilakukan oleh user dalam jangka waktu tertentu untuk mencegah serangan DDoS. Laravel memiliki fitur rate limiting yang bisa kamu gunakan.
• HTTPS: Gunakan HTTPS untuk semua request API untuk mengenkripsi data yang dikirimkan antara client dan server.
• CORS: Konfigurasi CORS (Cross-Origin Resource Sharing) dengan benar untuk mencegah aplikasi lain mengakses API kamu secara ilegal.
• Regular Security Audits: Lakukan audit keamanan secara berkala untuk mengidentifikasi dan memperbaiki potensi kerentanan keamanan.
• Keep Dependencies Up-to-Date: Pastikan semua dependencies project kamu selalu up-to-date dengan versi terbaru untuk mendapatkan patch keamanan terbaru.

10. Kesimpulan: Otentikasi API yang Aman dan Mudah dengan Laravel Sanctum

Selamat! Kamu telah menyelesaikan tutorial Laravel Sanctum Tutorial Bahasa Indonesia: Otentikasi API Aman dan Mudah ini. Kita sudah membahas berbagai topik, mulai dari instalasi dan konfigurasi, hingga implementasi endpoint login dan logout, pengamanan route dengan middleware, penggunaan token di frontend, penggunaan Personal Access Tokens, implementasi scopes, dan refresh token, serta tips keamanan tambahan.

Laravel Sanctum adalah pilihan yang tepat untuk mengamankan API Laravel kamu dengan cara yang aman dan mudah. Dengan menggunakan Laravel Sanctum, kamu bisa fokus pada pengembangan fitur-fitur aplikasi kamu, tanpa perlu khawatir tentang keamanan API.

Semoga tutorial ini bermanfaat bagi kamu. Selamat mencoba dan semoga sukses!