Python için FastAPI ile Bir Uygulama Oluşturun

FastAPI, Python 3.6 ve üzerini kullanarak modern uygulama programlama arayüzleri oluşturmaya yönelik hızlı ve hafif bir web çerçevesidir. Bu eğitimde, FastAPI ile bir uygulama oluşturmanın temellerini ele alacağız ve bunun neden 2021'in en iyi açık kaynak çerçevelerinden biri olarak aday gösterildiğine dair bir fikir edineceksiniz.

Kendi FastAPI uygulamalarınızı geliştirmeye hazır olduğunuzda, bunları barındıracak bir yer bulmak için uzaklara bakmanıza gerek kalmayacak. Kinsta'nın Uygulama Barındırma ve Veritabanı Barındırma hizmetleri, Python'da güçlü bir Hizmet Olarak Platform sağlar.

Önce temelleri öğrenelim.

FastAPI'nin Avantajları

FastAPI çerçevesinin bir projeye getirdiği avantajlardan bazıları aşağıdadır.

• Hız: Adından da anlaşılacağı gibi, FastAPI çok hızlı bir çerçevedir. Hızı, genellikle API oluşturmak için en hızlı seçenekler arasında sayılan Go ve Node.js ile karşılaştırılabilir.
• Öğrenmesi ve kodlaması kolay: FastAPI, üretime hazır bir API yapmak için ihtiyaç duyacağınız hemen hemen her şeyi zaten bulmuştur. FastAPI kullanan bir geliştirici olarak her şeyi sıfırdan kodlamanız gerekmez. Yalnızca birkaç satır kodla dağıtıma hazır bir RESTful API'ye sahip olabilirsiniz.
• Kapsamlı dokümantasyon: FastAPI, OpenAPI dokümantasyon standartlarını kullanır, böylece dokümantasyon dinamik olarak oluşturulabilir. Bu belgeler, FastAPI'nin uç noktaları, yanıtları, parametreleri ve dönüş kodları hakkında ayrıntılı bilgi sağlar.
• Daha az hata içeren API'ler: FastAPI, geliştiricilerin daha az hata içeren API'ler oluşturmasına olanak tanıyan özel veri doğrulamayı destekler. FastAPI'nin geliştiricileri, çerçevenin insan kaynaklı daha az hatayla sonuçlanmasıyla övünür - %40'a kadar daha az.
• Tip ipuçları: type modülü Python 3.5'te tanıtıldı. Bu, bir değişkenin type bildirmenizi sağlar. Bir değişkenin türü bildirildiğinde, IDE'ler daha iyi destek sağlayabilir ve hataları daha doğru tahmin edebilir.

FastAPI'ye Nasıl Başlanır?

Bu öğreticiyi takip etmek ve FastAPI'yi kullanmaya başlamak için önce birkaç şey yapmanız gerekecek.

Visual Studio Code gibi bir programcının metin düzenleyicisine/IDE'sine sahip olduğunuzdan emin olun. Diğer seçenekler arasında Sublime Text ve Espresso bulunur.

Python uygulamalarınızın ve örneklerinin sanal ortamlarda çalıştırılması yaygın bir uygulamadır. Sanal ortamlar, farklı paket setlerinin ve konfigürasyonların aynı anda çalışmasına izin verir ve uyumsuz paket sürümlerinden kaynaklanan çakışmaları önler.

Sanal bir ortam oluşturmak için terminalinizi açın ve şu komutu çalıştırın:

 $ python3 -m venv env

Ayrıca sanal ortamı da etkinleştirmeniz gerekecek. Bunu yapma komutu, kullandığınız işletim sistemine ve kabuğa bağlı olarak değişir. Çeşitli ortamlar için bazı CLI etkinleştirme örnekleri aşağıda verilmiştir:

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Python uyumlu bazı IDE'ler ayrıca mevcut sanal ortamı etkinleştirecek şekilde yapılandırılabilir.)

Şimdi, FastAPI'yi kurun:

 $ pip3 install fastapi

FastAPI, API'ler oluşturmaya yönelik bir çerçevedir, ancak API'lerinizi test etmek için yerel bir web sunucusuna ihtiyacınız olacaktır. Uvicorn, geliştirme için harika olan, Python için yıldırım hızında Asenkron Sunucu Ağ Geçidi Arayüzü (ASGI) web sunucusudur. Uvicorn'u yüklemek için şu komutu çalıştırın:

 $ pip3 install "uvicorn[standard]"

