API (Application Programming Interface) telah menjadi tulang punggung modern dalam pengembangan aplikasi. Kemampuannya untuk menghubungkan berbagai sistem dan aplikasi secara efisien menjadikannya sangat penting. Salah satu framework PHP yang populer, Laravel, menyediakan berbagai tools untuk mempermudah pembuatan API, dan salah satunya adalah Laravel Sanctum. Artikel ini akan membahas secara mendalam cara membuat API sederhana dengan Laravel Sanctum, memungkinkan Anda untuk mengintegrasikan aplikasi dengan mudah dan aman. Kita akan membahas langkah demi langkah, mulai dari instalasi hingga implementasi, memastikan Anda memiliki pemahaman yang komprehensif.

Apa Itu Laravel Sanctum dan Mengapa Penting untuk API Anda?

Laravel Sanctum adalah paket otentikasi ringan yang ideal untuk aplikasi single-page (SPA), aplikasi mobile, dan API sederhana. Alih-alih menggunakan mekanisme otentikasi berbasis token yang kompleks, Sanctum menggunakan cookie dan sesi untuk mengotentikasi pengguna yang mengakses API Anda. Ini membuatnya sangat mudah digunakan, terutama untuk aplikasi yang menggunakan Laravel sebagai backend dan JavaScript framework (seperti Vue.js atau React) sebagai frontend.

Mengapa Sanctum penting untuk API Anda? Berikut beberapa alasannya:

• Sederhana dan Mudah Digunakan: Sanctum menghilangkan kompleksitas yang sering terkait dengan otentikasi API tradisional.
• Keamanan yang Lebih Baik: Menggunakan cookie dan sesi untuk otentikasi mengurangi risiko serangan XSS (Cross-Site Scripting) dibandingkan dengan penyimpanan token di local storage.
• Cocok untuk SPA dan Aplikasi Mobile: Sanctum didesain khusus untuk aplikasi single-page dan mobile, memungkinkan otentikasi yang lancar antara frontend dan backend Laravel.
• Ringan dan Efisien: Sanctum tidak membebani aplikasi Anda dengan logika otentikasi yang rumit.

Persiapan Awal: Instalasi Laravel dan Konfigurasi Dasar

Sebelum memulai cara membuat API sederhana dengan Laravel Sanctum, pastikan Anda memiliki lingkungan pengembangan Laravel yang sudah siap. Jika belum, ikuti langkah-langkah berikut:

Related Post

Contoh Penggunaan Eloquent ORM di Laravel: Cara Mudah Berinteraksi dengan Database

May 1, 2025

Komunitas Laravel Indonesia Online: Bergabung, Belajar, dan Berkolaborasi dengan Developer Lain!

May 1, 2025

Buku Belajar Laravel Bahasa Indonesia PDF Gratis: Tingkatkan Skill Laravel Anda dengan Sumber Terpercaya

April 30, 2025

Tips Optimasi Performa Aplikasi Laravel: Website Cepat, Pengalaman Pengguna Lebih Baik

April 30, 2025

1. Instalasi Laravel: Gunakan Composer untuk membuat proyek Laravel baru. Buka terminal atau command prompt Anda dan jalankan perintah berikut:

   composer create-project laravel/laravel nama-proyek

   Ganti nama-proyek dengan nama proyek yang Anda inginkan.

2. Konfigurasi Database: Buat database baru dan konfigurasi koneksi database di file .env proyek Laravel Anda. Pastikan untuk mengatur parameter seperti DB_CONNECTION, DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, dan DB_PASSWORD sesuai dengan konfigurasi database Anda.

3. Jalankan Migrasi: Jalankan perintah berikut untuk membuat tabel-tabel yang diperlukan oleh Laravel, termasuk tabel users (jika belum ada):

   php artisan migrate

4. Instal Laravel Sanctum: Instal Sanctum menggunakan Composer:

   composer require laravel/sanctum

5. Publikasikan Konfigurasi dan Migrasi Sanctum: Publikasikan file konfigurasi dan migrasi Sanctum:

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

