Eko Sudarmaji
TechTopia Casing SSD NVMe NGFF USB 3.1 Type-C Enclosure Eksternal M.2 SATA & NVMe High Speed

Laravel API: Cara Membuat REST API dari Nol

Laravel merupakan salah satu framework PHP yang populer untuk membangun aplikasi web dan backend. Selain digunakan untuk membuat aplikasi berbasis server-side rendering, Laravel juga dapat digunakan untuk membangun REST API yang melayani komunikasi antara aplikasi web, mobile, maupun layanan lainnya.

Dalam tutorial ini, kita akan membuat REST API Laravel dari nol, mulai dari instalasi project, konfigurasi database, pembuatan model dan migration, pembuatan controller API, routing, validasi request, hingga pengujian endpoint.

Tutorial ini cocok untuk pemula yang ingin memahami cara membuat Laravel REST API dengan struktur yang rapi dan mudah dikembangkan.

Apa Itu REST API?

REST API adalah antarmuka yang memungkinkan aplikasi saling berkomunikasi melalui protokol HTTP.

Dalam REST API, data biasanya direpresentasikan dalam format JSON. Setiap resource memiliki endpoint tertentu dan dapat dimanipulasi menggunakan HTTP method seperti:

  • GET untuk mengambil data.
  • POST untuk membuat data baru.
  • PUT atau PATCH untuk memperbarui data.
  • DELETE untuk menghapus data.

Sebagai contoh, jika kita memiliki resource posts, endpoint API dapat dibuat seperti berikut:

GET    /api/posts
POST   /api/posts
GET    /api/posts/{id}
PUT    /api/posts/{id}
DELETE /api/posts/{id}

Pada tutorial ini, kita akan membuat REST API sederhana untuk mengelola data posts.

Persiapan Sebelum Membuat Laravel API

Pastikan environment pengembangan sudah memiliki beberapa kebutuhan berikut:

  • PHP yang kompatibel dengan versi Laravel yang digunakan.
  • Composer.
  • Database seperti MySQL atau MariaDB.
  • Terminal atau command line.
  • Code editor.

Periksa versi PHP:

php -v

Periksa Composer:

composer -V

Jika kedua perintah tersebut berhasil dijalankan, environment dasar sudah siap digunakan.

Membuat Project Laravel Baru

Buat project Laravel menggunakan Composer:

composer create-project laravel/laravel laravel-api

Masuk ke direktori project:

cd laravel-api

Jalankan development server:

php artisan serve

Secara default, aplikasi dapat diakses melalui:

http://127.0.0.1:8000

Jika halaman Laravel berhasil dibuka, berarti project sudah berhasil dibuat.

Konfigurasi Database Laravel

Laravel menggunakan file .env untuk menyimpan konfigurasi environment seperti database.

Buka file:

.env

Kemudian sesuaikan konfigurasi database.

Contoh menggunakan MySQL:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_api
DB_USERNAME=root
DB_PASSWORD=

Buat database laravel_api terlebih dahulu menggunakan MySQL atau database management tool yang Anda gunakan.

Setelah database dikonfigurasi, jalankan migration bawaan Laravel:

php artisan migrate

Jika tidak muncul error, Laravel sudah berhasil terhubung dengan database.

Membuat Model dan Migration Post

Sekarang kita akan membuat model Post sekaligus migration.

Jalankan:

php artisan make:model Post -m

Perintah tersebut menghasilkan model Post dan file migration untuk tabel posts.

Buka file migration yang berada di:

database/migrations/

Kemudian sesuaikan struktur tabel:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});

Struktur tersebut memiliki tiga field utama:

  • id sebagai primary key.
  • title untuk judul artikel.
  • content untuk isi artikel.
  • created_at dan updated_at dari timestamps().

Jalankan migration:

php artisan migrate

Laravel kemudian membuat tabel posts di database.

Mengatur Model Post

Buka:

app/Models/Post.php

Pada versi Laravel yang menggunakan mass assignment protection melalui $fillable, tambahkan field yang boleh diisi secara mass assignment:

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

Model kemudian menjadi seperti:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = [
        'title',
        'content',
    ];
}

Dengan konfigurasi tersebut, title dan content dapat digunakan ketika membuat data menggunakan Post::create().

Membuat API Controller

Buat controller khusus API:

php artisan make:controller Api/PostController --api

Laravel akan membuat controller di:

app/Http/Controllers/Api/PostController.php

Controller ini nantinya digunakan untuk menangani operasi CRUD.

Membuat Route API

