Bangun Aplikasi Dengan FastAPI untuk Python

FastAPI adalah kerangka kerja web yang cepat dan ringan untuk membangun antarmuka pemrograman aplikasi modern menggunakan Python 3.6 ke atas. Dalam tutorial ini, kita akan membahas dasar-dasar membangun aplikasi dengan FastAPI, dan Anda akan mengetahui mengapa FastAPI dinominasikan sebagai salah satu framework open-source terbaik tahun 2021.

Setelah Anda siap untuk mengembangkan aplikasi FastAPI Anda sendiri, Anda tidak perlu mencari jauh-jauh untuk menemukan tempat untuk menampungnya. Layanan Hosting Aplikasi dan Hosting Basis Data Kinsta menyediakan Platform sebagai Layanan yang kuat di Python.

Mari kita pelajari dasar-dasarnya terlebih dahulu.

Keuntungan dari FastAPI

Di bawah ini adalah beberapa keuntungan yang dibawa oleh kerangka kerja FastAPI ke sebuah proyek.

• Kecepatan: Seperti namanya, FastAPI adalah kerangka kerja yang sangat cepat. Kecepatannya sebanding dengan Go dan Node.js, yang umumnya dianggap sebagai opsi tercepat untuk membuat API.
• Mudah dipelajari dan dikodekan: FastAPI telah menemukan hampir semua yang Anda perlukan untuk membuat API siap produksi. Sebagai pengembang yang menggunakan FastAPI, Anda tidak perlu membuat kode semuanya dari awal. Dengan hanya beberapa baris kode, Anda dapat menyiapkan RESTful API untuk diterapkan.
• Dokumentasi komprehensif: FastAPI menggunakan standar dokumentasi OpenAPI, sehingga dokumentasi dapat dihasilkan secara dinamis. Dokumentasi ini memberikan informasi mendetail tentang titik akhir, respons, parameter, dan kode pengembalian FastAPI.
• API dengan lebih sedikit bug: FastAPI mendukung validasi data khusus, yang memungkinkan pengembang membuat API dengan lebih sedikit bug. Pengembang FastAPI menyombongkan diri bahwa kerangka kerjanya menghasilkan lebih sedikit bug yang disebabkan oleh manusia — sebanyak 40% lebih sedikit.
• Ketik petunjuk: Modul jenis diperkenalkan di Python 3.5. Ini memungkinkan Anda untuk mendeklarasikan type variabel. Saat tipe variabel dideklarasikan, IDE mampu memberikan dukungan yang lebih baik dan memprediksi kesalahan dengan lebih akurat.

Cara Memulai Dengan FastAPI

Untuk mengikuti tutorial ini dan memulai dengan FastAPI, Anda perlu melakukan beberapa hal terlebih dahulu.

Pastikan Anda memiliki editor teks/IDE programmer, seperti Visual Studio Code. Pilihan lainnya termasuk Sublime Text dan Espresso.

Merupakan praktik umum untuk membuat aplikasi Python Anda dan instansnya berjalan di lingkungan virtual. Lingkungan virtual memungkinkan kumpulan paket dan konfigurasi yang berbeda untuk berjalan secara bersamaan, dan menghindari konflik karena versi paket yang tidak kompatibel.

Untuk membuat lingkungan virtual, buka terminal Anda dan jalankan perintah ini:

 $ python3 -m venv env

Anda juga harus mengaktifkan lingkungan virtual. Perintah untuk melakukannya akan bervariasi tergantung pada sistem operasi dan shell yang Anda gunakan. Berikut adalah beberapa contoh aktivasi CLI untuk sejumlah lingkungan:

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Beberapa IDE yang sadar Python juga dapat dikonfigurasi untuk mengaktifkan lingkungan virtual saat ini.)

Sekarang, instal FastAPI:

 $ pip3 install fastapi

FastAPI adalah kerangka kerja untuk membuat API, tetapi untuk menguji API Anda, Anda memerlukan server web lokal. Uvicorn adalah server web Asynchronous Server Gateway Interface (ASGI) secepat kilat untuk Python yang bagus untuk pengembangan. Untuk menginstal Uvicorn, jalankan perintah ini:

 $ pip3 install "uvicorn[standard]"

