Apa itu FastAPI

FastAPI adalah kerangka kerja web canggih dan berperforma tinggi yang digunakan untuk membangun API (Application Programming Interfaces) dengan Python 3.6 dan versi yang lebih baru. FastAPI dibangun di atas Starlette untuk routing web dan Pydantic untuk validasi data dan pengelolaan pengaturan. Ketergantungan ini memastikan kecepatan dan keandalan FastAPI, menjadikannya pilihan yang sangat baik untuk pengembangan web modern.

FastAPI pertama kali dirilis ke publik pada bulan Desember 2018. Sejak itu, FastAPI telah mendapatkan popularitas yang signifikan karena kecepatannya, kemudahan penggunaan, dan kumpulan fitur yang komprehensif.

Fitur Utama FastAPI

Salah satu fitur paling menonjol dari FastAPI adalah kecepatannya. Dibandingkan dengan kerangka kerja Python populer lainnya, FastAPI menonjol baik dari segi performa maupun kecepatan pengembangan. FastAPI adalah salah satu kerangka kerja Python tercepat yang tersedia, hanya sedikit lebih lambat daripada NodeJS dan Go.

FastAPI dirancang berdasarkan fitur petunjuk tipe Python. Petunjuk tipe adalah fitur dalam Python yang memungkinkan pengembang untuk mengindikasikan tipe yang diharapkan dari argumen fungsi atau nilai kembalian. FastAPI menggunakan petunjuk tipe ini untuk menangani validasi data, serialisasi, dan dokumentasi, yang mengarah pada pengurangan bug dan kode yang lebih bersih.

FastAPI juga dikenal dengan dokumentasi API otomatis dan interaktifnya. Ketika Anda membuat endpoint API baru di FastAPI, kerangka kerja ini secara otomatis menghasilkan halaman dokumentasi interaktif untuk endpoint tersebut menggunakan Swagger UI atau ReDoc. Fitur ini memungkinkan pengembang dan pengguna untuk berinteraksi dengan API, memahami fungsionalitasnya, dan bahkan menguji parameter yang berbeda dan melihat responsnya, semua melalui browser web mereka.

Fitur lain yang menonjol dari FastAPI adalah dukungannya yang kuat untuk penanganan permintaan secara asinkron. Dibangun di atas Starlette, sebuah kerangka kerja web asinkron, FastAPI mendukung kata kunci async dan await bawaan Python, yang memungkinkan pengembang menulis kode asinkron untuk menangani operasi yang terikat pada IO dengan efisien.

FastAPI juga menyediakan dukungan untuk otentikasi OAuth2, JSON Web Tokens, parameter kueri, badan permintaan, parameter jalur, cookie, header, dan fitur HTTP lainnya, menjadikannya alat komprehensif untuk membangun API web yang tangguh dan aman.

Instalasi

FastAPI tersedia sebagai paket di Python Package Index (PyPI), dan Anda dapat menginstalnya menggunakan pip.

$ pip install fastapi

FastAPI membutuhkan server ASGI (Web Server Gateway Interface) untuk berjalan. Uvicorn adalah salah satu server ASGI yang dapat Anda gunakan. Uvicorn adalah implementasi server ASGI yang sangat cepat, menggunakan uvloop dan httptools.

$ pip install uvicorn

Membuat Aplikasi FastAPI

Mendefinisikan Rute

Di FastAPI, rute adalah cara untuk mendefinisikan endpoint dalam aplikasi Anda. Endpoint adalah URL spesifik tempat API Anda dapat diakses. Di FastAPI, Anda mendefinisikan rute menggunakan fungsi Python, yang juga dikenal sebagai "operasi jalur" ("path operations").

Mari buat aplikasi FastAPI sederhana dengan satu rute. Buka editor kode pilihan Anda, buat file Python baru dengan nama main.py, dan tulis kode berikut:

from fastapi import FastAPI

app = FastAPI()

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

Pada kode di atas, kita pertama-tama mengimpor kelas FastAPI. Kita kemudian membuat instance dari kelas ini dan menugaskannya ke variabel app. Instance ini akan menjadi titik utama interaksi dengan API kita.

