# FastAPI { #fastapi }
FastAPI framework, yüksek performanslı, öğrenmesi kolay, kodlaması hızlı, production'a hazır
---
**Dokümantasyon**: https://fastapi.tiangolo.com
**Kaynak Kod**: https://github.com/fastapi/fastapi
---
FastAPI, Python'un standart type hints'lerine dayalı olarak Python ile API'lar oluşturmak için kullanılan modern ve hızlı (yüksek performanslı) bir web framework'üdür.
Temel özellikleri şunlardır:
* **Hızlı**: Çok yüksek performanslı, **NodeJS** ve **Go** ile eşit düzeyde (Starlette ve Pydantic sayesinde). [Mevcut en hızlı Python framework'lerinden biri](#performance).
* **Kodlaması Hızlı**: Özellik geliştirme hızını yaklaşık %200 ile %300 aralığında artırır. *
* **Daha az hata**: İnsan (geliştirici) kaynaklı hataları yaklaşık %40 azaltır. *
* **Sezgisel**: Harika bir editör desteği. Her yerde Tamamlama. Hata ayıklamaya daha az zaman.
* **Kolay**: Kullanımı ve öğrenmesi kolay olacak şekilde tasarlandı. Doküman okumaya daha az zaman.
* **Kısa**: Kod tekrarını minimize eder. Her parametre tanımından birden fazla özellik. Daha az hata.
* **Sağlam**: Production'a hazır kod elde edersiniz. Otomatik etkileşimli dokümantasyon ile birlikte.
* **Standardlara dayalı**: API'lar için açık standartlara dayalıdır (ve tamamen uyumludur); OpenAPI (önceden Swagger olarak biliniyordu) ve JSON Schema.
* tahmin, production uygulamalar geliştiren dahili bir geliştirme ekibinin yaptığı testlere dayanmaktadır.
## Sponsorlar { #sponsors }
### Keystone Sponsor { #keystone-sponsor }
{% for sponsor in sponsors.keystone -%}
{% endfor -%}
### Gold and Silver Sponsors { #gold-and-silver-sponsors }
{% for sponsor in sponsors.gold -%}
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
{% endfor %}
Diğer sponsorlar
## Görüşler { #opinions }
"_[...] Bugünlerde **FastAPI**'ı çok fazla kullanıyorum. [...] Aslında bunu ekibimin **Microsoft'taki ML servislerinin** tamamında kullanmayı planlıyorum. Bunlardan bazıları ana **Windows** ürününe ve bazı **Office** ürünlerine entegre ediliyor._"
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)
## CLI'ların FastAPI'ı: **Typer** { #typer-the-fastapi-of-clis }
Web API yerine terminalde kullanılacak bir CLI uygulaması geliştiriyorsanız **Typer**'a göz atın.
**Typer**, FastAPI'ın küçük kardeşi. Ve hedefi CLI'ların **FastAPI'ı** olmak. ⌨️ 🚀
## Gereksinimler { #requirements }
FastAPI iki devin omuzları üstünde duruyor:
* Web kısımları için Starlette.
* Data kısımları için Pydantic.
## Kurulum { #installation }
Bir virtual environment oluşturup etkinleştirelim ve ardından FastAPI'ı yükleyelim:
```console
$ pip install "fastapi[standard]"
---> 100%
```
**Not**: Tüm terminallerde çalıştığından emin olmak için `"fastapi[standard]"` ifadesini tırnak içinde yazdığınızdan emin olun.
## Örnek { #example }
### Oluşturalım { #create-it }
Şu içerikle `main.py` adında bir dosya oluşturalım:
```Python
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: str | None = None):
return {"item_id": item_id, "q": q}
```
Ya da async def kullanalım...
Eğer kodunuz `async` / `await` kullanıyorsa, `async def` kullanın:
```Python hl_lines="7 12"
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: str | None = None):
return {"item_id": item_id, "q": q}
```
**Not**:
Eğer bilmiyorsanız, dokümanlardaki `async` ve `await` hakkında _"Aceleniz mi var?"_ bölümüne bakın.
### Çalıştıralım { #run-it }
Sunucuyu şu komutla çalıştıralım:
```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.
```
fastapi dev main.py komutu hakkında...
`fastapi dev` komutu, `main.py` dosyanızı okur, içindeki **FastAPI** uygulamasını algılar ve Uvicorn kullanarak bir server başlatır.
Varsayılan olarak `fastapi dev`, local geliştirme için auto-reload etkin şekilde başlar.
Daha fazla bilgi için FastAPI CLI dokümantasyonu'nu okuyabilirsiniz.
### Kontrol Edelim { #check-it }
Tarayıcınızda şu bağlantıyı açın: http://127.0.0.1:8000/items/5?q=somequery.
Şu JSON response'unu göreceksiniz:
```JSON
{"item_id": 5, "q": "somequery"}
```
Artık şunları yapan bir API oluşturdunuz:
* `/` ve `/items/{item_id}` _path_'lerinde HTTP request'leri alır.
* Her iki _path_ de `GET` operasyonlarını (HTTP _method_'ları olarak da bilinir) kabul eder.
* `/items/{item_id}` _path_'i, `int` olması gereken `item_id` adlı bir _path parameter_'a sahiptir.
* `/items/{item_id}` _path_'i, opsiyonel `str` bir _query parameter_ olan `q`'ya sahiptir.
### Etkileşimli API dokümantasyonu { #interactive-api-docs }
Şimdi http://127.0.0.1:8000/docs adresine gidin.
Otomatik etkileşimli API dokümantasyonunu göreceksiniz (Swagger UI tarafından sağlanır):
### Alternatif API dokümantasyonu { #alternative-api-docs }
Ve şimdi http://127.0.0.1:8000/redoc adresine gidin.
Alternatif otomatik dokümantasyonu göreceksiniz (ReDoc tarafından sağlanır):
## Örneği Güncelleyelim { #example-upgrade }
Şimdi `main.py` dosyasını, `PUT` request'iyle gelen bir body alacak şekilde değiştirelim.
Body'yi Pydantic sayesinde standart Python tiplerini kullanarak tanımlayalım.
```Python hl_lines="2 7-10 23-25"
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
price: float
is_offer: bool | None = None
@app.get("/")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: 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}
```
`fastapi dev` server'ı otomatik olarak yeniden yüklemelidir.
### Etkileşimli API dokümantasyonu güncellemesi { #interactive-api-docs-upgrade }
Şimdi http://127.0.0.1:8000/docs adresine gidin.
* Etkileşimli API dokümantasyonu, yeni body dahil olacak şekilde otomatik olarak güncellenecek:
* "Try it out" butonuna tıklayın; parametreleri doldurmanıza ve API ile doğrudan etkileşime girmenize olanak sağlar:
* Sonra "Execute" butonuna tıklayın; kullanıcı arayüzü API'nız ile iletişim kuracak, parametreleri gönderecek, sonuçları alacak ve ekranda gösterecek:
### Alternatif API dokümantasyonu güncellemesi { #alternative-api-docs-upgrade }
Ve şimdi http://127.0.0.1:8000/redoc adresine gidin.
* Alternatif dokümantasyon da yeni query parameter ve body'yi yansıtacak:
### Özet { #recap }
Özetle, parametrelerin, body'nin vb. type'larını fonksiyon parametreleri olarak **bir kere** tanımlarsınız.
Bunu standart modern Python tipleriyle yaparsınız.
Yeni bir syntax, belirli bir kütüphanenin method'larını ya da class'larını vb. öğrenmeniz gerekmez.
Sadece standart **Python**.
Örneğin bir `int` için:
```Python
item_id: int
```
ya da daha karmaşık bir `Item` modeli için:
```Python
item: Item
```
...ve bu tek tanımla şunları elde edersiniz:
* Şunlar dahil editör desteği:
* Completion.
* Type kontrolleri.
* Verinin doğrulanması:
* Veri geçersiz olduğunda otomatik ve anlaşılır hatalar.
* Çok derin iç içe JSON nesneleri için bile doğrulama.
* Girdi verisinin Dönüşümü: network'ten gelen veriyi Python verisine ve type'larına çevirir. Şunlardan okur:
* JSON.
* Path parameter'lar.
* Query parameter'lar.
* Cookie'ler.
* Header'lar.
* Form'lar.
* File'lar.
* Çıktı verisinin Dönüşümü: Python verisini ve type'larını network verisine çevirir (JSON olarak):
* Python type'larını dönüştürür (`str`, `int`, `float`, `bool`, `list`, vb.).
* `datetime` nesneleri.
* `UUID` nesneleri.
* Veritabanı modelleri.
* ...ve daha fazlası.
* 2 alternatif kullanıcı arayüzü dahil otomatik etkileşimli API dokümantasyonu:
* Swagger UI.
* ReDoc.
---
Önceki kod örneğine dönersek, **FastAPI** şunları yapacaktır:
* `GET` ve `PUT` request'leri için path'te `item_id` olduğunu doğrular.
* `GET` ve `PUT` request'leri için `item_id`'nin type'ının `int` olduğunu doğrular.
* Değilse, client faydalı ve anlaşılır bir hata görür.
* `GET` request'leri için `q` adlı opsiyonel bir query parameter olup olmadığını kontrol eder (`http://127.0.0.1:8000/items/foo?q=somequery` örneğindeki gibi).
* `q` parametresi `= None` ile tanımlandığı için opsiyoneldir.
* `None` olmasaydı zorunlu olurdu (tıpkı `PUT` örneğindeki body gibi).
* `/items/{item_id}`'ye yapılan `PUT` request'leri için body'yi JSON olarak okur:
* `str` olması gereken, zorunlu `name` alanı olduğunu kontrol eder.
* `float` olması gereken, zorunlu `price` alanı olduğunu kontrol eder.
* Varsa, `bool` olması gereken opsiyonel `is_offer` alanını kontrol eder.
* Bunların hepsi çok derin iç içe JSON nesneleri için de çalışır.
* JSON'a ve JSON'dan dönüşümü otomatik yapar.
* Her şeyi OpenAPI ile dokümante eder; bu dokümantasyon şunlar tarafından kullanılabilir:
* Etkileşimli dokümantasyon sistemleri.
* Birçok dil için otomatik client kodu üretim sistemleri.
* 2 etkileşimli dokümantasyon web arayüzünü doğrudan sunar.
---
Daha yolun başındayız, ama bunun nasıl çalıştığı hakkında fikri kaptınız.
Şu satırı değiştirmeyi deneyin:
```Python
return {"item_name": item.name, "item_id": item_id}
```
...şundan:
```Python
... "item_name": item.name ...
```
...şuna:
```Python
... "item_price": item.price ...
```
...ve editörünüzün alanları otomatik tamamladığını ve type'larını bildiğini görün:
Daha fazla özellik içeren daha kapsamlı bir örnek için Öğretici - Kullanıcı Rehberi'ne bakın.
**Spoiler alert**: öğretici - kullanıcı rehberi şunları içerir:
* **parameter**'ların farklı yerlerden: **header**'lar, **cookie**'ler, **form alanları** ve **file**'lar olarak tanımlanması.
* `maximum_length` ya da `regex` gibi **doğrulama kısıtlamalarının** nasıl ayarlanacağı.
* Çok güçlü ve kullanımı kolay bir **Bağımlılık Enjeksiyonu** sistemi.
* **JWT tokens** ve **HTTP Basic** auth ile **OAuth2** desteği dahil güvenlik ve kimlik doğrulama.
* **Çok derin iç içe JSON modelleri** tanımlamak için daha ileri (ama aynı derecede kolay) teknikler (Pydantic sayesinde).
* Strawberry ve diğer kütüphaneler ile **GraphQL** entegrasyonu.
* Starlette sayesinde gelen birçok ek özellik:
* **WebSockets**
* HTTPX ve `pytest` tabanlı aşırı kolay testler
* **CORS**
* **Cookie Sessions**
* ...ve daha fazlası.
### Uygulamanızı deploy edin (opsiyonel) { #deploy-your-app-optional }
İsterseniz FastAPI uygulamanızı FastAPI Cloud'a deploy edebilirsiniz; eğer henüz yapmadıysanız gidip bekleme listesine katılın. 🚀
Zaten bir **FastAPI Cloud** hesabınız varsa (bekleme listesinden sizi davet ettiysek 😉), uygulamanızı tek bir komutla deploy edebilirsiniz.
Deploy etmeden önce, giriş yaptığınızdan emin olun:
```console
$ fastapi login
You are logged in to FastAPI Cloud 🚀
```
Sonra uygulamanızı deploy edin:
```console
$ fastapi deploy
Deploying to FastAPI Cloud...
✅ Deployment successful!
🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
```
Hepsi bu! Artık uygulamanıza bu URL'den erişebilirsiniz. ✨
#### FastAPI Cloud hakkında { #about-fastapi-cloud }
**FastAPI Cloud**, **FastAPI**'ın arkasındaki aynı yazar ve ekip tarafından geliştirilmiştir.
**Bir API'ı build etmek**, **deploy etmek** ve **erişmek** süreçlerini minimum eforla kolaylaştırır.
FastAPI ile uygulama geliştirmenin sağladığı aynı **developer experience**'ı, onları cloud'a **deploy etmeye** de taşır. 🎉
FastAPI Cloud, *FastAPI and friends* open source projelerinin ana sponsoru ve finansman sağlayıcısıdır. ✨
#### Diğer cloud sağlayıcılarına deploy { #deploy-to-other-cloud-providers }
FastAPI open source'tur ve standartlara dayanır. FastAPI uygulamalarını seçtiğiniz herhangi bir cloud sağlayıcısına deploy edebilirsiniz.
FastAPI uygulamalarını onlarla deploy etmek için cloud sağlayıcınızın rehberlerini takip edin. 🤓
## Performans { #performance }
Bağımsız TechEmpower kıyaslamaları, Uvicorn altında çalışan **FastAPI** uygulamalarının mevcut en hızlı Python framework'lerinden biri olduğunu gösteriyor; sadece Starlette ve Uvicorn'un kendisinin gerisinde (FastAPI tarafından dahili olarak kullanılır). (*)
Daha iyi anlamak için Kıyaslamalar bölümüne bakın.
## Bağımlılıklar { #dependencies }
FastAPI, Pydantic ve Starlette'a bağımlıdır.
### `standard` Bağımlılıkları { #standard-dependencies }
FastAPI'ı `pip install "fastapi[standard]"` ile yüklediğinizde, opsiyonel bağımlılıkların `standard` grubuyla birlikte gelir:
Pydantic tarafından kullanılanlar:
* email-validator - email doğrulaması için.
Starlette tarafından kullanılanlar:
* httpx - `TestClient` kullanmak istiyorsanız gereklidir.
* jinja2 - varsayılan template yapılandırmasını kullanmak istiyorsanız gereklidir.
* python-multipart - `request.form()` ile, form "ayrıştırma" desteği istiyorsanız gereklidir.
FastAPI tarafından kullanılanlar:
* uvicorn - uygulamanızı yükleyen ve servis eden server için. Buna, yüksek performanslı servis için gereken bazı bağımlılıkları (örn. `uvloop`) içeren `uvicorn[standard]` dahildir.
* `fastapi-cli[standard]` - `fastapi` komutunu sağlamak için.
* Buna, FastAPI uygulamanızı FastAPI Cloud'a deploy etmenizi sağlayan `fastapi-cloud-cli` dahildir.
### `standard` Bağımlılıkları Olmadan { #without-standard-dependencies }
`standard` opsiyonel bağımlılıklarını dahil etmek istemiyorsanız, `pip install fastapi` ile kurabilirsiniz.
### `fastapi-cloud-cli` Olmadan { #without-fastapi-cloud-cli }
FastAPI'ı standard bağımlılıklarla ama `fastapi-cloud-cli` olmadan kurmak istiyorsanız, `pip install "fastapi[standard-no-fastapi-cloud-cli]"` ile yükleyebilirsiniz.
### Ek Opsiyonel Bağımlılıklar { #additional-optional-dependencies }
Yüklemek isteyebileceğiniz bazı ek bağımlılıklar da vardır.
Ek opsiyonel Pydantic bağımlılıkları:
* pydantic-settings - ayar yönetimi için.
* pydantic-extra-types - Pydantic ile kullanılacak ek type'lar için.
Ek opsiyonel FastAPI bağımlılıkları:
* orjson - `ORJSONResponse` kullanmak istiyorsanız gereklidir.
* ujson - `UJSONResponse` kullanmak istiyorsanız gereklidir.
## Lisans { #license }
Bu proje MIT lisansı şartları altında lisanslanmıştır.