Tutorial FastAPI: Pengantar Menggunakan FastAPI

API (Application Programming Interface) adalah tulang punggung arsitektur modern karena memungkinkan aplikasi bersifat modular dan terlepas. Artinya, Anda dapat membangun aplikasi dengan cepat dan mudah, sehingga lebih mudah dirawat dan diperbarui. 

API juga sangat penting dalam machine learning karena memungkinkan berbagai aplikasi berbagi data dan bekerja sama, menghemat waktu dan tenaga. Ada banyak framework berbeda untuk membangun API di Python. Beberapa framework paling populer untuk membuat API di Python adalah Django, Flask, dan FastAPI. Tutorial ini membahas secara mendalam salah satu framework tersebut, yaitu FastAPI.

Jika Anda ingin mendalami topik ini, saya merekomendasikan kursus berikut: Deploying AI Into Production With FastAPI.

Apa itu API?

API adalah singkatan dari Application Programming Interface. API adalah perantara perangkat lunak yang memungkinkan dua aplikasi saling berkomunikasi. Saat Anda menggunakan aplikasi di ponsel, aplikasi tersebut terhubung ke Internet dan mengirim data ke server. Server kemudian memproses data dan mengirimkannya kembali ke ponsel Anda. Aplikasi di ponsel Anda lalu menafsirkan data tersebut dan menampilkannya kepada Anda dengan cara yang mudah dibaca. 

API ibarat pelayan di restoran. Pelayan mencatat pesanan Anda dan mengirimkannya ke dapur. Dapur kemudian menyiapkan makanan dan mengirimkannya kembali ke pelayan. Pelayan lalu menyajikan makanan kepada Anda. 

Dengan cara yang sama, API menerima permintaan dari sebuah aplikasi dan mengirimkannya ke server. Server kemudian memproses permintaan tersebut dan mengirimkan data kembali ke aplikasi. Aplikasi kemudian menafsirkan data itu dan menyajikannya kepada pengguna.

Sumber Gambar: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Jika Anda ingin mempelajari lebih lanjut tentang pipeline machine learning, API, dan MLOps, Anda dapat melihat Tutorial Machine Learning, Pipelines, Deployment, dan MLOps kami.

Apa itu FastAPI

FastAPI adalah web framework berkinerja tinggi untuk membangun API dengan Python 3.7+ berdasarkan type hints standar Python. Framework ini membantu pengembang membangun aplikasi dengan cepat dan efisien. FastAPI dibangun di atas server web Starlette dan mencakup fitur-fitur yang memudahkan pembuatan aplikasi web, seperti validasi data otomatis, penanganan error, dan dokumentasi API interaktif. 

Kita akan melihat semua fitur ini satu per satu di bagian ini. Pertama, mari kita lihat fitur-fitur kunci seperti yang dijelaskan dalam dokumentasi asli FastAPI.

• Kinerja: Sejajar dengan NodeJS dan bahasa Go.
• Kecepatan: Meningkatkan kecepatan pengembangan 2-3X.
• Mudah: Dukungan editor yang hebat. Pelengkapan di mana-mana. Mudah dipelajari dan digunakan.
• Tangguh: Kode siap produksi dengan dokumentasi interaktif otomatis.
• Berbasis OpenAPI: Sepenuhnya kompatibel dengan OpenAPI dan JSON Schema.

Memasang FastAPI

FastAPI memerlukan Python 3.7+. Dapat dipasang menggunakan pip. Anda perlu memasang FastAPI dan server ASGI `uvicorn`.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Buat API sederhana

Mari langsung membuat API mainan yang sangat sederhana. Saya menggunakan VS Code untuk menerapkannya, tetapi Anda dapat menggunakan editor apa pun yang Anda sukai.

```

from typing import Union

from fastapi import FastAPI




app = FastAPI()




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}

```

(Contoh diambil dari dokumentasi asli). Terima kasih kepada @tiangolo.

Sekarang gunakan terminal baris perintah, jalankan API ini dengan perintah berikut:

