Oke, berikut adalah artikel SEO berbahasa Indonesia dengan fokus pada keyword “Cara Membuat API dengan Laravel Sanctum: Panduan Lengkap & Contoh Kode” yang memenuhi semua kriteria yang kamu sebutkan:

API (Application Programming Interface) telah menjadi tulang punggung pengembangan web modern. Dengan API, aplikasi yang berbeda dapat berkomunikasi dan bertukar data secara efisien. Jika Anda menggunakan Laravel, framework PHP yang populer, dan mencari cara aman dan mudah untuk membuat API, Laravel Sanctum adalah jawabannya. Artikel ini adalah panduan lengkap tentang cara membuat API dengan Laravel Sanctum, lengkap dengan contoh kode praktis. Mari kita mulai!

Apa Itu Laravel Sanctum dan Mengapa Menggunakannya untuk API?

Sebelum kita masuk ke implementasi, mari kita pahami dulu apa itu Laravel Sanctum dan mengapa ia menjadi pilihan populer untuk otentikasi API. Laravel Sanctum, sebelumnya dikenal sebagai Laravel Airlock, adalah paket otentikasi ringan yang sempurna untuk API sederhana. Sanctum menggunakan token API untuk otentikasi, memungkinkan pengguna (atau aplikasi) untuk melakukan permintaan yang diautentikasi ke API Anda.

Keuntungan menggunakan Laravel Sanctum:

• Ringan dan Mudah Digunakan: Konfigurasi sederhana dan mudah diintegrasikan ke dalam proyek Laravel Anda.
• Otentikasi Berbasis Token: Menggunakan token API untuk otentikasi, yang aman dan fleksibel.
• Otentikasi SPA (Single Page Application): Mendukung otentikasi untuk aplikasi SPA yang menggunakan JavaScript seperti React, Vue.js, atau Angular.
• Otentikasi Mobile: Mendukung otentikasi untuk aplikasi mobile melalui token.
• Otentikasi First-Party: Dirancang untuk otentikasi “first-party” yang berarti aplikasi yang mengakses API berada di bawah kendali Anda (misalnya, website Anda sendiri atau aplikasi mobile Anda).
• Keamanan: Menangani proses otentikasi dengan aman dan mencegah serangan umum seperti CSRF (Cross-Site Request Forgery).

Singkatnya, jika Anda membutuhkan solusi otentikasi API yang cepat, aman, dan mudah diimplementasikan dalam aplikasi Laravel Anda, Laravel Sanctum adalah pilihan yang sangat baik. Namun, perlu diingat bahwa Sanctum lebih cocok untuk API yang digunakan oleh aplikasi yang Anda kendalikan. Untuk API publik yang digunakan oleh pihak ketiga, pertimbangkan menggunakan OAuth 2.0 seperti Laravel Passport.

Persiapan Awal: Instalasi dan Konfigurasi Laravel Sanctum

Sebelum memulai dengan cara membuat API dengan Laravel Sanctum, pastikan Anda memiliki aplikasi Laravel yang sudah berjalan. Jika belum, instal Laravel terlebih dahulu.

Setelah itu, ikuti langkah-langkah berikut untuk menginstal dan mengkonfigurasi Laravel Sanctum:

1. Instal Paket Sanctum:

   Buka terminal dan jalankan perintah Composer berikut di direktori proyek Laravel Anda:

   composer require laravel/sanctum

2. Publikasikan Konfigurasi dan Migrasi:

   Setelah instalasi selesai, publikasikan file konfigurasi dan migrasi Sanctum dengan perintah Artisan:

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

   Perintah ini akan menyalin file konfigurasi Sanctum ke config/sanctum.php dan file migrasi ke database/migrations.

3. Jalankan Migrasi Database:

   Selanjutnya, jalankan migrasi database untuk membuat tabel yang dibutuhkan oleh Sanctum:

   php artisan migrate

   Migrasi ini akan membuat tabel personal_access_tokens yang digunakan untuk menyimpan token API.

4. Konfigurasi Model User:

   Pastikan model User Anda menggunakan trait HasApiTokens dari Sanctum. Buka file app/Models/User.php dan tambahkan use LaravelSanctumHasApiTokens; ke class User:

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

5. Konfigurasi Middleware (Optional):

   Jika Anda menggunakan SPA atau aplikasi mobile yang berada di domain yang berbeda dengan API Anda, Anda perlu menambahkan middleware EnsureFrontendRequestsAreStateful ke file app/Http/Kernel.php. Middleware ini memastikan bahwa Sanctum dapat menggunakan cookie session dengan aman. Temukan array $middlewareGroups dan tambahkan baris berikut ke grup api:

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

   Penting: Middleware EnsureFrontendRequestsAreStateful hanya boleh digunakan untuk aplikasi first-party yang Anda kendalikan. Jangan gunakan middleware ini untuk API publik.

