Cara Menggunakan Framework PYTHON bernama FastAPI

Bagaimana Python Melakukannya? (Framework Web)

Bayangkan membangun sebuah rumah. Anda tidak akan membuat setiap paku, batu bata, atau jendela dari nol. Anda menggunakan komponen yang sudah jadi. Framework web adalah kumpulan komponen, alat, dan aturan yang sudah jadi untuk mempercepat dan mempermudah pembuatan aplikasi web.

Framework ini menangani tugas-tugas rumit di latar belakang (disebut backend), seperti:

• Menerima permintaan dari browser pengguna.

• Mengolah logika bisnis aplikasi.

• Berinteraksi dengan database untuk menyimpan dan mengambil data.

• Mengirimkan kembali halaman HTML, data, atau respons lainnya ke browser.

---

Framework Python Populer untuk Web

Ada beberapa framework utama yang bisa Anda pilih, masing-masing dengan kelebihan dan kekurangannya:

🚀 Django

• "Baterai Sudah Termasuk" (Batteries-included): Django hadir dengan banyak fitur bawaan, seperti panel admin, sistem login pengguna, dan alat untuk berinteraksi dengan database (ORM).

• Cocok untuk: Proyek besar dan kompleks seperti situs e-commerce, jejaring sosial, atau sistem manajemen konten (CMS).

• Contoh Pengguna: Instagram, Spotify, dan Pinterest menggunakan Django.

🧩 Flask

• "Kerangka Mikro" (Micro-framework): Flask sangat ringan, sederhana, dan fleksibel. Ia menyediakan dasar-dasar yang paling penting, dan Anda bebas memilih alat atau pustaka tambahan sesuai kebutuhan.

• Cocok untuk: Proyek kecil hingga menengah, API (Application Programming Interface), atau saat Anda menginginkan kontrol penuh atas komponen yang digunakan.

• Contoh Pengguna: Netflix dan Reddit menggunakan Flask untuk beberapa bagian dari sistem mereka.

⚡ FastAPI

• Modern dan Cepat: Seperti namanya, FastAPI dirancang untuk performa tinggi. Keunggulan utamanya adalah kecepatan dan kemudahan dalam membuat API.

• Fitur Unggulan: Secara otomatis menghasilkan dokumentasi interaktif untuk API Anda, yang sangat membantu pengembang lain.

• Cocok untuk: Membangun API modern yang cepat, aplikasi backend untuk aplikasi seluler, dan layanan mikro (microservices).

1) Apa itu FastAPI?

FastAPI adalah web framework Python modern untuk membangun API yang cepat, mudah ditulis, dan aman. Ia mengandalkan:

• Standard Python type hints → otomatis validasi data & dokumentasi.

• Starlette (asynchronous ASGI toolkit) → routing, middleware, WebSocket, background tasks.

• Pydantic (v2) → parsing & validasi data kencang berbasis model.

• Uvicorn (ASGI server) → server ringan & sangat cepat.

Dampak praktis:

• Kinerja mendekati Node/Go untuk IO-bound.

• Auto OpenAPI → dokumentasi interaktif di /docs (Swagger UI) & /redoc.

• Ergonomis untuk async/await, dependency injection, dan security.

2) Cara kerja inti (mental model)

1. Tipe data Python pada parameter fungsi endpoint → FastAPI membangun skema OpenAPI & validator otomatis (via Pydantic).

2. Dependency Injection (DI) → Anda deklaratif “meminta” dependensi (DB session, auth, config) sebagai parameter; FastAPI yang menginisiasi & menyuntikkan.

3. ASGI & async → Endpoint bisa async def (non-blocking IO) atau def (sync). Middleware & event lifecycle mengikuti spesifikasi ASGI.

3) Komponen utama & fitur penting

• Routing: @app.get/post/put/delete/patch, APIRouter untuk modularitas, prefix & tags.

• Model Data (Pydantic v2): BaseModel untuk request/response, validasi kuat, field alias, validator.

• Validasi & Serialisasi otomatis: dari type hints + Pydantic → HTTP 422 bila data tidak valid.

• Response Model: response_model=ModelOut untuk bentuk respons terjamin; bisa exclude_none, from_attributes.

• Error Handling: HTTPException, custom exception handlers.

• Dependency Injection: Depends(...) untuk auth, DB session, pagination, rate-limit, dsb; bisa yield untuk setup/teardown.

• Security: OAuth2 password flow, scopes, JWT bearer, API key, cookie/session; integrasi mudah dengan fastapi.security.

• Middleware: CORS, GZip, custom logging, tracing.

• Background Tasks: jalankan pekerjaan ringan setelah respons dikirim (email, audit log).

• WebSocket: real-time komunikasi (chat, notifikasi).

• Static files & templates (via Starlette).

• Events/Lifespan: @app.on_event("startup"/"shutdown") atau context lifespan untuk koneksi DB, cache.

• Streaming: StreamingResponse untuk kirim chunk (CSV besar, SSE).

• Testing: TestClient (sync) & httpx.AsyncClient (async).

4) Contoh minimal

from fastapi import FastAPI

app = FastAPI(title="Hello FastAPI")

@app.get("/")
def read_root():
    return {"message": "Hello FastAPI"}

Buat file main.py dengan seperti diatas

Jalankan:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process

.\venv\Scripts\activate

uvicorn main:app --reload 

atau menggunakan


py -m uvicorn main:app --reload

Buka dokumentasi:

• Swagger: http://127.0.0.1:8000/docs

• ReDoc: http://127.0.0.1:8000/redoc

5) Contoh CRUD dengan validasi, response model, dan DI

# main.py
from typing import List
from fastapi import FastAPI, HTTPException, Depends, status
from pydantic import BaseModel, Field
from uuid import UUID, uuid4