Kurulum başarılı olduktan sonra, projenizin çalışma dizininde main.py adlı bir dosya oluşturun. Bu dosya uygulama giriş noktanız olacaktır.

Hızlı FastAPI Örneği

Örnek bir uç nokta kurarak FastAPI kurulumunuzu test edeceksiniz. main.py dosyanıza aşağıdaki kodu yapıştırın ve ardından dosyayı kaydedin:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

Yukarıdaki kod parçası, temel bir FastAPI uç noktası oluşturur. Aşağıda, her satırın ne yaptığının bir özeti verilmiştir:

• from fastapi import FastAPI : API'niz için işlevsellik, FastAPI Python sınıfı tarafından sağlanır.
• app = FastAPI() : Bu, bir FastAPI örneği oluşturur.
• @app.get("/") : Bu, FastAPI'ye altındaki işlevin istek işlemeden sorumlu olduğunu belirten bir python dekoratörüdür.
• @app.get("/") : Bu, rotayı belirten bir dekoratördür. Bu, sitenin rotasında bir GET yöntemi oluşturur. Sonuç daha sonra sarılmış işlev tarafından döndürülür.
• İletişim kurmak için kullanılan diğer olası işlemler arasında @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() . ve @app.trace() .

API sunucusunu başlatmak için dosyalar dizininde terminalinizde aşağıdaki komutu çalıştırın:

 $ uvicorn main:app --reload

Bu komutta main , modülünüzün adıdır. app nesnesi, uygulamanızın bir örneğidir ve ASGI sunucusuna aktarılır. --reload bayrağı, herhangi bir değişiklik yaptığınızda sunucuya otomatik olarak yeniden yüklenmesini söyler.

Terminalinizde böyle bir şey görmelisiniz:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

API'nizin çalıştığını doğrulamak için tarayıcınızda http://localhost:8000 gidin. Sayfada JSON nesnesi olarak “Hello”: “World” ifadesini görmelisiniz. Bu, FastAPI ile bir API oluşturmanın ne kadar kolay olduğunu gösterir. Tek yapmanız gereken, yukarıdaki pasajın altıncı satırında görüldüğü gibi bir rota tanımlamak ve Python sözlüğünüzü döndürmekti.

Yazım İpuçlarını Kullanma

Python kullanıyorsanız, int , str , float ve bool gibi temel veri türleriyle değişkenlere açıklama eklemeye alışkınsınız. Ancak, Python sürüm 3.9'dan itibaren gelişmiş veri yapıları tanıtıldı. Bu, dictionaries , tuples ve lists gibi veri yapılarıyla çalışmanıza olanak tanır. FastAPI'nin tip ipuçlarıyla, pydantic modelleri kullanarak verilerinizin şemasını yapılandırabilir ve ardından pydantic modelleri kullanarak tip ipucunu kullanabilir ve sağlanan veri doğrulamasından yararlanabilirsiniz.

Aşağıdaki örnekte, Python'da tür ipuçlarının kullanımı basit bir yemek fiyatı hesaplayıcı ile gösterilmektedir, calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Tip ipuçlarının kodunuzun çalışma şeklini değiştirmediğini unutmayın.

FastAPI Etkileşimli API Belgeleri

FastAPI, otomatik etkileşimli API belgeleri sağlamak için Swagger UI'yi kullanır. Erişmek için http://localhost:8000/docs gidin ve tüm uç noktalarınızı, yöntemlerinizi ve şemalarınızı içeren bir ekran göreceksiniz.

Bu otomatik, tarayıcı tabanlı API dokümantasyonu, FastAPI tarafından sağlanmaktadır ve bundan yararlanmak için başka bir şey yapmanıza gerek yoktur.

Yine FastAPI tarafından sağlanan alternatif bir tarayıcı tabanlı API belgesi Redoc'tur. Redoc'a erişmek için http://localhost:8000/redoc , burada size uç noktalarınızın, yöntemlerin ve ilgili yanıtlarının bir listesi sunulur.

FastAPI'de Rotaları Ayarlama

@app dekoratörü, rotanın @app.get veya @app.post gibi yöntemini belirtmenize olanak tanır ve GET , POST , PUT ve DELETE ile daha az yaygın olan HEAD , PATCH ve TRACE seçeneklerini destekler.

FastAPI ile Uygulamanızı Oluşturma

