Cara Membuat REST API dengan PHP dan Node.js: Panduan Lengkap

Apa Itu REST API dan Mengapa Penting?

REST API (Representational State Transfer Application Programming Interface) adalah standar arsitektur komunikasi antar sistem berbasis web yang paling banyak digunakan saat ini. Hampir setiap aplikasi modern - dari aplikasi mobile, website, hingga perangkat IoT - berkomunikasi melalui REST API.

Dengan memahami cara membuat REST API, Anda membuka pintu untuk membangun backend yang dapat dikonsumsi oleh berbagai platform sekaligus: website React/Vue, aplikasi Android/iOS, dan layanan pihak ketiga - semuanya menggunakan satu sumber data yang sama.

Dalam panduan ini, kita akan mempelajari cara membuat REST API menggunakan dua stack paling populer di Indonesia: PHP dengan Laravel dan Node.js dengan Express. Anda bisa memilih salah satu atau mempelajari keduanya sebagai referensi.

Prinsip Dasar REST API

Sebelum menulis kode, pahami dulu prinsip-prinsip REST yang menjadi landasan desain API yang baik:

HTTP Methods (Verb)

Konvensi Penamaan Endpoint

Gunakan kata benda (noun) bukan kata kerja, dan gunakan huruf kecil dengan tanda hubung:

• GET /api/products - ambil semua produk
• GET /api/products/42 - ambil produk dengan ID 42
• POST /api/products - buat produk baru
• PUT /api/products/42 - update produk ID 42
• DELETE /api/products/42 - hapus produk ID 42

HTTP Status Code yang Penting

• 200 OK - request berhasil
• 201 Created - data baru berhasil dibuat
• 204 No Content - berhasil, tidak ada data dikembalikan (biasanya DELETE)
• 400 Bad Request - input dari client tidak valid
• 401 Unauthorized - belum autentikasi
• 403 Forbidden - sudah autentikasi tapi tidak punya izin
• 404 Not Found - resource tidak ditemukan
• 500 Internal Server Error - kesalahan di sisi server

Cara Membuat REST API dengan PHP (Laravel)

Laravel adalah framework PHP paling populer di Indonesia. Fitur bawaan seperti Eloquent ORM, validasi, dan Laravel Sanctum/Passport menjadikannya pilihan ideal untuk membangun REST API yang robust.

Langkah 1: Instalasi Laravel

Pastikan sudah terinstall PHP 8.1+, Composer, dan MySQL/PostgreSQL. Jalankan perintah berikut:

# Buat proyek Laravel baru
composer create-project laravel/laravel toko-api
cd toko-api

# Konfigurasi database di file .env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=toko_db
DB_USERNAME=root
DB_PASSWORD=your_password

Langkah 2: Membuat Model dan Migration

# Buat model Product sekaligus migration dan controller API
php artisan make:model Product -mcr --api

Edit file migration yang baru dibuat di database/migrations/:

// create_products_table migration
public function up(): void
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description')->nullable();
        $table->decimal('price', 10, 2);
        $table->integer('stock')->default(0);
        $table->string('category');
        $table->timestamps();
    });
}

php artisan migrate

Langkah 3: Menulis Controller API

// app/Http/Controllers/ProductController.php
namespace AppHttpControllers;

use AppModelsProduct;
use IlluminateHttpRequest;
use IlluminateHttpJsonResponse;

class ProductController extends Controller
{
    public function index(): JsonResponse
    {
        $products = Product::paginate(15);
        return response()->json([
            'success' => true,
            'data'    => $products,
        ]);
    }

    public function store(Request $request): JsonResponse
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'required|numeric|min:0',
            'stock'       => 'required|integer|min:0',
            'category'    => 'required|string|max:100',
        ]);

        $product = Product::create($validated);

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

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

    public function update(Request $request, Product $product): JsonResponse
    {
        $validated = $request->validate([
            'name'        => 'sometimes|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'sometimes|numeric|min:0',
            'stock'       => 'sometimes|integer|min:0',
            'category'    => 'sometimes|string|max:100',
        ]);

        $product->update($validated);

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

    public function destroy(Product $product): JsonResponse
    {
        $product->delete();
        return response()->json(['success' => true], 204);
    }
}

Langkah 4: Mendaftarkan Route API

// routes/api.php
use AppHttpControllersProductController;

Route::apiResource('products', ProductController::class);

Cek semua route yang terdaftar dengan perintah:

php artisan route:list

Langkah 5: Autentikasi dengan Laravel Sanctum

# Install Sanctum
composer require laravel/sanctum
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"
php artisan migrate

Tambahkan middleware Sanctum pada route yang perlu dilindungi:

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('products', ProductController::class)
         ->except(['index', 'show']);
});

Cara Membuat REST API dengan Node.js (Express)

Node.js dengan Express adalah pilihan populer lainnya, terutama bagi developer yang sudah terbiasa dengan JavaScript. Ekosistemnya sangat besar dan proses developmentnya terasa cepat.

Langkah 1: Inisialisasi Proyek Node.js