Pada Laravel versi terbaru, route API perlu diaktifkan jika project belum memiliki file routes/api.php.

Gunakan:

php artisan install:api

Perintah tersebut dapat memasang kebutuhan API dan membuat konfigurasi route API pada project.

Setelah tersedia, buka:

routes/api.php

Tambahkan route resource:

<?php

use App\Http\Controllers\Api\PostController;
use Illuminate\Support\Facades\Route;

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

Dengan apiResource(), Laravel membuat route CRUD API tanpa route HTML seperti create dan edit.

Periksa route yang tersedia:

php artisan route:list --path=api

Anda akan mendapatkan endpoint seperti:

GET       /api/posts
POST      /api/posts
GET       /api/posts/{post}
PUT       /api/posts/{post}
PATCH     /api/posts/{post}
DELETE    /api/posts/{post}

Membuat Endpoint GET untuk Semua Post

Buka controller:

app/Http/Controllers/Api/PostController.php

Tambahkan implementasi method index():

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Post;
use Illuminate\Http\JsonResponse;

class PostController extends Controller
{
    public function index(): JsonResponse
    {
        $posts = Post::latest()->get();

        return response()->json([
            'success' => true,
            'data' => $posts,
        ]);
    }
}

Endpoint tersebut dapat diakses melalui:

GET /api/posts

Jika belum ada data, response kurang lebih akan berbentuk:

{
    "success": true,
    "data": []
}

Membuat Endpoint POST

Selanjutnya kita membuat endpoint untuk menambahkan post baru.

Tambahkan method store():

use Illuminate\Http\Request;

Kemudian:

public function store(Request $request): JsonResponse
{
    $validated = $request->validate([
        'title' => ['required', 'string', 'max:255'],
        'content' => ['required', 'string'],
    ]);

    $post = Post::create($validated);

    return response()->json([
        'success' => true,
        'message' => 'Post berhasil dibuat.',
        'data' => $post,
    ], 201);
}

Request JSON yang dikirim ke endpoint:

{
    "title": "Belajar Laravel API",
    "content": "Ini adalah contoh post dari REST API Laravel."
}

Endpoint:

POST /api/posts

Jika berhasil, server akan mengembalikan HTTP status 201 Created.

Validasi Request API

Validasi sangat penting untuk memastikan data yang masuk sesuai dengan kebutuhan aplikasi.

Contoh validasi:

$validated = $request->validate([
    'title' => ['required', 'string', 'max:255'],
    'content' => ['required', 'string'],
]);

Jika title atau content tidak dikirim, Laravel akan menghasilkan response validasi secara otomatis.

Contohnya, request tanpa title dapat menghasilkan response JSON seperti:

{
    "message": "The title field is required.",
    "errors": {
        "title": [
            "The title field is required."
        ]
    }
}

Validasi sebaiknya selalu dilakukan di sisi server meskipun frontend juga melakukan validasi.

Membuat Endpoint GET Berdasarkan ID

Untuk mengambil satu post, implementasikan method show():

public function show(Post $post): JsonResponse
{
    return response()->json([
        'success' => true,
        'data' => $post,
    ]);
}

Endpoint:

GET /api/posts/{id}

Contoh:

GET /api/posts/1

Laravel menggunakan route model binding sehingga parameter {post} dapat langsung diterjemahkan menjadi instance model Post.

Jika data dengan ID tersebut tidak ditemukan, Laravel akan menghasilkan response 404 Not Found.

Membuat Endpoint PUT untuk Update

Tambahkan method update():

public function update(Request $request, Post $post): JsonResponse
{
    $validated = $request->validate([
        'title' => ['sometimes', 'required', 'string', 'max:255'],
        'content' => ['sometimes', 'required', 'string'],
    ]);

    $post->update($validated);

    return response()->json([
        'success' => true,
        'message' => 'Post berhasil diperbarui.',
        'data' => $post->fresh(),
    ]);
}

Request:

PUT /api/posts/1

Dengan body JSON:

{
    "title": "Judul Post yang Diperbarui",
    "content": "Isi post yang telah diperbarui."
}

Membuat Endpoint DELETE

Untuk menghapus data, tambahkan method destroy():

public function destroy(Post $post): JsonResponse
{
    $post->delete();

    return response()->json([
        'success' => true,
        'message' => 'Post berhasil dihapus.',
    ]);
}

Endpoint:

DELETE /api/posts/1

Jika berhasil, API mengembalikan response:

{
    "success": true,
    "message": "Post berhasil dihapus."
}