Bu öğreticide, FastAPI ile bir CRUD uygulaması oluşturma konusunda size yol gösterilecektir. Uygulama şunları yapabilecektir:

• kullanıcı oluştur
• Bir kullanıcının veritabanı kaydını okuyun
• Mevcut bir kullanıcıyı güncelleme
• Belirli bir kullanıcıyı sil

Bu CRUD işlemlerini yürütmek için API uç noktalarını ortaya çıkaran yöntemler oluşturacaksınız. Sonuç, bir kullanıcı listesini saklayabilen bir bellek içi veritabanı olacaktır.

Python tipi açıklamaları kullanarak veri doğrulama ve ayar yönetimi gerçekleştirmek için pydantic kitaplığını kullanacaksınız. Bu öğreticinin amaçları doğrultusunda, verilerinizin şeklini niteliklere sahip sınıflar olarak ilan edeceksiniz.

Bu öğretici, bellek içi veritabanını kullanacaktır. Bu, API'lerinizi oluşturmak için FastAPI kullanmaya hızla başlamanızı sağlamak içindir. Ancak üretim için PostgreSQL, MySQL, SQLite ve hatta Oracle gibi dilediğiniz veritabanından yararlanabilirsiniz.

Uygulamayı Oluşturma

Kullanıcı modelinizi oluşturarak başlayacaksınız. Kullanıcı modeli aşağıdaki özniteliklere sahip olacaktır:

• id : Evrensel Benzersiz Tanımlayıcı (UUID)
• first_name : Kullanıcının ilk adı
• last_name : Kullanıcının soyadı
• gender : Kullanıcının cinsiyeti
• roles , admin ve user rollerini içeren bir listedir

Çalışma dizininizde models.py adlı yeni bir dosya oluşturarak başlayın, ardından modelinizi oluşturmak için aşağıdaki kodu models.py'ye yapıştırın:

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

Yukarıdaki kodda:

• User sınıfınız, daha sonra pydantic içe aktarılan BaseModel genişletir.
• Kullanıcının niteliklerini yukarıda tartışıldığı gibi tanımladınız.

Bir sonraki adım veritabanınızı oluşturmaktır. main.py dosyanızın içeriğini aşağıdaki kodla değiştirin:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

main.py'de :

• db bir List türüyle başlattınız ve User modeline geçtiniz
• Her biri first_name , last_name , gender ve roles gibi gerekli özniteliklere sahip dört kullanıcılı bir bellek içi veritabanı oluşturdunuz. Eunit kullanıcısına admin ve user rolleri atanırken, diğer üç kullanıcıya yalnızca user rolü atanır.

Veritabanı Kayıtlarını Oku

Bellek içi veritabanınızı başarıyla kurdunuz ve onu kullanıcılarla doldurdunuz, bu nedenle bir sonraki adım, tüm kullanıcıların bir listesini döndürecek bir uç nokta ayarlamaktır. FastAPI'nin devreye girdiği yer burasıdır.

main.py dosyanızda, aşağıdaki kodu Hello World bitiş noktanızın hemen altına yapıştırın:

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Bu kod /api/v1/users uç noktasını tanımlar ve veritabanının tüm içeriğini, db döndüren get_users bir eşzamansız işlev oluşturur.

Dosyanızı kaydedin ve kullanıcı uç noktanızı test edebilirsiniz. API sunucusunu başlatmak için terminalinizde aşağıdaki komutu çalıştırın:

 $ uvicorn main:app --reload

Tarayıcınızda http://localhost:8000/api/v1/users gidin. Bu, aşağıda görüldüğü gibi tüm kullanıcılarınızın bir listesini döndürmelidir:

Bu aşamada, main.py dosyanız şöyle görünecektir:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Veritabanı Kayıtları Oluşturun

Bir sonraki adım, veritabanınızda yeni bir kullanıcı oluşturmak için bir uç nokta oluşturmaktır. Aşağıdaki parçacığı main.py dosyanıza yapıştırın:

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

Bu snippet'te, yeni bir kullanıcı göndermek için uç noktayı tanımladınız ve bir POST yöntemi oluşturmak için @app.post dekoratörünü kullandınız.

Ayrıca User modelinin user kabul eden create_user işlevini de yarattınız ve yeni oluşturulan user veritabanına eklediniz (eklediniz), db . Son olarak uç nokta, yeni oluşturulan kullanıcının id bir JSON nesnesi döndürür.