6. Jalankan Migrasi Sanctum: Jalankan migrasi Sanctum untuk membuat tabel yang diperlukan:

   php artisan migrate

7. Konfigurasi Middleware Sanctum: Tambahkan middleware Sanctum ke kernel HTTP Anda. Buka file app/Http/Kernel.php dan tambahkan LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class ke $middlewareGroups['api']:

   protected $middlewareGroups = [
       'api' => [
           AppHttpMiddlewareEncryptCookies::class,
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
           IlluminateSessionMiddlewareStartSession::class,
           IlluminateViewMiddlewareShareErrorsFromSession::class,
           AppHttpMiddlewareVerifyCsrfToken::class, // Remove or comment this line
           IlluminateRoutingMiddlewareSubstituteBindings::class,
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Add this line
       ],
       // ...
   ];

   Penting: Hapus atau komentari middleware AppHttpMiddlewareVerifyCsrfToken::class dari grup api karena Sanctum menangani proteksi CSRF dengan caranya sendiri.

Dengan langkah-langkah ini, Anda telah berhasil menyiapkan Laravel dan menginstal Laravel Sanctum, siap untuk membuat API sederhana.

Membuat Model, Migrasi, dan Controller untuk API Resource

Setelah konfigurasi dasar selesai, langkah selanjutnya adalah membuat model, migrasi, dan controller untuk resource yang akan Anda expose melalui API. Misalnya, kita akan membuat API untuk mengelola daftar “Todos”.

1. Membuat Model dan Migrasi: Gunakan Artisan untuk membuat model dan migrasi Todo:

   php artisan make:model Todo -m

   Ini akan membuat file app/Models/Todo.php dan file migrasi yang sesuai di folder database/migrations.

2. Modifikasi Migrasi: Buka file migrasi yang baru dibuat (yang ada di folder database/migrations) dan tambahkan kolom-kolom yang Anda butuhkan untuk tabel todos. Contohnya:

   use IlluminateDatabaseMigrationsMigration;
   use IlluminateDatabaseSchemaBlueprint;
   use IlluminateSupportFacadesSchema;
   
   return new class extends Migration
   {
       /**
        * Run the migrations.
        */
       public function up(): void
       {
           Schema::create('todos', function (Blueprint $table) {
               $table->id();
               $table->string('title');
               $table->text('description')->nullable();
               $table->boolean('completed')->default(false);
               $table->timestamps();
           });
       }
   
       /**
        * Reverse the migrations.
        */
       public function down(): void
       {
           Schema::dropIfExists('todos');
       }
   };

3. Jalankan Migrasi: Setelah memodifikasi migrasi, jalankan perintah migrate untuk membuat tabel todos:

   php artisan migrate

4. Membuat Controller: Gunakan Artisan untuk membuat controller untuk Todo:

   php artisan make:controller TodoController --api

   Ini akan membuat file app/Http/Controllers/TodoController.php dengan method-method dasar untuk operasi CRUD (Create, Read, Update, Delete). Opsi --api akan membuat controller yang sudah dioptimalkan untuk API.

Implementasi CRUD API dengan Laravel Sanctum

Sekarang, kita akan mengimplementasikan operasi CRUD di dalam TodoController dan mengamankannya dengan Laravel Sanctum.

