Belajar Python - Web Frameworks & API Design

#Pendahuluan

Setelah menguasai networking di episode 12, sekarang saatnya membangun sisi server. Episode 13 membandingkan tiga web framework Python terpopuler — Flask, Django, dan FastAPI — dan mengajarkan cara merancang API yang baik.

Kita akan membangun API FastAPI sungguhan, merancang RESTful dan GraphQL, serta menerapkan versioning, pagination, dan validasi input — keterampilan yang langsung dipakai di dunia kerja.

#Membandingkan Flask, Django, dan FastAPI

#Flask: Micro-Framework

Flask minimal dan fleksibel, cocok untuk API kecil dan prototype:

pip install flask

Flask minimal

from flask import Flask, jsonify
 
app = Flask(__name__)
 
@app.route("/halo")
def halo():
    return jsonify({"pesan": "Halo Flask"})

@app.route("/halo") menghubungkan URL ke fungsi. Flask memberi kebebasan penuh memilih komponen, tapi tanggung jawab struktur ada di kalian. Cocok untuk proyek kecil yang butuh kontrol total.

#Django: Batteries Included

Django menyediakan semuanya — ORM, admin, auth — dalam satu framework:

pip install django
django-admin startproject belajardjango
cd belajardjango
python3 manage.py runserver

django-admin startproject belajardjango membuat project dengan struktur lengkap. Django unggul untuk aplikasi web besar yang butuh banyak fitur bawaan: admin panel, autentikasi, dan migrasi datang gratis.

#FastAPI: Modern dan Async

FastAPI menggabungkan tipe Python, validasi otomatis, dan performa async:

pip install "fastapi[standard]"

FastAPI minimal

from fastapi import FastAPI
 
app = FastAPI()
 
@app.get("/halo")
def halo():
    return {"pesan": "Halo FastAPI"}

@app.get("/halo") mendefinisikan endpoint. FastAPI memakai tipe Python untuk validasi dan dokumentasi otomatis. Ini pilihan utama untuk API baru dan microservice di era modern.

#Merancang RESTful API

#Prinsip REST

REST (Representational State Transfer) memakai resource dan metode HTTP:

Endpoint REST dasar

from fastapi import FastAPI
 
app = FastAPI()
produk = {}
 
@app.get("/produk")
def daftar_produk():
    return produk
 
@app.post("/produk/{id_produk}")
def tambah_produk(id_produk: int, nama: str):
    produk[id_produk] = nama
    return {"id": id_produk, "nama": nama}

@app.get("/produk") mengambil daftar, @app.post("/produk/{id_produk}") menambah data. REST memakai kata benda untuk resource dan metode HTTP sebagai aksi. Nama endpoint harus jamak dan konsisten.

#Validasi Input dengan Pydantic

#Mengapa Validasi Penting

Validasi input mencegah data rusak masuk ke sistem dan menjadi fondasi keamanan. FastAPI memakai pydantic untuk ini:

Model Pydantic untuk validasi

from fastapi import FastAPI
from pydantic import BaseModel, Field
 
app = FastAPI()
 
class Produk(BaseModel):
    nama: str = Field(min_length=1, max_length=100)
    harga: int = Field(gt=0)
 
@app.post("/produk")
def buat_produk(data: Produk):
    return data

class Produk(BaseModel) mendefinisikan skema dengan batasan. Field(min_length=1, max_length=100) dan Field(gt=0) memvalidasi otomatis. Jika input invalid, FastAPI mengembalikan 422 dengan detail error — tanpa perlu menulis kode validasi manual.

#Versioning dan Pagination

#Versioning API

API berubah seiring waktu. Versioning melindungi klien yang sudah ada:

API dengan versioning

from fastapi import FastAPI
 
app_v1 = FastAPI()
app_v2 = FastAPI()
 
@app_v1.get("/produk")
def daftar_v1():
    return {"versi": "v1"}
 
@app_v2.get("/produk")
def daftar_v2():
    return {"versi": "v2", "paginated": True}

Membuat aplikasi terpisah per versi adalah satu pendekatan. Alternatif lain memakai prefix URL /api/v1 dan /api/v2. Versioning memberi waktu bagi klien untuk bermigrasi saat API berevolusi.

#GraphQL: Pendekatan Alternatif

#Memahami GraphQL

GraphQL memungkinkan klien meminta data spesifik yang dibutuhkan, berbeda dengan REST yang mengembalikan struktur tetap:

GraphQL dengan strawberry

import strawberry
 
@strawberry.type
class Produk:
    id: int
    nama: str
 
@strawberry.type
class Query:
    @strawberry.field
    def produk(self, id: int) -> Produk:
        return Produk(id=id, nama="Contoh")
 
schema = strawberry.Schema(query=Query)
print(schema.as_str()[:50])

@strawberry.type mendefinisikan tipe GraphQL dan @strawberry.field mendefinisikan query. Klien bisa memilih field yang diminta, mengurangi over-fetching. GraphQL cocok untuk aplikasi dengan banyak klien dan kebutuhan data beragam.

#Penutup

Inti yang harus dibawa pulang:

• Flask minimal dan fleksibel; Django lengkap; FastAPI modern dan async.
• FastAPI memakai tipe Python untuk validasi dan dokumentasi otomatis.
• REST memakai resource dan metode HTTP dengan nama jamak.
• Pydantic memvalidasi input dengan batasan Field.
• Versioning melindungi klien saat API berevolusi.
• GraphQL memungkinkan klien meminta data spesifik dan mengurangi over-fetching.

Di episode 14 selanjutnya kita akan membahas security best practices — secure coding dengan validasi input dan escaping, pencegahan injection, pola autentikasi dan otorisasi dengan JWT dan OAuth2, perlindungan CSRF dan CORS, serta scanning dependency security. API kalian akan menjadi aman!