Cara Menggunakan FastAPI untuk Membuat dan Menangani Permintaan POST

Jika Anda menyelami dunia pengembangan web modern, kemungkinan besar Anda pernah mendengar tentang FastAPI. Ini adalah salah satu kerangka kerja dengan pertumbuhan tercepat untuk membangun API di Python. Dalam postingan blog ini, kita akan menjelajahi cara menggunakan FastAPI untuk membuat dan menangani permintaan POST. Baik Anda seorang pengembang berpengalaman atau baru memulai, panduan ini akan membantu Anda memahami dasar-dasarnya dan lebih dari itu.

button

Apa itu FastAPI?

FastAPI adalah kerangka kerja web modern, cepat (berkinerja tinggi), untuk membangun API dengan Python 3.7+ berdasarkan petunjuk tipe Python standar. Dirancang agar mudah digunakan dan memberikan kinerja tinggi setara dengan Node.js dan Go. Kerangka kerja ini juga sangat intuitif dan mudah, menjadikannya pilihan yang sangat baik untuk pemula dan ahli.

Mengapa Menggunakan FastAPI?

Ada beberapa alasan mengapa pengembang memilih FastAPI daripada kerangka kerja lain:

Kecepatan: FastAPI cepat. Bahkan, ini adalah salah satu kerangka kerja web tercepat yang tersedia saat ini.
Kemudahan Penggunaan: Dengan dokumentasi interaktif otomatis (berkat Swagger UI dan ReDoc), sangat mudah untuk menguji API Anda.
Validasi Data: FastAPI memanfaatkan Pydantic untuk validasi data, yang memastikan bahwa data yang diterima API Anda valid.
Siap Async: Mendukung pemrograman asinkron secara langsung, sehingga cocok untuk aplikasi web modern dan berkinerja tinggi.

Menyiapkan FastAPI

Sebelum kita membahas permintaan POST, mari kita siapkan FastAPI dengan cepat. Anda perlu Python yang terinstal di sistem Anda. Kemudian, Anda dapat menginstal FastAPI dan server ASGI, seperti Uvicorn, menggunakan pip:

pip install fastapi uvicorn

Setelah Anda menginstal FastAPI, Anda dapat membuat aplikasi FastAPI sederhana. Mari kita mulai dengan membuat file bernama main.py:

from fastapi import FastAPI

app = FastAPI()

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

Untuk menjalankan aplikasi, gunakan Uvicorn:

uvicorn main:app --reload

Buka browser Anda dan navigasikan ke http://127.0.0.1:8000. Anda akan melihat respons JSON: {"Hello": "World"}.

Membuat Endpoint POST

Sekarang kita memiliki aplikasi FastAPI dasar yang berjalan, mari tambahkan endpoint POST. Permintaan POST digunakan untuk mengirimkan data untuk diproses ke sumber daya yang ditentukan. Untuk menangani permintaan POST di FastAPI, Anda menggunakan dekorator @app.post.

Berikut adalah contoh sederhana tentang cara menangani permintaan POST:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

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

Dalam contoh ini:

Kita mendefinisikan instance FastAPI.
Kita membuat model Pydantic Item yang menjelaskan struktur data dari badan permintaan.
Kita menggunakan dekorator @app.post untuk mendefinisikan endpoint POST /items/.
Fungsi create_item mengambil objek Item sebagai input dan mengembalikannya.

Untuk menguji ini, Anda dapat menggunakan klien API seperti apidog atau cukup gunakan Swagger UI interaktif yang disediakan oleh FastAPI di http://127.0.0.1:8000/docs.

Menangani Data dan Validasi

FastAPI secara otomatis memvalidasi data permintaan terhadap model Pydantic. Jika data tidak sesuai dengan model, FastAPI mengembalikan kode status 422 dengan detail tentang kesalahan validasi.

Misalnya, jika Anda mengirim permintaan POST ke /items/ dengan badan JSON berikut:

{
    "name": "Item name",
    "price": 25.5
}

FastAPI akan menerima permintaan ini karena memenuhi persyaratan model Item. Namun, jika Anda menghilangkan bidang price, FastAPI akan menolak permintaan dan mengembalikan kesalahan.

Menggunakan Apidog untuk Menguji Permintaan POST FastAPI Anda

Apidog adalah alat yang ampuh untuk menguji API. Ini memungkinkan Anda untuk membuat dan menyimpan permintaan API, mengaturnya ke dalam koleksi, dan membaginya dengan tim Anda.

button

Berikut adalah cara Anda dapat menggunakan Apidog untuk menguji permintaan POST Anda:

Buka Apidog dan buat permintaan baru.

2. Atur metode permintaan ke POST.

3. Masukkan URL sumber daya yang ingin Anda perbarui. Tambahkan header atau parameter tambahan yang ingin Anda sertakan, lalu klik tombol "Kirim" untuk mengirim permintaan.

4. Verifikasi bahwa responsnya sesuai dengan yang Anda harapkan.

Permintaan POST Tingkat Lanjut

Sekarang, mari kita jelajahi beberapa skenario yang lebih canggih. FastAPI memungkinkan Anda melakukan lebih banyak hal dengan permintaan POST. Misalnya, Anda dapat:

Menangani Unggahan File: Gunakan File dan UploadFile dari fastapi.
Memproses Data Formulir: Gunakan Form dari fastapi.
Menggunakan Parameter Jalur: Gabungkan path parameters dengan permintaan POST.

Menangani Unggahan File

Berikut adalah contoh menangani unggahan file dengan FastAPI:

from fastapi import FastAPI, File, UploadFile

app = FastAPI()

@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
    return {"filename": file.filename}

Endpoint ini akan menerima file dan mengembalikan nama file. Anda dapat menguji ini dengan apidog atau Swagger UI.

Memproses Data Formulir

Untuk memproses data formulir, gunakan kelas Form dari FastAPI:

from fastapi import FastAPI, Form

app = FastAPI()

@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

Contoh ini membuat endpoint login yang menerima data formulir. Anda dapat menguji ini menggunakan pengiriman formulir di browser Anda atau alat pengujian API.

Menggunakan Parameter Jalur

Anda juga dapat menggabungkan parameter jalur dengan permintaan POST:

from fastapi import FastAPI

app = FastAPI()

@app.post("/users/{user_id}/items/")
def create_item_for_user(user_id: int, item: Item):
    return {"user_id": user_id, "item": item}

Endpoint ini membuat item untuk pengguna tertentu, yang diidentifikasi oleh parameter jalur user_id.

Kesimpulan

FastAPI adalah kerangka kerja yang kuat yang memudahkan untuk membangun API yang kuat dengan Python. Dukungannya untuk validasi data, dokumentasi interaktif, dan kinerja tinggi menjadikannya pilihan yang sangat baik untuk pengembangan web modern.

Dalam postingan blog ini, kita telah membahas cara menyiapkan aplikasi FastAPI dan menangani permintaan POST. Kita juga telah menjelajahi topik yang lebih canggih seperti unggahan file, pemrosesan data formulir, dan menggabungkan parameter jalur dengan permintaan POST. Sekarang, Anda seharusnya memiliki pemahaman yang kuat tentang cara menggunakan FastAPI untuk membuat dan menangani permintaan POST.

Ingat, apakah Anda sedang membangun API sederhana atau aplikasi yang kompleks, FastAPI memiliki alat yang Anda butuhkan untuk berhasil. Selamat membuat kode!