1. Implementasi Method di Controller: Buka file app/Http/Controllers/TodoController.php dan implementasikan method-method berikut:

   <?php
   
   namespace AppHttpControllers;
   
   use AppModelsTodo;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesAuth;
   
   class TodoController extends Controller
   {
       /**
        * Display a listing of the resource.
        */
       public function index()
       {
           // Dapatkan semua Todo milik user yang sedang login
           $todos = Todo::where('user_id', Auth::id())->get();
           return response()->json($todos);
       }
   
       /**
        * Store a newly created resource in storage.
        */
       public function store(Request $request)
       {
           $request->validate([
               'title' => 'required|string|max:255',
               'description' => 'nullable|string',
           ]);
   
           $todo = new Todo([
               'title' => $request->title,
               'description' => $request->description,
               'user_id' => Auth::id(), // Set user_id
           ]);
           $todo->save();
   
           return response()->json($todo, 201); // 201 Created
       }
   
       /**
        * Display the specified resource.
        */
       public function show(Todo $todo)
       {
           // Pastikan Todo ini milik user yang sedang login
           if ($todo->user_id !== Auth::id()) {
               return response()->json(['message' => 'Unauthorized'], 403);
           }
   
           return response()->json($todo);
       }
   
       /**
        * Update the specified resource in storage.
        */
       public function update(Request $request, Todo $todo)
       {
           $request->validate([
               'title' => 'required|string|max:255',
               'description' => 'nullable|string',
               'completed' => 'boolean',
           ]);
   
           // Pastikan Todo ini milik user yang sedang login
           if ($todo->user_id !== Auth::id()) {
               return response()->json(['message' => 'Unauthorized'], 403);
           }
   
           $todo->update($request->all());
           return response()->json($todo);
       }
   
       /**
        * Remove the specified resource from storage.
        */
       public function destroy(Todo $todo)
       {
           // Pastikan Todo ini milik user yang sedang login
           if ($todo->user_id !== Auth::id()) {
               return response()->json(['message' => 'Unauthorized'], 403);
           }
   
           $todo->delete();
           return response()->json(['message' => 'Todo deleted']);
       }
   }

   Penting: Perhatikan bahwa kita menambahkan user_id saat membuat dan memperbarui Todo, dan kita juga memeriksa user_id sebelum menampilkan, memperbarui, dan menghapus Todo untuk memastikan bahwa user hanya dapat mengakses Todo milik mereka sendiri. Ini penting untuk keamanan. Kita juga menggunakan Auth::id() untuk mendapatkan ID user yang sedang login.