Controller Lengkap

Setelah semua method dibuat, controller dapat disusun seperti berikut:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Post;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index(): JsonResponse
    {
        $posts = Post::latest()->get();

        return response()->json([
            'success' => true,
            'data' => $posts,
        ]);
    }

    public function store(Request $request): JsonResponse
    {
        $validated = $request->validate([
            'title' => ['required', 'string', 'max:255'],
            'content' => ['required', 'string'],
        ]);

        $post = Post::create($validated);

        return response()->json([
            'success' => true,
            'message' => 'Post berhasil dibuat.',
            'data' => $post,
        ], 201);
    }

    public function show(Post $post): JsonResponse
    {
        return response()->json([
            'success' => true,
            'data' => $post,
        ]);
    }

    public function update(Request $request, Post $post): JsonResponse
    {
        $validated = $request->validate([
            'title' => ['sometimes', 'required', 'string', 'max:255'],
            'content' => ['sometimes', 'required', 'string'],
        ]);

        $post->update($validated);

        return response()->json([
            'success' => true,
            'message' => 'Post berhasil diperbarui.',
            'data' => $post->fresh(),
        ]);
    }

    public function destroy(Post $post): JsonResponse
    {
        $post->delete();

        return response()->json([
            'success' => true,
            'message' => 'Post berhasil dihapus.',
        ]);
    }
}

Menguji Laravel REST API

Setelah API selesai dibuat, Anda dapat mengujinya menggunakan Postman, Insomnia, Bruno, curl, atau HTTP client lainnya.

Untuk mengambil seluruh post menggunakan curl:

curl http://127.0.0.1:8000/api/posts

Untuk membuat post:

curl -X POST http://127.0.0.1:8000/api/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"Belajar Laravel API","content":"Membuat REST API dari Laravel."}'

Untuk mengambil satu post:

curl http://127.0.0.1:8000/api/posts/1

Untuk memperbarui post:

curl -X PUT http://127.0.0.1:8000/api/posts/1 \
  -H "Content-Type: application/json" \
  -d '{"title":"Laravel REST API","content":"Konten telah diperbarui."}'

Untuk menghapus post:

curl -X DELETE http://127.0.0.1:8000/api/posts/1

Struktur API yang Kita Buat

Setelah mengikuti tutorial, struktur sederhananya menjadi:

laravel-api/
├── app/
│   ├── Http/
│   │   └── Controllers/
│   │       └── Api/
│   │           └── PostController.php
│   └── Models/
│       └── Post.php
├── database/
│   └── migrations/
│       └── xxxx_xx_xx_xxxxxx_create_posts_table.php
├── routes/
│   └── api.php
└── .env

Arsitektur tersebut sudah cukup untuk aplikasi API sederhana dan dapat dikembangkan lebih lanjut.

Praktik Terbaik Saat Membuat Laravel API

REST API yang digunakan dalam aplikasi production membutuhkan lebih dari sekadar CRUD. Beberapa praktik yang sebaiknya diterapkan antara lain:

Gunakan API Resource

Untuk API yang lebih terstruktur, gunakan Laravel API Resource agar format response tidak langsung bergantung pada struktur model database.

Buat resource:

php artisan make:resource PostResource

Kemudian resource dapat digunakan untuk menentukan field yang boleh dikirimkan ke client.

Gunakan Form Request untuk Validasi Kompleks

Jika validasi mulai panjang, pisahkan validasi dari controller menggunakan Form Request:

php artisan make:request StorePostRequest

Pendekatan ini membuat controller lebih bersih dan memudahkan pemeliharaan kode.

Gunakan Pagination

Jangan mengembalikan ribuan data sekaligus menggunakan get().

Untuk data yang besar, gunakan pagination:

$posts = Post::latest()->paginate(10);

Dengan pagination, client dapat mengambil data secara bertahap.

Gunakan Authentication

Jika API tidak bersifat publik, endpoint sebaiknya dilindungi autentikasi.

Laravel menyediakan beberapa pendekatan autentikasi API, termasuk Laravel Sanctum yang cocok untuk banyak aplikasi berbasis SPA, mobile, maupun token API sederhana.

Contoh middleware:

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('posts', PostController::class);
});

Pastikan metode autentikasi yang digunakan disesuaikan dengan arsitektur aplikasi.

Gunakan HTTP Status Code yang Tepat

Response API sebaiknya menggunakan status code yang sesuai.