Setelah instalasi berhasil, buat file bernama main.py di dalam direktori kerja proyek Anda. File ini akan menjadi titik masuk aplikasi Anda.

Contoh API Cepat Cepat

Anda akan menguji penginstalan FastAPI Anda dengan menyiapkan titik akhir contoh dengan cepat. Di file main.py Anda, rekatkan kode berikut, lalu simpan file:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

Cuplikan di atas membuat titik akhir FastAPI dasar. Di bawah ini adalah ringkasan dari apa yang dilakukan setiap baris:

• from fastapi import FastAPI : Fungsi untuk API Anda disediakan oleh kelas FastAPI Python.
• app = FastAPI() : Ini membuat instance FastAPI.
• @app.get("/") : Ini adalah dekorator python yang menentukan FastAPI bahwa fungsi di bawahnya bertanggung jawab atas penanganan permintaan.
• @app.get("/") : Ini adalah dekorator yang menentukan rute. Ini menciptakan metode GET pada rute situs. Hasilnya kemudian dikembalikan oleh fungsi yang dibungkus.
• Kemungkinan operasi lain yang digunakan untuk berkomunikasi termasuk @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() , dan @app.trace() .

Di direktori files, jalankan perintah berikut di terminal Anda untuk memulai server API:

 $ uvicorn main:app --reload

Dalam perintah ini, main adalah nama modul Anda. Objek app adalah turunan dari aplikasi Anda, dan diimpor ke server ASGI. Bendera --reload memberi tahu server untuk memuat ulang secara otomatis saat Anda melakukan perubahan.

Anda akan melihat sesuatu seperti ini di terminal Anda:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

Di browser Anda, navigasikan ke http://localhost:8000 untuk mengonfirmasi bahwa API Anda berfungsi. Anda akan melihat "Halo": "Dunia" sebagai objek JSON di halaman. Ini menggambarkan betapa mudahnya membuat API dengan FastAPI. Yang harus Anda lakukan hanyalah menentukan rute dan mengembalikan kamus Python Anda, seperti yang terlihat pada baris enam cuplikan di atas.

Menggunakan Petunjuk Jenis

Jika Anda menggunakan Python, Anda terbiasa menganotasi variabel dengan tipe data dasar seperti int , str , float , dan bool . Namun, dari Python versi 3.9, struktur data lanjutan diperkenalkan. Hal ini memungkinkan Anda untuk bekerja dengan struktur data seperti dictionaries , tuples , dan lists . Dengan petunjuk tipe FastAPI, Anda dapat menyusun skema data Anda menggunakan model pydantic dan kemudian, menggunakan model pydantic untuk mengetikkan petunjuk dan mendapat manfaat dari validasi data yang disediakan.

Pada contoh di bawah ini, penggunaan petunjuk tipe di Python didemonstrasikan dengan kalkulator harga makanan sederhana, calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Perhatikan bahwa petunjuk jenis tidak mengubah cara kode Anda berjalan.

Dokumentasi API Interaktif FastAPI

FastAPI menggunakan Swagger UI untuk menyediakan dokumentasi API interaktif otomatis. Untuk mengaksesnya, navigasikan ke http://localhost:8000/docs dan Anda akan melihat layar dengan semua titik akhir, metode, dan skema Anda.

Dokumentasi API otomatis berbasis browser ini disediakan oleh FastAPI, dan Anda tidak perlu melakukan apa pun untuk memanfaatkannya.

Dokumentasi API berbasis browser alternatif, juga disediakan oleh FastAPI, adalah Redoc. Untuk mengakses Redoc, navigasikan ke http://localhost:8000/redoc , di mana Anda akan disajikan daftar titik akhir, metode, dan responsnya masing-masing.

Menyiapkan Rute di FastAPI

Dekorator @app memungkinkan Anda menentukan metode rute, seperti @app.get atau @app.post , dan mendukung GET , POST , PUT , dan DELETE , serta opsi yang kurang umum, HEAD , PATCH , dan TRACE .