Setelah menyelesaikan langkah-langkah di atas, Anda telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum. Sekarang, kita bisa lanjut ke bagian cara membuat API dengan Laravel Sanctum yang sebenarnya.

Membuat API Endpoint: Contoh Sederhana Mendapatkan Profil Pengguna

Sekarang kita akan membuat contoh sederhana API endpoint untuk mendapatkan profil pengguna yang sudah diautentikasi.

1. Buat Route API:

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

   <?php
   
   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::middleware('auth:sanctum')->get('/user', function (Request $request) {
       return $request->user();
   });

   Perhatikan middleware auth:sanctum. Middleware ini memastikan bahwa hanya pengguna yang sudah diautentikasi yang dapat mengakses route ini.

2. Pastikan Otentikasi Berfungsi (Register & Login):

   Jika Anda belum memiliki fitur register dan login, Anda perlu membuatnya terlebih dahulu. Anda bisa menggunakan Laravel Breeze atau Jetstream untuk mempercepat proses ini. Pastikan pengguna dapat mendaftar dan login ke aplikasi Anda.

Cara Mendapatkan Token API dengan Laravel Sanctum: Register dan Login

Bagian ini akan menjelaskan cara mendapatkan token API dengan Laravel Sanctum setelah pengguna berhasil register atau login. Kita akan memodifikasi controller register dan login untuk menghasilkan token API.

1. Modifikasi Controller Register:

   Asumsikan Anda memiliki controller RegisterController (atau yang sejenisnya) yang menangani proses register pengguna. Modifikasi controller tersebut untuk menghasilkan token API setelah pengguna berhasil mendaftar. Berikut contohnya:

   <?php
   
   namespace AppHttpControllersAuth;
   
   use AppHttpControllersController;
   use AppModelsUser;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesHash;
   use IlluminateSupportFacadesValidator;
   
   class RegisterController 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|confirmed',
           ]);
   
           if ($validator->fails()) {
               return response()->json(['errors' => $validator->errors()], 422);
           }
   
           $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',
           ]);
       }
   }

   Penjelasan:

   • Setelah pengguna berhasil dibuat, kita menggunakan $user->createToken('auth_token') untuk menghasilkan token API. 'auth_token' adalah nama token yang bisa Anda ganti sesuai kebutuhan.
   • ->plainTextToken mengembalikan token dalam bentuk plain text yang akan dikirimkan ke pengguna. Penting: Token ini hanya ditampilkan sekali, jadi pastikan pengguna menyimpannya dengan aman.
   • Kita mengembalikan token API dalam format JSON bersama dengan tipe token (Bearer).

2. Modifikasi Controller Login:

   Sama seperti controller register, modifikasi controller login Anda untuk menghasilkan token API setelah pengguna berhasil login. Berikut contohnya:

   <?php
   
   namespace AppHttpControllersAuth;
   
   use AppHttpControllersController;
   use IlluminateHttpRequest;
   use IlluminateSupportFacadesAuth;
   
   class LoginController extends Controller
   {
       public function login(Request $request)
       {
           $credentials = $request->validate([
               'email' => 'required|string|email',
               'password' => 'required|string',
           ]);
   
           if (!Auth::attempt($credentials)) {
               return response()->json(['message' => 'Invalid credentials'], 401);
           }
   
           $user = Auth::user();
           $token = $user->createToken('auth_token')->plainTextToken;
   
           return response()->json([
               'access_token' => $token,
               'token_type' => 'Bearer',
           ]);
       }
   }

   Penjelasan:

   • Setelah pengguna berhasil login (autentikasi berhasil), kita menghasilkan token API menggunakan $user->createToken('auth_token')->plainTextToken.
   • Kita mengembalikan token API dalam format JSON.

3. Buat Route untuk Register dan Login:

   Buka routes/api.php dan tambahkan route untuk register dan login:

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

Menguji API dengan Token: Menggunakan Postman atau Tools Serupa

Setelah Anda mendapatkan token API, Anda perlu mengujinya untuk memastikan API endpoint Anda berfungsi dengan benar. Anda bisa menggunakan Postman, Insomnia, atau tools API client lainnya.

1. Dapatkan Token API:

   Lakukan register atau login melalui API endpoint yang sudah Anda buat (/api/register atau /api/login). Simpan token API yang dikembalikan.

2. Konfigurasi Postman:

   • Buka Postman (atau tools API client pilihan Anda).
   • Buat request GET ke endpoint /api/user.
   • Pada tab “Authorization”, pilih type “Bearer Token”.
   • Masukkan token API yang sudah Anda dapatkan ke field “Token”.