mkdir toko-api-node && cd toko-api-node
npm init -y

# Install dependensi utama
npm install express cors dotenv express-validator jsonwebtoken bcryptjs

# Install dependensi database (Prisma ORM)
npm install prisma @prisma/client
npx prisma init

Langkah 2: Definisikan Schema Database (Prisma)

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model Product {
  id          Int      @id @default(autoincrement())
  name        String
  description String?
  price       Float
  stock       Int      @default(0)
  category    String
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt
}

npx prisma migrate dev --name init

Langkah 3: Struktur Proyek

toko-api-node/
├── src/
│   ├── routes/
│   │   └── productRoutes.js
│   ├── controllers/
│   │   └── productController.js
│   ├── middleware/
│   │   └── authMiddleware.js
│   └── app.js
├── prisma/
│   └── schema.prisma
├── .env
└── package.json

Langkah 4: Membuat Controller dan Route

// src/controllers/productController.js
const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();

exports.getAllProducts = async (req, res) => {
  try {
    const { page = 1, limit = 15 } = req.query;
    const skip = (page - 1) * limit;

    const [products, total] = await Promise.all([
      prisma.product.findMany({ skip: Number(skip), take: Number(limit) }),
      prisma.product.count(),
    ]);

    res.json({ success: true, data: products, total, page: Number(page) });
  } catch (error) {
    res.status(500).json({ success: false, message: 'Server error' });
  }
};

exports.createProduct = async (req, res) => {
  try {
    const { name, description, price, stock, category } = req.body;
    const product = await prisma.product.create({
      data: { name, description, price: parseFloat(price), stock: parseInt(stock), category },
    });
    res.status(201).json({ success: true, data: product });
  } catch (error) {
    res.status(500).json({ success: false, message: 'Server error' });
  }
};

// src/routes/productRoutes.js
const express = require('express');
const router = express.Router();
const { getAllProducts, createProduct } = require('../controllers/productController');
const { authenticate } = require('../middleware/authMiddleware');

router.get('/', getAllProducts);
router.post('/', authenticate, createProduct);

module.exports = router;

// src/app.js
const express = require('express');
const cors = require('cors');
require('dotenv').config();

const app = express();
app.use(cors());
app.use(express.json());

app.use('/api/products', require('./routes/productRoutes'));

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`API berjalan di port ${PORT}`));

Autentikasi JWT untuk REST API

JWT (JSON Web Token) adalah standar autentikasi stateless yang banyak digunakan di REST API modern. Berikut implementasi dasarnya di Node.js:

// middleware/authMiddleware.js
const jwt = require('jsonwebtoken');

exports.authenticate = (req, res, next) => {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ success: false, message: 'Token tidak ditemukan' });
  }

  const token = authHeader.split(' ')[1];

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ success: false, message: 'Token tidak valid' });
  }
};

Praktik Terbaik Membuat REST API

• Versioning API - gunakan prefix /api/v1/ agar mudah melakukan breaking change di masa depan
• Validasi input selalu - jangan pernah percaya data dari client tanpa validasi
• Gunakan HTTPS - enkripsi semua komunikasi di production
• Rate limiting - batasi jumlah request per IP untuk mencegah abuse
• Dokumentasi API - gunakan Swagger/OpenAPI agar tim frontend mudah mengintegrasikan
• Format respons konsisten - selalu kembalikan format JSON yang seragam
• Handle error dengan baik - berikan pesan error yang informatif namun tidak membocorkan detail sistem

Deploy REST API ke Hosting Indonesia

Setelah API selesai dikembangkan, saatnya deploy ke server agar bisa diakses publik. Untuk Laravel, Anda bisa menggunakan shared hosting dengan PHP 8.1+ dan mengunggah file via cPanel. Untuk Node.js, VPS adalah pilihan yang lebih tepat.

1. Pilih hosting atau VPS dengan spesifikasi memadai (minimal 1 GB RAM untuk Node.js)
2. Clone repository ke server via SSH atau upload via Git
3. Jalankan npm install --production atau composer install --no-dev
4. Set environment variable di server (jangan hardcode di kode)
5. Gunakan PM2 (Node.js) atau Supervisor (PHP) untuk menjaga proses tetap berjalan
6. Konfigurasi Nginx sebagai reverse proxy
7. Pasang SSL certificate gratis via Let's Encrypt

FAQ: Cara Membuat REST API

Kesimpulan

Membuat REST API dengan PHP (Laravel) maupun Node.js (Express) tidak serumit yang dibayangkan. Dengan mengikuti konvensi REST, menerapkan validasi input, mengamankan endpoint dengan autentikasi JWT, dan mendokumentasikan API dengan baik, Anda sudah berada di jalur yang benar.

Langkah berikutnya setelah API selesai adalah memilih layanan hosting yang tepat. Untuk Laravel, shared hosting Indonesia dengan dukungan PHP 8.1+ sudah cukup untuk memulai. Untuk Node.js, pertimbangkan VPS dengan resource yang memadai agar API Anda dapat melayani ribuan request dengan performa optimal.