Membangun Aplikasi Anda Dengan FastAPI

Dalam tutorial ini, Anda akan dipandu untuk membangun aplikasi CRUD dengan FastAPI. Aplikasi ini akan dapat:

• Buat pengguna
• Membaca catatan basis data pengguna
• Perbarui pengguna yang ada
• Hapus pengguna tertentu

Untuk menjalankan operasi CRUD ini, Anda akan membuat metode yang memaparkan titik akhir API. Hasilnya adalah database dalam memori yang dapat menyimpan daftar pengguna.

Anda akan menggunakan perpustakaan pydantic untuk melakukan validasi data dan manajemen pengaturan menggunakan anotasi tipe Python. Untuk keperluan tutorial ini, Anda akan mendeklarasikan bentuk data Anda sebagai kelas dengan atribut.

Tutorial ini akan menggunakan database dalam memori. Ini untuk membantu Anda memulai dengan cepat menggunakan FastAPI untuk membangun API Anda. Namun, untuk produksi, Anda dapat menggunakan database apa pun yang Anda pilih, seperti PostgreSQL, MySQL, SQLite, atau bahkan Oracle.

Membangun Aplikasi

Anda akan mulai dengan membuat model pengguna Anda. Model pengguna akan memiliki atribut berikut:

• id : Pengidentifikasi Unik Universal (UUID)
• first_name : Nama depan pengguna
• last_name : Nama belakang pengguna
• gender : Jenis kelamin pengguna
• roles , yang merupakan daftar yang berisi peran admin dan user

Mulailah dengan membuat file baru bernama models.py di direktori kerja Anda, lalu tempelkan kode berikut ke models.py untuk membuat model Anda:

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

Dalam kode di atas:

• Kelas User Anda memperluas BaseModel , yang kemudian diimpor dari pydantic .
• Anda mendefinisikan atribut pengguna, seperti yang dibahas di atas.

Langkah selanjutnya adalah membuat database Anda. Ganti konten file main.py Anda dengan kode berikut:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

Di main.py :

• Anda menginisialisasi db dengan tipe List , dan meneruskan model User
• Anda membuat database dalam memori dengan empat pengguna, masing-masing dengan atribut yang diperlukan seperti first_name , last_name , gender , dan roles . Pengguna Eunit diberi peran admin dan user , sedangkan tiga pengguna lainnya hanya diberi peran user .

Baca Catatan Basis Data

Anda telah berhasil menyiapkan database dalam memori dan mengisinya dengan pengguna, jadi langkah selanjutnya adalah menyiapkan titik akhir yang akan mengembalikan daftar semua pengguna. Di sinilah FastAPI masuk.

Di file main.py Anda, rekatkan kode berikut tepat di bawah titik akhir Hello World Anda:

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Kode ini mendefinisikan titik akhir /api/v1/users , dan membuat fungsi async, get_users , yang mengembalikan semua konten database, db .

Simpan file Anda, dan Anda dapat menguji titik akhir pengguna Anda. Jalankan perintah berikut di terminal Anda untuk memulai server API:

 $ uvicorn main:app --reload

Di browser Anda, navigasikan ke http://localhost:8000/api/v1/users . Ini harus mengembalikan daftar semua pengguna Anda, seperti yang terlihat di bawah ini:

Pada tahap ini, file main.py Anda akan terlihat seperti ini:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Buat Catatan Database

Langkah selanjutnya adalah membuat titik akhir untuk membuat pengguna baru di database Anda. Rekatkan cuplikan berikut ke file main.py Anda:

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

Dalam cuplikan ini, Anda menentukan titik akhir untuk mengirimkan pengguna baru dan menggunakan dekorator @app.post untuk membuat metode POST .

Anda juga membuat fungsi create_user , yang menerima user dari model User , dan menambahkan (menambahkan) user yang baru dibuat ke database, db . Terakhir, titik akhir mengembalikan objek JSON dari id pengguna yang baru dibuat.