2. Konfigurasi Routes API: Buka file routes/api.php dan definisikan routes untuk API Todo:

   <?php
   
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesRoute;
   use AppHttpControllersTodoController;
   
   /*
   |--------------------------------------------------------------------------
   | 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::middleware('auth:sanctum')->get('/user', function (Request $request) {
       return $request->user();
   });
   
   Route::middleware('auth:sanctum')->apiResource('todos', TodoController::class);

   Route::middleware('auth:sanctum') memastikan bahwa semua routes di dalam group ini dilindungi oleh otentikasi Sanctum. Hanya user yang sudah login dan memiliki token Sanctum yang valid yang dapat mengakses routes ini. apiResource secara otomatis membuat routes untuk semua operasi CRUD (index, store, show, update, destroy) di TodoController.

Otentikasi Pengguna dengan Laravel Sanctum

Sebelum API kita dapat digunakan, kita perlu mengimplementasikan proses otentikasi user. Laravel Sanctum menyediakan cara mudah untuk melakukan ini.

1. Membuat Routes untuk Register dan Login: Tambahkan routes untuk register dan login di file routes/api.php:

   use AppHttpControllersAuthController; // Asumsikan Anda membuat AuthController
   
   Route::post('/register', [AuthController::class, 'register']);
   Route::post('/login', [AuthController::class, 'login']);

2. Membuat AuthController: Buat controller baru bernama AuthController:

   php artisan make:controller AuthController

3. Implementasi Method Register dan Login: Buka file app/Http/Controllers/AuthController.php dan implementasikan method register dan login:

   <?php
   
   namespace AppHttpControllers;
   
   use AppModelsUser;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesHash;
   use IlluminateSupportFacadesAuth;
   
   class AuthController extends Controller
   {
       public function register(Request $request)
       {
           $request->validate([
               'name' => 'required|string|max:255',
               'email' => 'required|string|email|max:255|unique:users',
               'password' => 'required|string|min:8|confirmed',
           ]);
   
           $user = User::create([
               'name' => $request->name,
               'email' => $request->email,
               'password' => Hash::make($request->password),
           ]);
   
           $token = $user->createToken('auth_token')->plainTextToken;
   
           return response()->json([
               'access_token' => $token,
               'token_type' => 'Bearer',
           ]);
       }
   
       public function login(Request $request)
       {
           $request->validate([
               'email' => 'required|string|email',
               'password' => 'required|string',
           ]);
   
           $credentials = $request->only('email', 'password');
   
           if (!Auth::attempt($credentials)) {
               return response()->json([
                   'message' => 'Invalid login credentials'
               ], 401);
           }
   
           $user = User::where('email', $request->email)->firstOrFail();
   
           $token = $user->createToken('auth_token')->plainTextToken;
   
           return response()->json([
               'access_token' => $token,
               'token_type' => 'Bearer',
           ]);
       }
   }

   Dalam method register, kita membuat user baru dan menghasilkan token Sanctum. Dalam method login, kita mengautentikasi user dan menghasilkan token Sanctum jika autentikasi berhasil. Token ini kemudian dikembalikan ke client.

Menguji API dengan Postman atau Insomnia

Setelah API selesai dibuat, langkah selanjutnya adalah mengujinya. Anda dapat menggunakan tools seperti Postman atau Insomnia untuk mengirimkan request ke API dan melihat response-nya.

1. Register User: Kirim request POST ke /api/register dengan data yang diperlukan (name, email, password, password_confirmation). Anda akan menerima token Sanctum dalam response.
2. Login User: Kirim request POST ke /api/login dengan data yang diperlukan (email, password). Anda akan menerima token Sanctum dalam response.
3. Mengakses API Terproteksi: Untuk mengakses API yang terproteksi (seperti /api/todos), tambahkan header Authorization ke request Anda dengan nilai Bearer <token>, di mana <token> adalah token Sanctum yang Anda terima saat login.

Dengan langkah-langkah ini, Anda dapat menguji semua operasi CRUD pada API Todo Anda.

Integrasi dengan Aplikasi Frontend

Langkah terakhir adalah mengintegrasikan API dengan aplikasi frontend Anda. Proses integrasi ini akan bergantung pada framework JavaScript yang Anda gunakan (Vue.js, React, Angular, dll.). Secara umum, Anda perlu melakukan hal berikut:

1. Simpan Token Sanctum: Setelah user berhasil login, simpan token Sanctum yang diterima dari API. Anda dapat menyimpannya di local storage, cookie, atau state management library seperti Vuex atau Redux.
2. Tambahkan Token ke Setiap Request API: Setiap kali Anda membuat request ke API, tambahkan header Authorization dengan nilai Bearer <token>, di mana <token> adalah token Sanctum yang Anda simpan.
3. Handle Response Error: Tangani response error dari API, terutama error 401 (Unauthorized), yang menunjukkan bahwa token Sanctum sudah tidak valid atau user tidak memiliki akses. Jika terjadi error 401, arahkan user kembali ke halaman login.

Kesimpulan dan Langkah Selanjutnya

Dalam artikel ini, kita telah membahas cara membuat API sederhana dengan Laravel Sanctum secara detail. Kita telah membahas instalasi, konfigurasi, pembuatan model dan controller, implementasi CRUD, otentikasi user, dan pengujian API. Dengan pengetahuan ini, Anda sekarang dapat mengintegrasikan aplikasi Anda dengan mudah menggunakan API yang aman dan efisien.

Langkah selanjutnya adalah menjelajahi fitur-fitur lanjutan dari Laravel Sanctum, seperti:

• Multiple Token: Memungkinkan user untuk memiliki beberapa token Sanctum untuk perangkat yang berbeda.
• Token Expiration: Mengatur masa berlaku token Sanctum untuk meningkatkan keamanan.
• Scopes: Membatasi akses ke API berdasarkan peran dan izin user.

Dengan memanfaatkan fitur-fitur ini, Anda dapat membuat API yang lebih canggih dan aman dengan Laravel Sanctum. Selamat mencoba!