🚀 Membangun Aplikasi CRUD dengan FastAPI – Panduan Lengkap

FastAPI adalah kerangka kerja web modern dan berkinerja tinggi untuk membangun API dengan Python. Dalam panduan ini, kita akan membahas cara membangun aplikasi CRUD (Create, Read, Update, Delete) lengkap menggunakan FastAPI, dengan fokus pada praktik terbaik, keamanan, dan kemampuan skalabilitas.

Daftar Isi

1. Pendahuluan FastAPI dan CRUD
2. Menyiapkan Lingkungan Pengembangan
3. Membangun Model Data (Database dengan SQLAlchemy)
4. Membuat Endpoint CRUD dengan FastAPI
   1. Endpoint Create (POST)
   2. Endpoint Read (GET)
   3. Endpoint Update (PUT)
   4. Endpoint Delete (DELETE)
5. Validasi Data dengan Pydantic
6. Penanganan Error dan Exception
7. Otentikasi dan Otorisasi
8. Pengujian Aplikasi FastAPI
9. Dokumentasi API dengan Swagger UI
10. Deployment Aplikasi FastAPI
11. Praktik Terbaik dan Tips
12. Kesimpulan

1. Pendahuluan FastAPI dan CRUD

FastAPI adalah kerangka kerja web Python modern dan cepat (kinerja tinggi), yang dirancang untuk membangun API. Fitur utamanya termasuk:

• Kecepatan: Berdasarkan Starlette dan Pydantic, FastAPI menawarkan kinerja yang sangat baik.
• Kemudahan Penggunaan: Dirancang dengan mempertimbangkan pengembang, sehingga mudah dipelajari dan digunakan.
• Validasi Data: Integrasi dengan Pydantic untuk validasi data dan serialisasi.
• Dokumentasi Otomatis: Menghasilkan dokumentasi API interaktif dengan Swagger UI dan ReDoc.
• Dependency Injection: Sistem dependency injection yang kuat untuk modularitas dan pengujian.

CRUD adalah singkatan dari Create, Read, Update, dan Delete. Operasi-operasi ini adalah fungsi dasar yang diperlukan untuk mengelola data persisten dalam aplikasi. Membangun aplikasi CRUD adalah cara yang bagus untuk mempelajari dasar-dasar pengembangan API.

2. Menyiapkan Lingkungan Pengembangan

Sebelum kita mulai membangun aplikasi CRUD, kita perlu menyiapkan lingkungan pengembangan kita.

1. Instal Python: Pastikan Anda memiliki Python 3.7 atau lebih tinggi yang terinstal. Anda dapat mengunduhnya dari situs web resmi Python.
2. Buat Virtual Environment: Virtual environment membantu mengisolasi dependensi proyek Anda. Buka terminal dan jalankan perintah berikut:

python3 -m venv venv
  source venv/bin/activate  # Di Linux/macOS
  venv\Scripts\activate  # Di Windows

3. Instal FastAPI dan Dependensi: Instal FastAPI, Uvicorn (server ASGI), dan SQLAlchemy (ORM untuk database):

pip install fastapi uvicorn sqlalchemy python-dotenv psycopg2-binary

3. Membangun Model Data (Database dengan SQLAlchemy)

Kita akan menggunakan SQLAlchemy untuk berinteraksi dengan database kita. Mari definisikan model data kita.

1. Buat File `database.py`: Buat file bernama `database.py` dan tambahkan kode berikut:

from sqlalchemy import create_engine
  from sqlalchemy.ext.declarative import declarative_base
  from sqlalchemy.orm import sessionmaker
  import os
  from dotenv import load_dotenv

  load_dotenv()

  DATABASE_URL = os.getenv("DATABASE_URL")

  engine = create_engine(DATABASE_URL)

  SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

  Base = declarative_base()

  def get_db():
      db = SessionLocal()
      try:
          yield db
      finally:
          db.close()

2. Buat File `.env`: Untuk menyimpan informasi koneksi database, buat file `.env` dan tambahkan URL databasenya.

DATABASE_URL=postgresql://username:password@host:port/database_name

3. Buat File `models.py`: Buat file bernama `models.py` dan definisikan model SQLAlchemy kita:

from sqlalchemy import Column, Integer, String
  from sqlalchemy.ext.declarative import declarative_base
  from sqlalchemy.orm import relationship
  from .database import Base

  class Item(Base):
      __tablename__ = "items"

      id = Column(Integer, primary_key=True, index=True)
      name = Column(String, index=True)
      description = Column(String, nullable=True)
      price = Column(Integer)

4. Buat Database: Jalankan kode Python berikut untuk membuat tabel database:

from .database import engine
  from .models import Base

  Base.metadata.create_all(bind=engine)

4. Membuat Endpoint CRUD dengan FastAPI

Sekarang kita akan membuat endpoint CRUD menggunakan FastAPI.

1. Buat File `main.py`: Buat file bernama `main.py` dan tambahkan kode berikut:

Endpoint Create (POST)

Endpoint ini akan memungkinkan kita untuk membuat item baru.

