Jak zbudować wysokowydajną usługę API za pomocą FastAPI

FastAPI to nowoczesny, szybki (wydajny) framework webowy, zaprojektowany specjalnie do budowy API. Opiera się na wskazówkach typów Pythona i wspiera programowanie asynchroniczne, co pozwala deweloperom na tworzenie wysokowydajnych, wysoko dostępnych usług API o niskim opóźnieniu. W tym artykule szczegółowo przedstawimy, jak używać FastAPI do budowy wysokowydajnej usługi API, krok po kroku, aby pomóc Ci zrealizować cały proces, od przygotowania środowiska po wdrożenie.

Krok pierwszy: Przygotowanie środowiska

Musisz upewnić się, że w Twoim środowisku deweloperskim zainstalowany jest Python 3.6+. Jeśli jeszcze go nie masz, możesz odwiedzić oficjalną stronę Pythona, aby pobrać i zainstalować.

Instalacja FastAPI i Uvicorn

FastAPI sam w sobie nie zapewnia usługi, potrzebny jest serwer ASGI do jego obsługi. Tutaj używamy Uvicorn, wysokowydajnego serwera ASGI. Możesz zainstalować FastAPI i Uvicorn za pomocą następującego polecenia:

pip install fastapi uvicorn

Krok drugi: Budowa podstawowego API

Stwórzmy prostą aplikację FastAPI.

Tworzenie pliku aplikacji

W swoim katalogu projektu stwórz plik Pythona, na przykład main.py, a następnie napisz w nim następujący kod:

from fastapi import FastAPI

app = FastAPI()

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

W powyższym kodzie najpierw importujemy FastAPI i tworzymy instancję app. Następnie definiujemy trasę GET, która zwraca prostą odpowiedź JSON, gdy odwiedzamy ścieżkę główną /.

Uruchomienie serwera

Uruchom swój serwer FastAPI za pomocą następującego polecenia:

uvicorn main:app --reload

• main: odnosi się do nazwy pliku, bez rozszerzenia .py.
• app: odnosi się do instancji FastAPI.
• --reload: w trybie deweloperskim, serwer automatycznie restartuje się po zmianach w plikach.

Krok trzeci: Definiowanie tras i modeli danych

Aby zbudować bardziej złożone API, musisz użyć Pydantic do definiowania modeli danych.

Tworzenie modelu danych

Dodaj następujący kod do main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Ten kod używa Pydantic do stworzenia modelu danych Item, który zawiera trzy atrybuty: nazwę produktu, cenę i dostępność.

Dodanie nowej trasy

Następnie możemy zdefiniować nową trasę POST, aby przyjmować dane typu Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

W tej trasie FastAPI automatycznie weryfikuje przesyłane dane i mapuje je na model Item.

Krok czwarty: Automatyczne generowanie dokumentacji

Jedną z największych zalet FastAPI jest możliwość automatycznego generowania dokumentacji API. Możesz zobaczyć ją, odwiedzając następujące adresy:

• Swagger UI: http://127.0.0.1:8000/docs
• ReDoc: http://127.0.0.1:8000/redoc

W tych wygenerowanych dokumentach możesz interaktywnie testować API i przeglądać formaty żądań i odpowiedzi dla każdej trasy.

Krok piąty: Dodanie uwierzytelniania

W rzeczywistych aplikacjach uwierzytelnianie jest ważnym elementem. Dodajmy proste uwierzytelnianie oparte na rolach.

Dodanie zależności bezpieczeństwa

Użyj metody Depends FastAPI oraz OAuth2PasswordBearer, aby zaimplementować uwierzytelnianie:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
    return user

Ochrona tras

Następnie możesz dodać uwierzytelnianie do tras, które wymagają ochrony:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Krok szósty: Wdrożenie aplikacji FastAPI

Po zakończeniu rozwoju możesz potrzebować wdrożyć aplikację na serwerze w chmurze. Możesz wybrać wdrożenie za pomocą Dockera.

Tworzenie Dockerfile

W katalogu projektu stwórz plik o nazwie Dockerfile i wpisz w nim następujące treści:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Budowanie obrazu Docker

W terminalu użyj następującego polecenia, aby zbudować obraz Docker:

docker build -t myfastapiapp .

Uruchamianie kontenera Docker

Uruchom swoją aplikację FastAPI:

docker run -d --name fastapi -p 80:80 myfastapiapp

Podsumowanie

W tym artykule szczegółowo omówiliśmy, jak używać FastAPI do budowy wysokowydajnej usługi API, od przygotowania środowiska, przez tworzenie podstawowego API, definiowanie tras i modeli danych, aż po dodanie uwierzytelniania i wdrożenie. FastAPI oferuje wiele potężnych funkcji, które sprawiają, że budowa nowoczesnych API jest prosta i wydajna. Możesz dalej eksplorować więcej funkcji i cech w oficjalnej dokumentacji. Mamy nadzieję, że ten artykuł pomoże Ci szybciej zacząć korzystać z FastAPI i skutecznie zwiększyć wydajność rozwoju Twojego projektu!