Kemudian kita mendefinisikan rute dengan dekorator @app.get("/"). Dekorator ini memberi tahu FastAPI bahwa fungsi di bawahnya harus dipanggil ketika permintaan GET dibuat ke URL root ("/"). Fungsi read_root() hanya mengembalikan respons JSON dengan teks "Hello, World".

Menjalankan Aplikasi

Dengan rute pertama Anda sudah didefinisikan, Anda sekarang dapat menjalankan aplikasi FastAPI Anda. Untuk melakukannya, buka terminal atau command prompt Anda, arahkan ke direktori yang berisi file main.py, dan ketik:

$ uvicorn main:app --reload

Di sini, main:app memberi tahu Uvicorn untuk mencari instance aplikasi dalam file main.py dengan nama app. Flag --reload mengaktifkan hot reloading, yang berarti server akan secara otomatis diperbarui setiap kali Anda membuat perubahan pada kode Anda.

Setelah Uvicorn berjalan, Anda dapat membuka browser web Anda dan arahkan ke http://localhost:8000/. Anda seharusnya melihat respons JSON dari fungsi read_root(): {"Hello": "World"}.

Penanganan Data di FastAPI

Pada bab ini, saya akan melihat lebih dekat bagaimana FastAPI menangani data dalam bentuk badan permintaan, parameter kueri, dan parameter jalur.

Badan Permintaan

Di FastAPI, Anda dapat membaca badan permintaan metode HTTP (seperti POST dan PUT) menggunakan model Pydantic. Model Pydantic memungkinkan Anda mendefinisikan struktur data dan secara otomatis menangani validasi, serialisasi, dan dokumentasi.

Mari kita lihat contoh. Pertama, tentukan model Pydantic:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    quantity: int

Di sini, name, price, dan quantity adalah bidang yang wajib, sedangkan description adalah bidang opsional.

Selanjutnya, gunakan model ini dalam sebuah rute:

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

Pada rute ini, FastAPI akan mengharapkan objek JSON dalam badan permintaan yang sesuai dengan struktur model Item. FastAPI akan secara otomatis memvalidasi data, mengubahnya menjadi model Pydantic, dan menyertakannya dalam fungsi rute Anda.

Seorang klien dapat mengirimkan permintaan POST ke rute ini dengan objek JSON dalam badan permintaan. Berikut adalah contoh menggunakan perintah curl:

$ curl -X POST "http://localhost:8000/items/" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"name\":\"Foo\",\"price\":50.5,\"quantity\":10}"

Parameter Kueri

Parameter kueri adalah bagian dari URL yang terletak setelah tanda tanya (?) dan biasanya digunakan untuk mengurutkan/menyaring konten. FastAPI membuat penanganan parameter kueri sangat mudah.

Mari tambahkan rute yang menerima parameter kueri:

@app.get("/items/")
def read_items(skip: int = 0, limit: int = 10):
    return items[skip : skip + limit]

Pada contoh ini, skip dan limit adalah parameter kueri opsional dengan nilai default 0 dan 10, secara berturut-turut.

Seorang klien dapat mengirimkan permintaan GET ke rute ini dengan parameter kueri dalam URL. Berikut adalah contoh menggunakan perintah curl:

$ curl -X GET "http://localhost:8000/items/?skip=20&limit=10" -H "accept: application/json"

Parameter Jalur

Parameter jalur, juga dikenal sebagai variabel jalur, adalah variabel yang merupakan bagian dari jalur URL. Mereka dapat didefinisikan sebagai argumen fungsi.

Berikut adalah cara menggunakan parameter jalur di FastAPI:

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Pada rute ini, item_id adalah parameter jalur yang akan diekstraksi oleh FastAPI dari URL dan diteruskan ke fungsi rute Anda sebagai argumen.

Seorang klien dapat mengirimkan permintaan GET ke rute ini dengan ID item dalam jalur URL. Berikut adalah contoh menggunakan perintah curl:

$ curl -X GET "http://localhost:8000/items/5" -H "accept: application/json"

Referensi

https://fastapi.tiangolo.com/