from fastapi import FastAPI, Depends, HTTPException
  from sqlalchemy.orm import Session
  from . import models, schemas
  from .database import get_db, engine

  models.Base.metadata.create_all(bind=engine)

  app = FastAPI()

  @app.post("/items/", response_model=schemas.Item)
  def create_item(item: schemas.ItemCreate, db: Session = Depends(get_db)):
      db_item = models.Item(**item.dict())
      db.add(db_item)
      db.commit()
      db.refresh(db_item)
      return db_item

Penjelasan:

• @app.post("/items/"): Mendefinisikan endpoint POST di `/items/`.
• item: schemas.ItemCreate: Memvalidasi input menggunakan skema Pydantic ItemCreate.
• db: Session = Depends(get_db): Mendapatkan sesi database melalui dependency injection.

Endpoint Read (GET)

Endpoint ini akan memungkinkan kita untuk membaca satu item berdasarkan ID.

@app.get("/items/{item_id}", response_model=schemas.Item)
  def read_item(item_id: int, db: Session = Depends(get_db)):
      db_item = db.query(models.Item).filter(models.Item.id == item_id).first()
      if db_item is None:
          raise HTTPException(status_code=404, detail="Item not found")
      return db_item

Penjelasan:

• @app.get("/items/{item_id}"): Mendefinisikan endpoint GET di `/items/{item_id}`.
• item_id: int: Mengambil ID item dari path parameter.
• Jika item tidak ditemukan, raise HTTPException dengan status kode 404.

Endpoint ini akan memungkinkan kita untuk membaca semua item.

@app.get("/items/", response_model=list[schemas.Item])
  def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    items = db.query(models.Item).offset(skip).limit(limit).all()
    return items

Penjelasan:

• @app.get("/items/"): Mendefinisikan endpoint GET di `/items/`.
• skip: int = 0: Parameter opsional untuk melewati item.
• limit: int = 100: Parameter opsional untuk membatasi jumlah item.

Endpoint Update (PUT)

Endpoint ini akan memungkinkan kita untuk memperbarui item yang ada.

@app.put("/items/{item_id}", response_model=schemas.Item)
  def update_item(item_id: int, item: schemas.ItemUpdate, db: Session = Depends(get_db)):
      db_item = db.query(models.Item).filter(models.Item.id == item_id).first()
      if db_item is None:
          raise HTTPException(status_code=404, detail="Item not found")

      for key, value in item.dict(exclude_unset=True).items():
          setattr(db_item, key, value)

      db.add(db_item)
      db.commit()
      db.refresh(db_item)
      return db_item

Penjelasan:

• @app.put("/items/{item_id}"): Mendefinisikan endpoint PUT di `/items/{item_id}`.
• item: schemas.ItemUpdate: Memvalidasi input menggunakan skema Pydantic ItemUpdate.
• exclude_unset=True: Hanya memperbarui field yang disediakan dalam permintaan.

Endpoint Delete (DELETE)

Endpoint ini akan memungkinkan kita untuk menghapus item yang ada.

@app.delete("/items/{item_id}")
  def delete_item(item_id: int, db: Session = Depends(get_db)):
      db_item = db.query(models.Item).filter(models.Item.id == item_id).first()
      if db_item is None:
          raise HTTPException(status_code=404, detail="Item not found")

      db.delete(db_item)
      db.commit()
      return {"message": "Item deleted"}

Penjelasan:

• @app.delete("/items/{item_id}"): Mendefinisikan endpoint DELETE di `/items/{item_id}`.
• Menghapus item dari database dan melakukan commit perubahan.

5. Validasi Data dengan Pydantic

Pydantic digunakan untuk validasi data dan serialisasi. Mari definisikan skema Pydantic kita.

1. Buat File `schemas.py`: Buat file bernama `schemas.py` dan tambahkan kode berikut:

from typing import Optional
  from pydantic import BaseModel

  class ItemBase(BaseModel):
      name: str
      description: Optional[str] = None
      price: int

  class ItemCreate(ItemBase):
      pass

  class ItemUpdate(ItemBase):
      name: Optional[str] = None
      description: Optional[str] = None
      price: Optional[int] = None

  class Item(ItemBase):
      id: int

      class Config:
          orm_mode = True

Penjelasan:

• ItemBase: Skema dasar dengan field umum.
• ItemCreate: Skema untuk membuat item baru.
• ItemUpdate: Skema untuk memperbarui item yang ada.
• Item: Skema untuk menampilkan item yang ada, termasuk ID.
• orm_mode = True: Mengaktifkan dukungan ORM untuk konversi antara model SQLAlchemy dan skema Pydantic.

6. Penanganan Error dan Exception

Penanganan error yang tepat sangat penting untuk aplikasi yang kuat. Kita akan menggunakan FastAPI untuk menangani exception.

Contoh penanganan HTTPException:

from fastapi import FastAPI, HTTPException

  app = FastAPI()

  @app.get("/items/{item_id}")
  async def read_item(item_id: int):
      if item_id not in items:
          raise HTTPException(status_code=404, detail="Item not found")
      return {"item_id": item_id, "item_name": items[item_id]}

Anda juga dapat membuat exception handler khusus untuk menangani exception tertentu.

