Membuat RESTful APIs dengan FastAPI - Tutorial Lengkap

Dalam pengembangan web modern, API (Application Programming Interface) adalah jembatan vital yang menghubungkan frontend (React, Vue, Mobile App) dengan backend (Server & Database).

Python memiliki banyak framework API, tetapi FastAPI adalah bintang yang paling bersinar saat ini. Sesuai namanya, ia sangat cepat (setara dengan NodeJS dan Go), modern, dan memiliki fitur dokumentasi otomatis yang luar biasa.

Mengapa FastAPI?

🚀 Performa Tinggi: Dibangun di atas Starlette dan Pydantic.
⚡ Cepat Di-coding: Meningkatkan kecepatan pengembangan hingga 200%-300%.
🐛 Lebih Sedikit Bug: Mengurangi sekitar 40% bug yang disebabkan oleh kesalahan manusia (developer).
📝 Dokumentasi Otomatis: Swagger UI & ReDoc langsung tersedia.

Dalam tutorial ini, kita akan:

Memahami konsep RESTful API.
Instalasi dan Persiapan Lingkungan.
Membuat API dengan operasi CRUD (Create, Read, Update, Delete).
Validasi data otomatis dengan Pydantic.
Melihat dokumentasi API yang auto-generated.

Apa itu RESTful API?

REST (Representational State Transfer) adalah gaya arsitektur komunikasi web. API RESTful menggunakan metode HTTP standar (Verbs) untuk berinteraksi dengan resource:

Method HTTP	Fungsi	Analogi SQL	Deskripsi
GET	Read	SELECT	Mengambil data dari server.
POST	Create	INSERT	Mengirim data baru ke server.
PUT	Update	UPDATE	Memperbarui data yang sudah ada (secara keseluruhan).
DELETE	Delete	DELETE	Menghapus data dari server.

Data biasanya dikirim dan diterima dalam format JSON (JavaScript Object Notation), yang mudah dibaca manusia dan mesin.

1. Persiapan Lingkungan (Untuk Lokal)

Jika Anda mengikuti tutorial ini di komputer sendiri (bukan di simulator browser kami), Anda perlu menginstal FastAPI dan server ASGI:

pip install fastapi "uvicorn[standard]"

FastAPI: Framework untuk membangun API.
Uvicorn: Web server ASGI (Asynchronous Server Gateway Interface) untuk menjalankan FastAPI.

2. Hello World: API Pertama Anda

FastAPI sangat minimalis. Mari buat file main.py pertama kita.

Kode Dasar

from fastapi import FastAPI

# 1. Inisialisasi Aplikasi
app = FastAPI()

# 2. Definisi Route (Endpoint)
@app.get("/")
async def read_root():
    return {"message": "Hello World", "status": "running"}

Menjalankan Server

Jalankan perintah berikut di terminal:

uvicorn main:app --reload

Server akan aktif di http://127.0.0.1:8000. Jika Anda membukanya di browser, Anda akan melihat respons JSON: {"message": "Hello World", "status": "running"}

Catatan: Kami menggunakan async def karena FastAPI mendukung asynchronous code secara native, yang membuatnya sangat efisien menangani banyak request sekaligus.

3. Path Parameters & Type Hints

Bagaimana jika kita ingin mengambil data spesifik, misalnya detail produk berdasarkan ID? Kita gunakan Path Parameters.

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    # Type hint 'int' otomatis memvalidasi input!
    return {"item_id": item_id, "name": f"Barang ke-{item_id}"}

FastAPI cerdas:

Jika user mengakses /items/5, item_id akan dibaca sebagai integer 5.
Jika user mengakses /items/foo, FastAPI otomatis memberikan error validasi: "value is not a valid integer". Anda tidak perlu menulis kode validasi manual!

4. Query Parameters

Query parameters adalah key-value yang ada di URL setelah tanda ?, misalnya ?skip=0&limit=10. Parameter fungsi yang bukan path parameter otomatis dianggap sebagai query parameter.

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
    return fake_items_db[skip : skip + limit]

URL akses: http://127.0.0.1:8000/items/?skip=1&limit=1

5. Request Body & Pydantic (POST)

Untuk mengirim data (misalnya menambah produk baru), kita menggunakan method POST. Kita butuh validasi agar data yang dikirim user sesuai format. Di sinilah Pydantic bersinar.

from pydantic import BaseModel
from typing import Optional

# Definisi Model Data (Schema)
class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None

@app.post("/items/")
async def create_item(item: Item):
    item_dict = item.dict()
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

FastAPI akan:

Membaca body request sebagai JSON.
Mengonversi tipe data (misal string "10.5" ke float 10.5).
Memvalidasi data (apakah field wajib ada?).
Memberikan error detail jika validasi gagal.

6. Update (PUT) & Delete (DELETE)

Melengkapi operasi CRUD, berikut cara update dan delete:

# Update data
@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    return {"item_id": item_id, "updated_data": item}

# Delete data
@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    return {"status": "deleted", "item_id": item_id}

7. Dokumentasi Otomatis (Swagger UI)

Salah satu fitur terbaik FastAPI adalah dokumentasi yang dibuat otomatis. Tanpa perlu plugin tambahan, cukup buka:

Swagger UI: http://127.0.0.1:8000/docs - UI interaktif untuk mencoba API Anda.
ReDoc: http://127.0.0.1:8000/redoc - Dokumentasi statis yang cantik.

Ini sangat membantu komunikasi antara Backend dan Frontend developer.

Struktur Project Besar

Untuk project serius, kode tidak boleh ditumpuk di satu file main.py saja. Kita harus memecahnya menggunakan APIRouter agar lebih modular dan mudah dikelola.

Contoh Struktur Folder

my-project/
├── main.py          # Entry point aplikasi
└── routers/         # Folder untuk menyimpan route
    ├── __init__.py
    ├── items.py     # Endpoint khusus barang
    └── users.py     # Endpoint khusus user

1. File `routers/items.py`

Buat file untuk menangani logika items:

from fastapi import APIRouter

router = APIRouter()

@router.get("/items/")
async def read_items():
    return [{"name": "Item A"}, {"name": "Item B"}]

2. File `main.py`

Panggil router tersebut di aplikasi utama:

from fastapi import FastAPI
from routers import items

app = FastAPI()

app.include_router(items.router)

@app.get("/")
async def root():
    return {"message": "Aplikasi Berjalan"}

Dengan cara ini, aplikasi Anda bisa tumbuh besar tanpa menjadi "spaghetti code"!

Kesimpulan

FastAPI adalah revolusi di dunia Python backend. Ia menggabungkan kecepatan eksekusi (async), kecepatan coding (type hints + autocompletion), dan fitur modern (OpenAPI standard).

Kelebihan utama:

🚀 Performa Tinggi: Berbasis Starlette dan Pydantic.
📝 Dokumentasi Otomatis: Swagger UI & ReDoc langsung tersedia.
🛡️ Tipe Data Aman: Bug berkurang drastis berkat Type Hints.

Siap membangun API Anda sendiri? Mulai dengan project kecil, dan rasakan nikmatnya menggunakan FastAPI!

Edit tutorial ini

Cybersecurity

Fullstack App

OFFICIAL COMMUNITY

Gabung Komunitas Developer & Kreator Digital

Dapatkan teman coding, sharing project, networking dengan expert, dan update teknologi terbaru.

Materi Tutorial