Cara Menggunakan FastAPI untuk Membangun Layanan API Berkinerja Tinggi

FastAPI adalah kerangka kerja web modern dan cepat (efisien) yang dirancang khusus untuk membangun API. Ini didasarkan pada petunjuk tipe Python dan mendukung pemrograman asinkron, memungkinkan pengembang untuk membangun layanan API berkinerja tinggi, tersedia tinggi, dan latensi rendah. Artikel ini akan menjelaskan secara rinci bagaimana menggunakan FastAPI untuk membangun layanan API berkinerja tinggi, kami akan menjelaskan langkah demi langkah untuk membantu Anda mewujudkan seluruh proses dari persiapan lingkungan hingga penerapan.

Langkah Pertama: Persiapan Lingkungan

Anda perlu memastikan bahwa lingkungan pengembangan Anda telah menginstal Python 3.6+. Jika belum menginstal, Anda dapat mengunjungi Situs Resmi Python untuk mengunduh dan menginstalnya.

Instal FastAPI dan Uvicorn

FastAPI sendiri tidak menyediakan layanan, memerlukan server ASGI untuk menampungnya. Di sini kami menggunakan Uvicorn, server ASGI berkinerja tinggi. Anda dapat menggunakan perintah berikut untuk menginstal FastAPI dan Uvicorn:

pip install fastapi uvicorn

Langkah Kedua: Membangun API Dasar

Mari kita buat aplikasi FastAPI sederhana.

Membuat File Aplikasi

Di direktori proyek Anda, buat file Python, misalnya main.py, lalu tulis kode berikut di dalamnya:

from fastapi import FastAPI

app = FastAPI()

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

Dalam kode di atas, kami pertama-tama mengimpor FastAPI dan membuat instance app. Kemudian, kami mendefinisikan rute GET yang mengembalikan respons JSON sederhana saat mengakses jalur akar /.

Menjalankan Server

Jalankan server FastAPI Anda dengan perintah berikut:

uvicorn main:app --reload

main: merujuk pada nama file, tanpa akhiran .py.
app: merujuk pada instance FastAPI.
--reload: dalam mode pengembangan, server akan otomatis restart saat file diubah.

Langkah Ketiga: Mendefinisikan Rute dan Model Data

Untuk membangun API yang kompleks, Anda perlu menggunakan Pydantic untuk mendefinisikan model data.

Membuat Model Data

Tambahkan konten berikut di main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Kode ini menggunakan Pydantic untuk membuat model data Item, yang mencakup tiga atribut: nama produk, harga, dan ketersediaan.

Menambahkan Rute Baru

Selanjutnya, kita dapat mendefinisikan rute POST baru untuk menerima data tipe Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

Dalam rute ini, FastAPI akan secara otomatis memvalidasi data yang masuk dan memetakan ke model Item.

Langkah Keempat: Dokumentasi Otomatis

Salah satu keuntungan terbesar FastAPI adalah dapat secara otomatis menghasilkan dokumentasi API. Anda dapat melihatnya dengan mengunjungi alamat berikut:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

Dalam dokumentasi yang dihasilkan ini, Anda dapat menguji API secara interaktif, melihat format permintaan dan respons untuk setiap rute.

Langkah Kelima: Menambahkan Autentikasi

Dalam aplikasi nyata, autentikasi adalah langkah penting. Mari kita tambahkan autentikasi berbasis peran yang sederhana.

Menambahkan Dependensi Keamanan

Gunakan metode Depends FastAPI dan OAuth2PasswordBearer untuk mengimplementasikan autentikasi:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
    return user

Melindungi Rute

Kemudian, Anda dapat menambahkan autentikasi ke rute yang perlu dilindungi:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Langkah Keenam: Menerapkan Aplikasi FastAPI

Setelah Anda menyelesaikan pengembangan, Anda mungkin perlu menerapkan aplikasi ke server cloud. Anda dapat memilih untuk menggunakan Docker untuk penerapan.

Membuat Dockerfile

Buat file bernama Dockerfile di direktori proyek, masukkan konten berikut:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Membangun Gambar Docker

Di terminal Anda, gunakan perintah berikut untuk membangun gambar Docker:

docker build -t myfastapiapp .

Menjalankan Kontainer Docker

Jalankan aplikasi FastAPI Anda:

docker run -d --name fastapi -p 80:80 myfastapiapp

Kesimpulan

Dalam artikel ini, kami telah menjelaskan secara rinci bagaimana menggunakan FastAPI untuk membangun layanan API berkinerja tinggi, dari persiapan lingkungan hingga membuat API dasar, mendefinisikan rute dan model data, hingga menambahkan autentikasi dan penerapan. FastAPI menyediakan banyak fitur kuat yang membuat pembangunan API modern menjadi sederhana dan efisien, Anda dapat menjelajahi lebih banyak fitur dan karakteristik melalui dokumentasi resmi. Semoga artikel ini dapat membantu Anda lebih cepat memahami FastAPI dan secara efektif meningkatkan efisiensi pengembangan proyek Anda!