Python selalu populer untuk mengembangkan aplikasi web ringan berkat kerangka kerja yang luar biasa seperti Flask, Django, Falcon dan banyak lagi. Karena posisi terdepan Python sebagai bahasa pembelajaran mesin, ini sangat berguna untuk model kemasan dan menyediakannya sebagai layanan.
Selama bertahun-tahun Flask telah menjadi alat utama untuk tugas-tugas semacam itu, tetapi jika Anda belum mendengarnya, pesaing baru telah muncul menggantikannya. FastAPI adalah kerangka kerja Python yang relatif baru yang terinspirasi oleh pendahulunya. Ini meningkatkan fungsionalitasnya dan memperbaiki banyak kekurangan. FastAPI dibangun di atas Starlette dan memiliki banyak fitur luar biasa.
Baru-baru ini, dia mendapatkan banyak popularitas, dan setelah 8 bulan terakhir saya bekerja dengannya setiap hari, saya dapat mengatakan dengan keyakinan bahwa semua hype di sekitarnya sepenuhnya dapat dibenarkan. Jika Anda belum mencobanya, saya telah mengumpulkan lima alasan mengapa Anda masih harus mengetahuinya.
Antarmuka sederhana yang bagus
Semua kerangka kerja dipaksa untuk menyeimbangkan antara fungsionalitas dan kebebasan untuk pengembang. Django kuat, tapi terlalu keras kepala. Flask, di sisi lain, levelnya cukup tinggi untuk memberikan kebebasan bertindak, tetapi banyak yang tersisa untuk pengguna. FastAPI lebih dekat dengan Flask dalam hal ini, tetapi berhasil mencapai keseimbangan yang lebih sehat.
Misalnya, mari kita lihat bagaimana FastAPI mendefinisikan titik akhir.
from fastapi import FastAPI
from pydantic import BaseModel
class User(BaseModel):
email: str
password: str
app = FastAPI()
@app.post("/login")
def login(user: User):
# ...
# do some magic
# ...
return {"msg": "login successful"}Untuk menentukan skema, digunakan Pydantic, yang merupakan pustaka Python yang sama mengagumkannya untuk validasi data. Terlihat cukup sederhana, tetapi ada banyak hal yang terjadi. Tanggung jawab untuk memvalidasi data masukan didelegasikan ke FastAPI. Jika permintaan yang salah dikirim, misalnya, bidang e-mail berisi nilai tipe
int, kode kesalahan yang sesuai akan dikembalikan, tetapi aplikasi tidak akan macet, menyebabkan Kesalahan Server Internal (500). Dan semuanya hampir gratis.
Aplikasi contoh sederhana dengan
uvicorn:
uvicorn main:appAplikasi sekarang dapat menerima permintaan. Dalam kasus ini, permintaannya akan terlihat seperti ini:
curl -X POST "http://localhost:8000/login" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"email\":\"string\",\"password\":\"string\"}"Lapisan gula pada kue akan menjadi pembuatan dokumentasi otomatis sesuai dengan OpenAPI menggunakan antarmuka interaktif Swagger.
Antarmuka kesombongan untuk aplikasi FastAPI
Asinkron
Salah satu kelemahan terbesar dari kerangka kerja web WSGI Python dibandingkan dengan rekan-rekan mereka di Node.js atau Go adalah ketidakmampuan untuk memproses permintaan secara asinkron. Sejak diperkenalkannya ASGI, hal ini tidak lagi menjadi masalah, dan FastAPI menerapkan kemampuan ini sepenuhnya. Yang harus Anda lakukan hanyalah mendeklarasikan titik akhir menggunakan kata kunci async seperti ini:
@app.post("/")
async def endpoint():
# ...
# call async functions here with `await`
# ...
return {"msg": "FastAPI is awesome!"}Injeksi ketergantungan
FastAPI memiliki cara yang sangat keren untuk mengelola dependensi. Meskipun developer tidak dipaksa untuk menggunakan injeksi tersemat untuk menangani dependensi pada endpoint, hal ini sangat disarankan.
Misalnya, mari buat titik akhir tempat pengguna dapat mengomentari artikel tertentu.
from fastapi import FastAPI, Depends
from pydantic import BaseModel
class Comment(BaseModel):
username: str
content: str
app = FastAPI()
database = {
"articles": {
1: {
"title": "Top 3 Reasons to Start Using FastAPI Now",
"comments": []
}
}
}
def get_database():
return database
@app.post("/articles/{article_id}/comments")
def post_comment(article_id: int, comment: Comment, database = Depends(get_database)):
database["articles"][article_id]["comments"].append(comment)
return {"msg": "comment posted!"}FastAPI get_database saat runtime saat memanggil endpoint, sehingga Anda dapat menggunakan nilai yang dikembalikan sesuai keinginan Anda. Ada (setidaknya) dua alasan bagus untuk ini.
- Anda dapat mengganti dependensi secara global dengan memodifikasi kamus
app.dependency_overrides. Ini akan membuat pengujian lebih mudah dan mengejek objek. - Ketergantungan (dalam kasus kami
get_database) dapat melakukan pemeriksaan yang lebih kompleks dan memungkinkan Anda untuk memisahkannya dari logika bisnis. Masalahnya sangat disederhanakan. Misalnya, agar Anda dapat dengan mudah menerapkan autentikasi pengguna.
Integrasi yang mudah dengan database
Apa pun yang Anda pilih, baik itu SQL, MongoDB, Redis, atau apa pun, FastAPI tidak akan memaksa Anda untuk membangun aplikasi di sekitar database. Jika Anda pernah bekerja dengan MongoDB melalui Django, Anda tahu betapa menyakitkan itu bisa. Dengan FastAPI, Anda tidak perlu melakukan pengait tambahan, karena menambahkan database ke tumpukan semudah mungkin. (Atau lebih tepatnya, jumlah pekerjaan akan ditentukan oleh database yang Anda pilih, bukan kerumitan yang muncul dengan menggunakan kerangka kerja tertentu.)
Serius, lihat keindahannya.
from fastapi import FastAPI, Depends
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
engine = create_engine("sqlite:///./database.db")
Session = sessionmaker(bind=engine)
def get_db():
return Session()
app = FastAPI()
@app.get("/")
def an_endpoint_using_sql(db = Depends(get_db)):
# ...
# do some SQLAlchemy
# ...
return {"msg": "an exceptionally successful operation!"}Voila! Saya sudah bisa melihat Anda mengetik
pip install fastapidi terminal pada komputer Anda.
Dukungan GraphQL
Saat Anda bekerja dengan model data yang kompleks, REST bisa menjadi rintangan utama. Tidak terlalu keren ketika perubahan sekecil apa pun di bagian depan memerlukan pembaruan skema titik akhir. Dalam kasus seperti itu, GraphQL menyelamatkan Anda. Meskipun dukungan GraphQL bukanlah hal baru bagi kerangka web Python, Graphene dan FastAPI bekerja sama dengan baik. Tidak perlu memasang tambahan apapun, misalnya
graphene_djangountuk Django, semuanya akan bekerja dari awal.
+1: Dokumentasi yang bagus
Tentu saja, kerangka kerja tidak bisa menjadi bagus jika memiliki dokumentasi yang buruk. Django, Flask, dan lainnya telah melakukannya dengan baik dalam hal ini, dan FastAPI tidak jauh di belakang. Tentu saja, karena dia jauh lebih muda, belum ada satu buku pun tentang dia, tapi ini hanya soal waktu.
Jika Anda ingin melihat FastAPI beraksi, saya punya panduan hebat untuk Anda. Saya telah menulis tutorial mendetail yang dapat digunakan untuk menerapkan model ML Anda ke Docker, Docker Compose, dan GitHub Actions!
Untuk meringkas, apakah Anda mencari kerangka kerja yang cepat dan ringan untuk bekerja dengan model pembelajaran mendalam Anda atau sesuatu yang lebih kompleks, FastAPI adalah pilihan Anda. Saya cukup yakin ini akan berhasil untuk Anda.