Yukarıda görüldüğü gibi uç noktanızı test etmek için FastAPI tarafından sağlanan otomatik API belgelerini kullanmanız gerekecektir. Bunun nedeni, web tarayıcısını kullanarak gönderi isteği yapamamanızdır. SwaggerUI tarafından sağlanan belgeleri kullanarak test etmek için http://localhost:8000/docs adresine gidin.

Veritabanı Kayıtlarını Sil

Bir CRUD uygulaması oluşturduğunuz için, uygulamanızın belirli bir kaynağı silme yeteneğine sahip olması gerekir. Bu öğretici için, bir kullanıcıyı silmek için bir uç nokta oluşturacaksınız.

Aşağıdaki kodu main.py dosyanıza yapıştırın:

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

İşte bu kodun nasıl çalıştığının satır satır dökümü:

• @app.delete("/api/v1/users/{id}") : @app.delete() dekoratörünü kullanarak silme uç noktasını oluşturdunuz. Yol hala /api/v1/users/{id} şeklindedir, ancak daha sonra kullanıcının id karşılık gelen bir yol değişkeni olan id'yi alır.
• async def delete_user(id: UUID): : id URL'den alan delete_user işlevini oluşturur.
• for user in db: : Bu, uygulamaya veritabanındaki kullanıcılar arasında dolaşmasını ve iletilen id veritabanındaki bir kullanıcıyla eşleşip eşleşmediğini kontrol etmesini söyler.
• db.remove(user) : id bir kullanıcıyla eşleşirse, kullanıcı silinir; aksi takdirde, durum kodu 404 olan bir HTTPException oluşturulur.

Veritabanı Kayıtlarını Güncelle

Bir kullanıcının ayrıntılarını güncellemek için bir uç nokta oluşturacaksınız. Güncellenebilen ayrıntılar şu parametreleri içerir: first_name , last_name ve roles .

models.py dosyanızda, User(BaseModel): sınıfından sonra gelen User modelinizin altına aşağıdaki kodu yapıştırın:

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

Bu kod parçacığında, UpdateUser sınıfı BaseModel öğesini genişletir. Daha sonra first_name , last_name ve roles gibi güncellenebilir kullanıcı parametrelerini isteğe bağlı olarak ayarlarsınız.

Şimdi, belirli bir kullanıcının ayrıntılarını güncellemek için bir uç nokta oluşturacaksınız. main.py dosyanızda, aşağıdaki kodu @app.delete decorator'dan sonra yapıştırın:

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

Yukarıdaki kodda aşağıdakileri yaptınız:

• Güncelleme bitiş noktası olan @app.put("/api/v1/users/{id}") oluşturuldu. Kullanıcının kimliğine karşılık gelen değişken bir parametre id sahiptir.
• UpdateUser sınıfını ve id alan update_user adlı bir yöntem yarattı.
• Geçirilen id ilişkili kullanıcının veritabanında olup olmadığını kontrol etmek için bir for döngüsü kullanıldı.
• Kullanıcının parametrelerinden herhangi birinin is not None (null değil) olup olmadığı kontrol edildi. first_name , last_name veya roles gibi herhangi bir parametre boş değilse güncellenir.
• İşlem başarılı olursa, kullanıcı kimliği döndürülür.
• Kullanıcı bulunamadıysa, durum kodu 404 olan bir HTTPException istisnası ve Could not find user with id: {id} mesajı oluşturulur.

Bu uç noktayı test etmek için Uvicorn sunucunuzun çalıştığından emin olun. Çalışmıyorsa şu komutu girin:

 uvicorn main:app --reload

Aşağıda testin bir ekran görüntüsü var.

FastAPI'nin insan kaynaklı hataları yüzde 40'a kadar nasıl azaltabileceğini görün Hemen buradan başlayın: Tweet için Tıklayın

Özet

Bu eğitimde, Python için FastAPI çerçevesini öğrendiniz ve FastAPI destekli bir uygulamayı ne kadar hızlı çalışır hale getirebileceğinizi kendiniz gördünüz. Veritabanı kayıtlarını oluşturma, okuma, güncelleme ve silme gibi çerçeveyi kullanarak CRUD API uç noktaları oluşturmayı öğrendiniz.

Şimdi, web uygulaması geliştirmenizi bir sonraki seviyeye taşımak istiyorsanız, Kinsta'nın Uygulama Barındırma ve Veritabanı Barındırma platformunu kontrol ettiğinizden emin olun. FastAPI gibi, son derece basittir.