Anda harus menggunakan dokumentasi API otomatis yang disediakan oleh FastAPI untuk menguji titik akhir Anda, seperti yang terlihat di atas. Ini karena Anda tidak dapat membuat permintaan posting menggunakan browser web. Arahkan ke http://localhost:8000/docs untuk menguji menggunakan dokumentasi yang disediakan oleh SwaggerUI.

Hapus Catatan Basis Data

Karena Anda membuat aplikasi CRUD, aplikasi Anda harus memiliki kemampuan untuk menghapus sumber daya tertentu. Untuk tutorial ini, Anda akan membuat titik akhir untuk menghapus pengguna.

Rekatkan kode berikut ke file main.py Anda:

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

Berikut rincian baris demi baris tentang cara kerja kode tersebut:

• @app.delete("/api/v1/users/{id}") : Anda membuat titik akhir hapus menggunakan dekorator @app.delete() . Jalurnya masih /api/v1/users/{id} , tetapi kemudian ia mengambil id , yang merupakan variabel jalur yang sesuai dengan id pengguna.
• async def delete_user(id: UUID): : Membuat fungsi delete_user , yang mengambil id dari URL.
• for user in db: Ini memberi tahu aplikasi untuk mengulangi pengguna di database, dan memeriksa apakah id yang diteruskan cocok dengan pengguna di database.
• db.remove(user) : Jika id cocok dengan pengguna, pengguna akan dihapus; jika tidak, HTTPException dengan kode status 404 akan dimunculkan.

Perbarui Catatan Database

Anda akan membuat titik akhir untuk memperbarui detail pengguna. Detail yang dapat diperbarui mencakup parameter berikut: first_name , last_name , dan roles .

Di file models.py Anda, rekatkan kode berikut di bawah model User Anda, yaitu setelah kelas User(BaseModel): :

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

Dalam cuplikan ini, kelas UpdateUser memperluas BaseModel . Anda kemudian menyetel parameter pengguna yang dapat diperbarui, seperti first_name , last_name , dan roles , menjadi opsional.

Sekarang Anda akan membuat titik akhir untuk memperbarui detail pengguna tertentu. Di file main.py Anda, rekatkan kode berikut setelah dekorator @app.delete :

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

Pada kode di atas, Anda telah melakukan hal berikut:

• Dibuat @app.put("/api/v1/users/{id}") , titik akhir pembaruan. Ini memiliki id parameter variabel yang sesuai dengan id pengguna.
• Membuat metode yang disebut update_user , yang menggunakan kelas UpdateUser dan id .
• Menggunakan loop for untuk memeriksa apakah pengguna yang terkait dengan id yang diteruskan ada di database.
• Diperiksa apakah salah satu parameter pengguna is not None (bukan nol). Jika ada parameter, seperti first_name , last_name , atau roles , bukan null, maka parameter tersebut akan diperbarui.
• Jika operasi berhasil, id pengguna dikembalikan.
• Jika pengguna tidak ditemukan, pengecualian HTTPException dengan kode status 404 dan pesan Could not find user with id: {id} dimunculkan.

Untuk menguji titik akhir ini, pastikan server Uvicorn Anda berjalan. Jika tidak berjalan, masukkan perintah ini:

 uvicorn main:app --reload

Di bawah ini adalah tangkapan layar dari tes tersebut.

Lihat bagaimana FastAPI dapat menurunkan bug yang disebabkan oleh manusia hingga 40 persen. Mulailah di sini: Klik untuk menge-Tweet

Ringkasan

Dalam tutorial ini, Anda telah belajar tentang kerangka kerja FastAPI untuk Python dan melihat sendiri seberapa cepat Anda bisa mengaktifkan dan menjalankan aplikasi yang didukung FastAPI. Anda telah mempelajari cara membuat titik akhir CRUD API menggunakan kerangka kerja — membuat, membaca, memperbarui, dan menghapus record database.

Sekarang, jika Anda ingin meningkatkan pengembangan aplikasi web Anda, pastikan untuk memeriksa platform Kinsta untuk Hosting Aplikasi dan Hosting Basis Data. Seperti FastAPI, ini sangat sederhana.