FastAPI #

FastAPI adalah web framework modern, cepat (high-performance) yang dibangun di atas Python 3.7+ dan mendukung pengembangan API berbasis standard OpenAPI dan JSON Schema. FastAPI dirancang untuk menghasilkan kode yang cepat, efisien, dan mudah digunakan, serta mendukung fitur seperti validasi data otomatis, dokumentasi interaktif, dan performa tinggi.

Instalasi FastAPI #

Untuk memulai dengan FastAPI, Anda harus menginstalnya terlebih dahulu. Anda juga perlu menginstal uvicorn, server ASGI untuk menjalankan aplikasi FastAPI.

pip install fastapi
pip install uvicorn

Membuat Aplikasi FastAPI #

Berikut adalah contoh sederhana bagaimana membuat aplikasi FastAPI.

Membuat File Aplikasi #

Buat file Python, misalnya main.py, dan tulis kode berikut:

from fastapi import FastAPI

app = FastAPI()

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

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Menjalankan Aplikasi #

Untuk menjalankan aplikasi FastAPI, gunakan uvicorn:

uvicorn main:app --reload

Server akan berjalan di http://127.0.0.1:8000/.

Fitur Utama FastAPI #

Dokumentasi Otomatis #

FastAPI secara otomatis menghasilkan dokumentasi interaktif untuk API Anda menggunakan Swagger UI dan Redoc. Anda dapat mengakses dokumentasi ini di:

• Swagger UI: http://127.0.0.1:8000/docs
• Redoc: http://127.0.0.1:8000/redoc

Validasi dan Parsing Data #

FastAPI menggunakan pydantic untuk validasi data dan parsing. Anda dapat mendefinisikan model data dengan pydantic dan menggunakannya dalam rute API.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.post("/items/")
def create_item(item: Item):
    return item

Query Parameters dan Path Parameters #

FastAPI mendukung query parameters dan path parameters dengan cara yang mudah dan intuitif.

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Dependency Injection #

FastAPI mendukung dependency injection, yang memungkinkan Anda untuk mendefinisikan dependensi dan menggunakannya dalam rute API.

from fastapi import Depends, FastAPI

app = FastAPI()

def common_parameters(q: str = None, skip: int = 0, limit: int = 10):
    return {"q": q, "skip": skip, "limit": limit}

@app.get("/items/")
def read_items(commons: dict = Depends(common_parameters)):
    return commons

Menjalankan Asynchronous Code #

FastAPI mendukung kode asynchronous, yang memungkinkan Anda untuk menulis aplikasi yang sangat efisien dan skalabel.

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/")
async def read_root():
    await asyncio.sleep(1)
    return {"Hello": "World"}

Penggunaan Database dengan FastAPI #

FastAPI dapat diintegrasikan dengan berbagai database melalui ORM seperti SQLAlchemy atau Tortoise-ORM. Berikut adalah contoh menggunakan SQLAlchemy.

Instalasi SQLAlchemy dan dependencies #

pip install sqlalchemy
pip install databases
pip install asyncpg

Konfigurasi Database #

Buat file database.py:

from sqlalchemy import create_engine, MetaData

DATABASE_URL = "postgresql://user:password@localhost/dbname"

engine = create_engine(DATABASE_URL)
metadata = MetaData()

database = databases.Database(DATABASE_URL)

Model dan CRUD Operations #

Buat file models.py:

from sqlalchemy import Table, Column, Integer, String
from .database import metadata

notes = Table(
    "notes",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("text", String(50)),
    Column("completed", String(50)),
)

Buat file main.py:

from fastapi import FastAPI
from .database import database, engine, metadata
from .models import notes

metadata.create_all(engine)

app = FastAPI()

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.get("/notes/")
async def read_notes():
    query = notes.select()
    return await database.fetch_all(query)

Kesimpulan #

FastAPI adalah framework yang modern, cepat, dan mudah digunakan untuk pengembangan API dengan Python. Dengan dukungan untuk validasi data otomatis, dokumentasi interaktif, dan performa tinggi, FastAPI memungkinkan pengembang untuk membuat API yang kuat dan efisien dengan cepat. Untuk informasi lebih lanjut, Anda bisa merujuk ke dokumentasi resmi FastAPI.