3. Kirim Request:

   Kirim request. Jika konfigurasi Anda benar, Anda akan mendapatkan response JSON yang berisi data user yang sudah diautentikasi.

Mengamankan API dengan Sanctum: Best Practices Tambahan

Selain menggunakan middleware auth:sanctum, berikut beberapa best practices tambahan untuk mengamankan API Anda:

• Rate Limiting: Gunakan middleware throttle:api untuk membatasi jumlah request yang dapat dilakukan oleh setiap pengguna dalam jangka waktu tertentu. Ini membantu mencegah serangan brute-force dan DDoS.
• Validasi Input: Selalu validasi semua input yang diterima oleh API Anda untuk mencegah serangan injeksi (SQL injection, XSS).
• HTTPS: Pastikan API Anda hanya dapat diakses melalui HTTPS untuk mengenkripsi data yang dikirimkan antara client dan server.
• Token Expiration: Secara default, token Sanctum tidak memiliki masa berlaku. Anda bisa mengimplementasikan logika untuk mencabut token setelah jangka waktu tertentu atau ketika pengguna logout. Anda bisa menggunakan delete() pada model PersonalAccessToken untuk mencabut token.
• Scopes (Abilities): Anda dapat mendefinisikan “abilities” (scopes) untuk token API, yang memberikan kontrol lebih rinci atas apa yang dapat dilakukan oleh token tersebut. Misalnya, satu token mungkin hanya memiliki izin untuk membaca data, sementara token lain memiliki izin untuk membaca dan menulis data. Lihat dokumentasi Laravel Sanctum untuk informasi lebih lanjut tentang abilities.

Contoh Kode Lengkap: Membuat CRUD API Sederhana dengan Sanctum

Berikut adalah contoh kode lengkap untuk membuat CRUD API sederhana untuk mengelola posts menggunakan Laravel Sanctum:

1. Model Post:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Post extends Model
{
    use HasFactory;

    protected $fillable = [
        'title',
        'content',
        'user_id',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

2. Controller PostController:

<?php

namespace AppHttpControllersApi;

use AppHttpControllersController;
use AppModelsPost;
use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;
use IlluminateSupportFacadesValidator;

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::with('user')->get();
        return response()->json($posts);
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|string|max:255',
            'content' => 'required|string',
        ]);

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

        $post = Post::create([
            'title' => $request->title,
            'content' => $request->content,
            'user_id' => Auth::id(),
        ]);

        return response()->json($post, 201);
    }

    public function show(Post $post)
    {
        return response()->json($post->load('user'));
    }

    public function update(Request $request, Post $post)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|string|max:255',
            'content' => 'required|string',
        ]);

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

        if ($post->user_id !== Auth::id()) {
            return response()->json(['message' => 'Unauthorized'], 403);
        }

        $post->update([
            'title' => $request->title,
            'content' => $request->content,
        ]);

        return response()->json($post);
    }

    public function destroy(Post $post)
    {
        if ($post->user_id !== Auth::id()) {
            return response()->json(['message' => 'Unauthorized'], 403);
        }

        $post->delete();

        return response()->json(['message' => 'Post deleted']);
    }
}

3. Route API (routes/api.php):

<?php

use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
use AppHttpControllersApiPostController;

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

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

    Route::apiResource('posts', PostController::class);
});

Penjelasan:

• Kita menggunakan Route::apiResource untuk membuat route CRUD (Create, Read, Update, Delete) untuk resource posts.
• Semua route di dalam Route::middleware('auth:sanctum')->group(function () { ... }); dilindungi oleh middleware auth:sanctum, sehingga hanya pengguna yang sudah diautentikasi yang dapat mengaksesnya.
• Pada method update dan destroy di PostController, kita melakukan pengecekan apakah user yang mencoba mengedit atau menghapus post adalah pemilik post tersebut. Ini untuk memastikan bahwa user hanya dapat mengelola post miliknya sendiri.

Kesimpulan: Laravel Sanctum untuk API Otentikasi yang Mudah dan Aman

Dalam panduan ini, kita telah membahas secara mendalam cara membuat API dengan Laravel Sanctum. Mulai dari instalasi dan konfigurasi, mendapatkan token API, hingga contoh kode lengkap CRUD API sederhana. Laravel Sanctum adalah solusi yang sangat baik untuk otentikasi API yang mudah, aman, dan ringan, terutama untuk aplikasi first-party. Dengan mengikuti panduan ini dan best practices yang disebutkan, Anda dapat dengan cepat membangun API yang aman dan andal untuk aplikasi Laravel Anda. Selamat mencoba!