Beberapa status code yang umum:

  • 200 OK untuk request berhasil.
  • 201 Created ketika resource baru berhasil dibuat.
  • 204 No Content ketika operasi berhasil tetapi tidak membutuhkan response body.
  • 400 Bad Request untuk request yang tidak valid secara umum.
  • 401 Unauthorized ketika autentikasi diperlukan atau gagal.
  • 403 Forbidden ketika user tidak memiliki izin.
  • 404 Not Found ketika resource tidak ditemukan.
  • 422 Unprocessable Content untuk kegagalan validasi data.

Penggunaan status code yang konsisten membuat API lebih mudah digunakan oleh frontend dan aplikasi client lainnya.

Keamanan Laravel API

API yang sudah dapat digunakan bukan berarti otomatis aman untuk production.

Beberapa hal yang perlu diperhatikan:

  • Validasi semua input dari client.
  • Jangan mengembalikan data sensitif melalui JSON.
  • Gunakan authentication untuk endpoint privat.
  • Terapkan authorization untuk memastikan user hanya dapat mengakses resource yang diperbolehkan.
  • Gunakan HTTPS pada production.
  • Batasi request dengan rate limiting jika diperlukan.
  • Jangan menyimpan credential atau secret API di source code.
  • Gunakan environment variable untuk konfigurasi sensitif.
  • Perbarui Laravel dan dependency secara berkala.

Jangan menganggap validasi request sebagai pengganti authorization. Validasi memastikan data memiliki format yang benar, sedangkan authorization menentukan apakah user memiliki hak untuk melakukan suatu tindakan.

Kesalahan yang Sering Terjadi

Route API Tidak Ditemukan

Jika /api/posts menghasilkan 404, periksa apakah route sudah terdaftar:

php artisan route:list --path=api

Pastikan routes/api.php berisi route yang benar dan konfigurasi API sudah tersedia.

Database Connection Error

Periksa konfigurasi:

DB_DATABASE
DB_USERNAME
DB_PASSWORD
DB_HOST
DB_PORT

Setelah mengubah .env, bersihkan cache konfigurasi jika diperlukan:

php artisan config:clear

Mass Assignment Error

Jika menggunakan:

Post::create($validated);

pastikan field yang diizinkan sudah ditentukan pada model:

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

API Mengembalikan HTML

API seharusnya mengembalikan JSON. Pastikan request menggunakan header yang sesuai dan endpoint memang diarahkan ke route API.

Contoh header:

Accept: application/json

Untuk request yang memiliki body JSON, gunakan:

Content-Type: application/json

Kesimpulan

Membuat Laravel REST API dari nol dapat dilakukan dengan alur yang cukup sederhana: buat project Laravel, konfigurasi database, buat model dan migration, siapkan API controller, definisikan route, tambahkan validasi, lalu uji endpoint CRUD.

Dengan apiResource(), Laravel membantu mengurangi boilerplate routing untuk operasi CRUD. Setelah API dasar selesai, aplikasi dapat dikembangkan menggunakan API Resource, Form Request, pagination, authentication, authorization, rate limiting, dan berbagai fitur lain sesuai kebutuhan.

REST API yang dirancang dengan struktur endpoint, validasi, response, dan keamanan yang konsisten akan lebih mudah digunakan oleh frontend web, aplikasi mobile, maupun service lain.

FAQ

Apakah Laravel cocok untuk membuat REST API?

Ya. Laravel menyediakan routing API, validation, Eloquent ORM, middleware, authentication, API Resource, dan berbagai komponen lain yang memudahkan pengembangan REST API.

Apa perbedaan apiResource() dan resource()?

apiResource() dirancang untuk API dan tidak membuat route halaman create serta edit. Sementara resource() membuat route resource lengkap yang umumnya digunakan untuk aplikasi web berbasis HTML.

Apakah Laravel API harus menggunakan database MySQL?

Tidak. Laravel mendukung beberapa database, sehingga database dapat dipilih sesuai kebutuhan aplikasi dan environment deployment.

Apakah Laravel API bisa digunakan untuk aplikasi mobile?

Bisa. REST API Laravel dapat menjadi backend untuk aplikasi Android, iOS, maupun aplikasi mobile lintas platform selama client dapat berkomunikasi menggunakan HTTP/HTTPS.

Apakah Laravel API harus menggunakan Sanctum?

Tidak semua API membutuhkan Sanctum. Namun, jika API memiliki endpoint privat yang membutuhkan autentikasi, Sanctum merupakan salah satu opsi yang dapat dipertimbangkan sesuai kebutuhan arsitektur aplikasi.

Artikel Terkait