app = FastAPI(title="Books API")

# ---- Models ----
class BookIn(BaseModel):
    title: str = Field(..., min_length=1, max_length=120)
    price: float = Field(gt=0)
    in_stock: bool = True

class BookOut(BookIn):
    id: UUID

# ---- Fake DB & Dependency ----
class FakeDB:
    def __init__(self):
        self.data: dict[UUID, BookOut] = {}

def get_db():
    db = FakeDB()
    # seed optional
    yield db
    # teardown optional

# ---- Routes ----
@app.post("/books", response_model=BookOut, status_code=status.HTTP_201_CREATED)
def create_book(payload: BookIn, db: FakeDB = Depends(get_db)):
    book = BookOut(id=uuid4(), **payload.model_dump())
    db.data[book.id] = book
    return book

@app.get("/books", response_model=List[BookOut])
def list_books(db: FakeDB = Depends(get_db)):
    return list(db.data.values())

@app.get("/books/{book_id}", response_model=BookOut)
def get_book(book_id: UUID, db: FakeDB = Depends(get_db)):
    if book_id not in db.data:
        raise HTTPException(status_code=404, detail="Book not found")
    return db.data[book_id]

@app.put("/books/{book_id}", response_model=BookOut)
def update_book(book_id: UUID, payload: BookIn, db: FakeDB = Depends(get_db)):
    if book_id not in db.data:
        raise HTTPException(status_code=404, detail="Book not found")
    book = BookOut(id=book_id, **payload.model_dump())
    db.data[book_id] = book
    return book

@app.delete("/books/{book_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_book(book_id: UUID, db: FakeDB = Depends(get_db)):
    if db.data.pop(book_id, None) is None:
        raise HTTPException(status_code=404, detail="Book not found")

6) Autentikasi singkat (JWT Bearer)

from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

auth_scheme = HTTPBearer()

def get_current_user(token: HTTPAuthorizationCredentials = Depends(auth_scheme)):
    # verifikasi JWT di sini (decode, cek exp, audience, dsb)
    if token.scheme.lower() != "bearer":
        raise HTTPException(status_code=401, detail="Invalid scheme")
    # ... decode & validate
    return {"sub": "user-id-123"}

@app.get("/me")
def me(user=Depends(get_current_user)):
    return {"user": user}

7) Database & async pattern (contoh dengan SQLAlchemy)

Pola umum:

• Buat Session per request via DI.

• Gunakan async engine + async_sessionmaker untuk IO non-blocking.

• Pydantic v2: pakai model_config = ConfigDict(from_attributes=True) agar bisa mengembalikan ORM object.

Sketsa:

# db.py
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession

engine = create_async_engine("postgresql+asyncpg://user:pass@host/db", echo=False)
SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)

async def get_session():
    async with SessionLocal() as session:
        yield session

Di endpoint:

from sqlalchemy import select
from fastapi import Depends

@app.get("/items")
async def items(session: AsyncSession = Depends(get_session)):
    result = await session.execute(select(Item))
    return result.scalars().all()

8) Middleware, CORS, Background Task

from fastapi.middleware.cors import CORSMiddleware
from fastapi import BackgroundTasks

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # sesuaikan di produksi
    allow_methods=["*"],
    allow_headers=["*"],
)

def send_email(to: str, subject: str):
    # kirim email asinkron ringkas (non-IO berat)
    ...

@app.post("/contact")
def contact(email: str, background: BackgroundTasks):
    background.add_task(send_email, to=email, subject="Thanks")
    return {"ok": True}

9) Testing

Sync (cepat untuk unit):

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_root():
    r = client.get("/")
    assert r.status_code == 200

Async (end-to-end IO): gunakan pytest + httpx.AsyncClient.

10) Struktur proyek yang rapi

app/
  __init__.py
  main.py
  api/
    __init__.py
    routes/
      users.py
      items.py
    deps.py
  core/
    config.py
    security.py
  db/
    base.py
    session.py
    models.py
  schemas/
    users.py
    items.py
  services/
    mailer.py
    payments.py
tests/
  test_items.py

• Pakai APIRouter per domain, schemas untuk Pydantic, models untuk ORM, services untuk logika bisnis, deps.py untuk DI.

• Konfigurasi dengan pydantic_settings.BaseSettings (ENV → object).

11) Performa & skala

• Jalankan produksi via Gunicorn + Uvicorn workers:
  gunicorn -k uvicorn.workers.UvicornWorker -w 4 app.main:app

• Gunakan keep-alive, connection pooling DB, caching (Redis), GZip untuk respons besar.

• Profil IO (jangan blocking di endpoint async). Untuk CPU bound, pakai task queue (Celery, RQ) atau offload ke proses lain.

12) Praktik terbaik (ringkas)

• Ketatkan response_model untuk kontrak API yang stabil.

• Pisahkan schema (Pydantic) dari model ORM.

• Gunakan status codes & detail error yang jelas.

• Tambahkan tags, summary, description pada endpoint → dokumentasi rapi.

• Audit security: JWT expiry, scopes, rate limiting, CORS ketat di prod.

• Tutup resource di lifespan/yield DI.

• Tulis tes untuk skenario kritis (auth, transaksi, validasi).

• Logging & observabilitas (uvicorn access log, middleware trace, Sentry/OpenTelemetry jika perlu).

• Menyusun checklist deployment (Nginx reverse proxy, SSL, systemd service).

Contoh Aplikasi Absensi Siswa dalam menggunakan FastAPI 

Disclaimer  : Trial Error😅😁😎

Bisa di download di sini▶️

https://drive.google.com/drive/folders/1cvBNfpakhTGlYGi7wO1VBeUS1k0nFEcg?usp=sharing

Berbagi :