```

uvicorn main:app –reload

```

`main` adalah nama file Python, dan `app` adalah variabel yang menyimpan kelas FastAPI. Anda bisa menamainya sesuka Anda. Setelah menjalankan perintah di atas, Anda akan melihat sesuatu seperti ini di terminal:

Buka tautan tersebut di browser Anda, dan jika Anda melihat halaman yang menampilkan `Hello World,` berarti API sudah aktif dan berjalan.

Gambar oleh Penulis

Selamat atas pembuatan API pertama Anda. 

Dokumentasi API Interaktif

FastAPI menghasilkan "skema" dengan semua API Anda menggunakan standar OpenAPI untuk mendefinisikan API. "Skema" adalah definisi atau deskripsi tentang sesuatu. Bukan kode yang mengimplementasikannya, melainkan deskripsi abstrak. Skema OpenAPI adalah yang mendukung dua sistem dokumentasi interaktif yang disertakan dalam FastAPI.

Untuk melihat dokumentasi, cukup tambahkan `/docs` ke URL (`http://127.0.0.1:8000/docs`). Tautan ini akan menampilkan dokumentasi API interaktif otomatis.

Gambar oleh Penulis

Klik tombol `Try it out` di pojok kanan atas untuk menguji API.

Gambar oleh Penulis

Anda dapat melihat body respons berupa dictionary. Ini adalah nilai kembalian dari fungsi `read_item` yang didefinisikan di `main.py`. Anda juga dapat melihat URL permintaan `http://127.0.0.1:8000/items/1?q=orange`. `1` dan `orange` adalah masukan kita ke API.

Ada dokumentasi otomatis interaktif alternatif yang tersedia di FastAPI. Untuk mencobanya, buka http://127.0.0.1:8000/redoc`. Tampilannya seperti ini:

Gambar oleh Penulis

Contoh yang lebih lanjut

Saat membangun API, "path" mendefinisikan rute atau endpoint dari permintaan. Namun, ada satu pilihan lagi yang harus kita tentukan, yaitu “Operation.” Kata `operation` di sini merujuk pada salah satu "metode" HTTP. Dengan menggunakan satu (atau lebih) dari metode tersebut, Anda dapat berkomunikasi dengan setiap path yang didukung oleh protokol HTTP. Biasanya, Anda akan menggunakan:

• POST: untuk membuat data.
• GET: untuk membaca data.
• PUT: untuk memperbarui data.
• DELETE: untuk menghapus data.
• Dan beberapa metode lanjutan lainnya 

FastAPI mendukung semua metode HTTP tersebut. 

Fakta bahwa FastAPI dibangun di atas type hints Python adalah aspek kunci lainnya dari framework ini. Type hints didukung pada Python 3.6 dan yang lebih baru. Type hints adalah jenis sintaks khusus yang memungkinkan Anda mendeklarasikan tipe sebuah variabel. 

Mendeklarasikan tipe untuk variabel Anda memungkinkan editor dan alat lainnya memberi bantuan yang lebih baik. Mari kita lihat contoh lanjutan.

Kita akan memodifikasi file `main.py` untuk menyertakan permintaan `PUT` baru yang akan menerima beberapa masukan dengan tipe data berbeda. 

```

from typing import Union




from fastapi import FastAPI

from pydantic import BaseModel




app = FastAPI()




class Item(BaseModel):

    name: str

    price: float

    is_offer: Union[bool, None] = None




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}




@app.put("/items/{item_id}")

def update_item(item_id: int, item: Item):

    return {"item_name": item.name, "item_id": item_id}

```

(Contoh diambil dari dokumentasi asli). Terima kasih kepada @tiangolo.

Perubahannya:

Sebuah permintaan `put` ditambahkan yang menerima dua masukan. `item_id` adalah integer dan tipe `item` merujuk pada kelas kustom `Item` yang dibuat dan mewarisi `BaseModel` dari `pydantic`. Kelas `Item` berisi tiga atribut: `name`, `price`, `is_offer`, dan semuanya memiliki tipe data yang berbeda.