7. Otentikasi dan Otorisasi

Keamanan adalah aspek penting dari setiap aplikasi. Mari terapkan otentikasi dan otorisasi menggunakan FastAPI.

1. Instal Dependensi: Instal dependensi yang diperlukan:

pip install python-jose passlib bcrypt

2. Buat Utilitas Keamanan: Buat file bernama `security.py` dan tambahkan kode berikut:

from passlib.context import CryptContext

  pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

  def hash_password(password: str):
      return pwd_context.hash(password)

  def verify_password(plain_password: str, hashed_password: str):
      return pwd_context.verify(plain_password, hashed_password)

Otentikasi dapat diimplementasikan menggunakan token JWT (JSON Web Tokens). Kita dapat menggunakan python-jose untuk membuat dan memverifikasi token.

8. Pengujian Aplikasi FastAPI

Pengujian sangat penting untuk memastikan aplikasi kita berfungsi seperti yang diharapkan. Kita akan menggunakan pytest untuk pengujian.

1. Instal Pytest: Instal pytest dan dependensi terkait:

pip install pytest httpx

2. Buat File `test_main.py`: Buat file bernama `test_main.py` dan tambahkan pengujian:

import pytest
  from httpx import AsyncClient
  from .main import app

  @pytest.mark.asyncio
  async def test_create_item():
      async with AsyncClient(app=app, base_url="http://test") as ac:
          response = await ac.post("/items/", json={"name": "Test Item", "description": "Test Description", "price": 10})
      assert response.status_code == 200
      assert response.json()["name"] == "Test Item"

3. Jalankan Pengujian: Jalankan pengujian dengan perintah berikut:

pytest

9. Dokumentasi API dengan Swagger UI

FastAPI secara otomatis menghasilkan dokumentasi API interaktif menggunakan Swagger UI dan ReDoc.

1. Akses Dokumentasi: Buka browser Anda dan kunjungi `/docs` atau `/redoc` untuk melihat dokumentasi API.

10. Deployment Aplikasi FastAPI

Setelah aplikasi kita siap, kita dapat mendeploynya ke server.

Opsi deployment populer:

• Heroku: Platform cloud yang mudah digunakan.
• AWS: Layanan web Amazon dengan berbagai opsi deployment.
• Google Cloud: Platform cloud Google dengan berbagai opsi deployment.
• Docker: Kontainerisasi aplikasi kita untuk deployment yang konsisten.

Contoh deployment dengan Docker:

1. Buat File `Dockerfile`: Buat file bernama `Dockerfile` dan tambahkan kode berikut:

FROM python:3.9

  WORKDIR /app

  COPY requirements.txt .
  RUN pip install --no-cache-dir -r requirements.txt

  COPY . .

  CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

2. Buat File `requirements.txt`: Buat file bernama `requirements.txt` dan tambahkan dependensi proyek Anda:

fastapi
  uvicorn
  sqlalchemy
  python-dotenv
  psycopg2-binary

3. Bangun dan Jalankan Kontainer Docker: Jalankan perintah berikut untuk membangun dan menjalankan kontainer Docker:

docker build -t fastapi-crud .
  docker run -p 8000:8000 fastapi-crud

11. Praktik Terbaik dan Tips

Berikut adalah beberapa praktik terbaik dan tips untuk membangun aplikasi FastAPI yang sukses:

• Gunakan Virtual Environment: Selalu gunakan virtual environment untuk mengisolasi dependensi proyek Anda.
• Validasi Data: Gunakan Pydantic untuk validasi data yang kuat.
• Penanganan Error: Implementasikan penanganan error yang tepat untuk memberikan respons yang bermakna kepada pengguna.
• Keamanan: Terapkan otentikasi dan otorisasi untuk melindungi API Anda.
• Pengujian: Tulis pengujian unit dan integrasi untuk memastikan kode Anda berfungsi seperti yang diharapkan.
• Dokumentasi: Manfaatkan dokumentasi otomatis FastAPI untuk memberikan dokumentasi API yang jelas dan ringkas.
• Kode Modular: Susun kode Anda menjadi modul yang lebih kecil dan dapat dikelola.
• Asynchronous: Manfaatkan kemampuan asinkron FastAPI untuk meningkatkan kinerja.
• Logging: Implementasikan logging untuk memantau dan men-debug aplikasi Anda.
• Monitoring: Gunakan alat monitoring untuk melacak kinerja aplikasi Anda dan mengidentifikasi masalah.

12. Kesimpulan

Dalam panduan ini, kita telah membahas cara membangun aplikasi CRUD lengkap menggunakan FastAPI. Kita telah membahas penyiapan lingkungan, model data, endpoint CRUD, validasi data, penanganan error, otentikasi, pengujian, dokumentasi, deployment, dan praktik terbaik. Dengan mengikuti langkah-langkah ini, Anda dapat membangun API yang kuat dan mudah dipelihara dengan FastAPI.

FastAPI adalah kerangka kerja yang sangat baik untuk membangun API modern. Kinerja, kemudahan penggunaan, dan fitur-fitur canggihnya menjadikannya pilihan yang sangat baik untuk berbagai aplikasi.