# FastAPI
FastAPI, framework performa tinggi, mudah dipelajari, cepat untuk coding, siap untuk pengembangan
---
**Dokumentasi**: https://fastapi.tiangolo.com
**Kode Sumber**: https://github.com/fastapi/fastapi
---
FastAPI adalah *framework* *web* moderen, cepat (performa-tinggi) untuk membangun API dengan Python berdasarkan tipe petunjuk Python.
Fitur utama FastAPI:
* **Cepat**: Performa sangat tinggi, setara **NodeJS** dan **Go** (berkat Starlette dan Pydantic). [Salah satu *framework* Python tercepat yang ada](#performa).
* **Cepat untuk coding**: Meningkatkan kecepatan pengembangan fitur dari 200% sampai 300%. *
* **Sedikit bug**: Mengurangi hingga 40% kesalahan dari manusia (pemrogram). *
* **Intuitif**: Dukungan editor hebat. Penyelesaian di mana pun. Lebih sedikit *debugging*.
* **Mudah**: Dibuat mudah digunakan dan dipelajari. Sedikit waktu membaca dokumentasi.
* **Ringkas**: Mengurasi duplikasi kode. Beragam fitur dari setiap deklarasi parameter. Lebih sedikit *bug*.
* **Handal**: Dapatkan kode siap-digunakan. Dengan dokumentasi otomatis interaktif.
* **Standar-resmi**: Berdasarkan (kompatibel dengan ) standar umum untuk API: OpenAPI (sebelumnya disebut Swagger) dan JSON Schema.
* estimasi berdasarkan pengujian tim internal pengembangan applikasi siap pakai.
## Sponsor
{% if sponsors %}
{% for sponsor in sponsors.gold -%}
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
{% endfor %}
{% endif %}
Sponsor lainnya
## Opini
"_[...] Saya banyak menggunakan **FastAPI** sekarang ini. [...] Saya berencana menggunakannya di semua tim servis ML Microsoft. Beberapa dari mereka sudah mengintegrasikan dengan produk inti *Windows** dan sebagian produk **Office**._"
Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
Jika anda mengembangkan app CLI yang digunakan di terminal bukan sebagai API web, kunjungi **Typer**.
**Typer** adalah saudara kecil FastAPI. Dan ditujukan sebagai **CLI FastAPI**. ⌨️ 🚀
## Prayarat
FastAPI berdiri di pundak raksasa:
* Starlette untuk bagian web.
* Pydantic untuk bagian data.
## Instalasi
Buat dan aktifkan virtual environment kemudian *install* FastAPI:
```console
$ pip install "fastapi[standard]"
---> 100%
```
**Catatan**: Pastikan anda menulis `"fastapi[standard]"` dengan tanda petik untuk memastikan bisa digunakan di semua *terminal*.
## Contoh
### Buat app
* Buat file `main.py` dengan:
```Python
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}
```
Atau gunakan async def...
Jika kode anda menggunakan `async` / `await`, gunakan `async def`:
```Python hl_lines="9 14"
from typing import Union
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
```
**Catatan**:
Jika anda tidak paham, kunjungi _"Panduan cepat"_ bagian `async` dan `await` di dokumentasi.
### Jalankan
Jalankan *server* dengan:
```console
$ fastapi dev main.py
╭────────── FastAPI CLI - Development mode ───────────╮
│ │
│ Serving at: http://127.0.0.1:8000 │
│ │
│ API docs: http://127.0.0.1:8000/docs │
│ │
│ Running in development mode, for production use: │
│ │
│ fastapi run │
│ │
╰─────────────────────────────────────────────────────╯
INFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [2248755] using WatchFiles
INFO: Started server process [2248757]
INFO: Waiting for application startup.
INFO: Application startup complete.
```
Mengenai perintah fastapi dev main.py...
Perintah `fastapi dev` membaca file `main.py`, memeriksa app **FastAPI** di dalamnya, dan menjalan server dengan Uvicorn.
Secara otomatis, `fastapi dev` akan mengaktifkan *auto-reload* untuk pengembangan lokal.
Informasi lebih lanjut kunjungi Dokumen FastAPI CLI.
### Periksa
Buka *browser* di http://127.0.0.1:8000/items/5?q=somequery.
Anda akan melihat respon JSON berikut:
```JSON
{"item_id": 5, "q": "somequery"}
```
Anda telah membuat API:
* Menerima permintaan HTTP di _path_ `/` dan `/items/{item_id}`.
* Kedua _paths_ menerima operasi `GET` (juga disebut _metode_ HTTP).
* _path_ `/items/{item_id}` memiliki _parameter path_ `item_id` yang harus berjenis `int`.
* _path_ `/items/{item_id}` memiliki _query parameter_ `q` berjenis `str`.
### Dokumentasi API interaktif
Sekarang kunjungi http://127.0.0.1:8000/docs.
Anda akan melihat dokumentasi API interaktif otomatis (dibuat oleh Swagger UI):
### Dokumentasi API alternatif
Kemudian kunjungi http://127.0.0.1:8000/redoc.
Anda akan melihat dokumentasi alternatif otomatis (dibuat oleh ReDoc):
## Contoh upgrade
Sekarang ubah `main.py` untuk menerima struktur permintaan `PUT`.
Deklarasikan struktur menggunakan tipe standar Python, berkat Pydantic.
```Python hl_lines="4 9-12 25-27"
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}
```
Server `fastapi dev` akan otomatis memuat kembali.
### Upgrade dokumentasi API interaktif
Kunjungi http://127.0.0.1:8000/docs.
* Dokumentasi API interaktif akan otomatis diperbarui, termasuk kode yang baru:
* Klik tombol "Try it out", anda dapat mengisi parameter dan langsung berinteraksi dengan API:
* Kemudian klik tombol "Execute", tampilan pengguna akan berkomunikasi dengan API, mengirim parameter, mendapatkan dan menampilkan hasil ke layar:
### Upgrade dokumentasi API alternatif
Kunjungi http://127.0.0.1:8000/redoc.
* Dokumentasi alternatif akan menampilkan parameter *query* dan struktur *request*:
### Ringkasan
Singkatnya, anda mendeklarasikan **sekali** jenis parameter, struktur, dll. sebagai parameter fungsi.
Anda melakukannya dengan tipe standar moderen Python.
Anda tidak perlu belajar sintaksis, metode, *classs* baru dari *library* tertentu, dll.
Cukup **Python** standar.
Sebagai contoh untuk `int`:
```Python
item_id: int
```
atau untuk model lebih rumit `Item`:
```Python
item: Item
```
...dengan sekali deklarasi anda mendapatkan:
* Dukungan editor, termasuk:
* Pelengkapan kode.
* Pengecekan tipe.
* Validasi data:
* Kesalahan otomatis dan jelas ketika data tidak sesuai.
* Validasi hingga untuk object JSON bercabang mendalam.
* Konversi input data: berasal dari jaringan ke data dan tipe Python. Membaca dari:
* JSON.
* Parameter path.
* Parameter query.
* Cookie.
* Header.
* Form.
* File.
* Konversi output data: konversi data Python ke tipe jaringan data (seperti JSON):
* Konversi tipe Python (`str`, `int`, `float`, `bool`, `list`, dll).
* Objek `datetime`.
* Objek `UUID`.
* Model database.
* ...dan banyak lagi.
* Dokumentasi interaktif otomatis, termasuk 2 alternatif tampilan pengguna:
* Swagger UI.
* ReDoc.
---
Kembali ke kode contoh sebelumnya, **FastAPI** akan:
* Validasi apakah terdapat `item_id` di *path* untuk permintaan `GET` dan `PUT` requests.
* Validasi apakah `item_id` berjenit `int` untuk permintaan `GET` dan `PUT`.
* Jika tidak, klien akan melihat pesan kesalahan jelas.
* Periksa jika ada parameter *query* opsional bernama `q` (seperti `http://127.0.0.1:8000/items/foo?q=somequery`) untuk permintaan `GET`.
* Karena parameter `q` dideklarasikan dengan `= None`, maka bersifat opsional.
* Tanpa `None` maka akan menjadi wajib ada (seperti struktur di kondisi dengan `PUT`).
* Untuk permintaan `PUT` `/items/{item_id}`, membaca struktur sebagai JSON:
* Memeriksa terdapat atribut wajib `name` harus berjenis `str`.
* Memeriksa terdapat atribut wajib`price` harus berjenis `float`.
* Memeriksa atribut opsional `is_offer`, harus berjenis `bool`, jika ada.
* Semua ini juga sama untuk objek json yang bersarang mendalam.
* Konversi dari dan ke JSON secara otomatis.
* Dokumentasi segalanya dengan OpenAPI, dengan menggunakan:
* Sistem dokumentasi interaktif.
* Sistem otomatis penghasil kode, untuk banyak bahasa.
* Menyediakan 2 tampilan dokumentasi web interaktif dengan langsung.
---
Kita baru menyentuh permukaannya saja, tetapi anda sudah mulai paham gambaran besar cara kerjanya.
Coba ubah baris:
```Python
return {"item_name": item.name, "item_id": item_id}
```
...dari:
```Python
... "item_name": item.name ...
```
...menjadi:
```Python
... "item_price": item.price ...
```
...anda akan melihat kode editor secara otomatis melengkapi atributnya dan tahu tipe nya:
Untuk contoh lengkap termasuk fitur lainnya, kunjungi Tutorial - Panduan Pengguna.
**Peringatan spoiler**: tutorial - panduan pengguna termasuk:
* Deklarasi **parameter** dari tempat berbeda seperti: **header**, **cookie**, **form field** and **file**.
* Bagaimana mengatur **batasan validasi** seperti `maximum_length`atau `regex`.
* Sistem **Dependency Injection** yang hebat dan mudah digunakan.
* Keamanan dan autentikasi, termasuk dukungan ke **OAuth2** dengan **JWT token** dan autentikasi **HTTP Basic**.
* Teknik lebih aju (tetapi mudah dipakai untuk deklarasi **model JSON bersarang ke dalam** (berkat Pydantic).
* Integrasi **GraphQL** dengan Strawberry dan library lainnya.
* Fitur lainnya (berkat Starlette) seperti:
* **WebSocket**
* Test yang sangat mudah berdasarkan HTTPX dan `pytest`
* **CORS**
* **Cookie Session**
* ...dan lainnya.
## Performa
Tolok ukur Independent TechEmpower mendapati aplikasi **FastAPI** berjalan menggunakan Uvicorn sebagai salah satu framework Python tercepat yang ada, hanya di bawah Starlette dan Uvicorn itu sendiri (digunakan di internal FastAPI). (*)
Penjelasan lebih lanjut, lihat bagian Tolok ukur.
## Dependensi
FastAPI bergantung pada Pydantic dan Starlette.
### Dependensi `standar`
Ketika anda meng-*install* FastAPI dengan `pip install "fastapi[standard]"`, maka FastAPI akan menggunakan sekumpulan dependensi opsional `standar`:
Digunakan oleh Pydantic:
* email-validator - untuk validasi email.
Digunakan oleh Starlette:
* httpx - Dibutuhkan jika anda menggunakan `TestClient`.
* jinja2 - Dibutuhkan jika anda menggunakan konfigurasi template bawaan.
* python-multipart - Dibutuhkan jika anda menggunakan form dukungan "parsing", dengan `request.form()`.
Digunakan oleh FastAPI / Starlette:
* uvicorn - untuk server yang memuat dan melayani aplikasi anda. Termasuk `uvicorn[standard]`, yang memasukan sejumlah dependensi (misal `uvloop`) untuk needed melayani dengan performa tinggi.
* `fastapi-cli` - untuk menyediakan perintah `fastapi`.
### Tanpda dependensi `standard`
Jika anda tidak ingin menambahkan dependensi opsional `standard`, anda dapat menggunakan `pip install fastapi` daripada `pip install "fastapi[standard]"`.
### Dependensi Opsional Tambahan
Ada beberapa dependensi opsional yang bisa anda install.
Dependensi opsional tambahan Pydantic:
* pydantic-settings - untuk manajemen setting.
* pydantic-extra-types - untuk tipe tambahan yang digunakan dengan Pydantic.
Dependensi tambahan opsional FastAPI:
* orjson - Diperlukan jika anda akan menggunakan`ORJSONResponse`.
* ujson - Diperlukan jika anda akan menggunakan `UJSONResponse`.
## Lisensi
Project terlisensi dengan lisensi MIT.