FastAPI akan memeriksa: 

• `name` adalah `str`.
• `price` adalah `float`.
• `is_offer` adalah bool, jika ada.

Keuntungan menggunakan type hints adalah Anda cukup sekali mendeklarasikan tipe parameter, body, dll. sebagai parameter fungsi dengan Python standar (3.6+). Anda akan mendapatkan:

• Dukungan editor, termasuk pelengkapan otomatis, pemeriksaan tipe
• Validasi data
• Konversi data masukan
• Konversi data keluaran
• Error yang mudah dipahami.

Perbandingan FastAPI dengan Django dan Flask

Ketiga framework ini adalah web framework Python yang dapat Anda gunakan untuk mengembangkan aplikasi web. Masing-masing memiliki kelebihan dan kekurangannya.

Django adalah framework lengkap yang mencakup semua yang Anda butuhkan untuk memulai, termasuk ORM bawaan dan panel admin. Bisa terasa sedikit rumit bagi pemula, tetapi dokumentasinya yang komprehensif membuatnya mudah dipelajari.

Flask adalah microframework yang ringan dan mudah untuk mulai digunakan. Tidak selengkap Django dalam hal fitur, tetapi sangat cocok untuk proyek sederhana.

FastAPI adalah framework baru yang dirancang cepat dan mudah digunakan. Ia mencakup fitur seperti validasi data otomatis dan dokumentasi. 

Benchmark Kinerja FastAPI

Menurut hasil pengujian yang dijalankan oleh techempower, FastAPI unggul dibanding framework lainnya dalam hal kinerja keseluruhan. 

Sumber: https://www.techempower.com/benchmarks/

Contoh: Membangun Pipeline machine learning end-to-end dengan PyCaret dan melakukan deployment dengan FastAPI 

Pada bagian ini, kita akan dengan cepat membangun pipeline machine learning lalu membuat API untuk menyajikan modelnya. Kita akan menggunakan library Python low-code PyCaret untuk membangun pipeline dan membuat API. PyCaret memiliki integrasi dengan FastAPI, yang membuat pembuatan dan penyajian model machine learning sebagai API menjadi sangat mudah.

PyCaret

PyCaret adalah library machine learning open-source dan low-code di Python yang mengotomatisasi alur kerja machine learning. Ini adalah alat end-to-end untuk machine learning dan manajemen model yang mempercepat siklus eksperimen secara eksponensial dan membuat Anda lebih produktif.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

Kita akan menggunakan dataset `insurance` dalam contoh ini. Ini adalah kasus regresi untuk memprediksi biaya medis berdasarkan usia, jenis kelamin, BMI, dan wilayah. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Gambar oleh Penulis

Selanjutnya kita akan menginisialisasi fungsi `setup` dari pycaret. Fungsi ini menginisialisasi eksperimen di PyCaret dan membuat pipeline transformasi berdasarkan semua parameter yang diberikan dalam fungsi. 

`setup` harus dieksekusi terlebih dahulu sebelum fungsi lainnya. Fungsi ini memerlukan dua parameter untuk bekerja yaitu `data` dan `target`. Semua argumen lainnya dalam `setup` bersifat opsional. Fungsi `setup` bertanggung jawab mengendalikan seluruh prosedur prapemrosesan data. Lihat dokumentasi PyCaret untuk rangkuman komprehensif semua prosedur prapemrosesan yang didukung di PyCaret.

```

from pycaret.regression import *

s = setup(data, target = 'charges')

```

Gambar oleh Penulis Keluaran dipangkas.

Setelah setup selesai, kita dapat mulai melatih dan memilih model hanya dengan satu baris kode: `compare_models`. Melalui cross-validation, fungsi ini melatih dan mengevaluasi kinerja model dari semua estimator dalam pustaka model. Hasil dari fungsi ini adalah grid penilaian yang berisi skor rata-rata yang diperoleh dari cross-validation.