Jak skonfigurować bazy danych SQL w aplikacji FastAPI

W świecie zarządzania danymi, połączenie potęgi Pythona i efektywności baz danych SQL tworzy silne narzędzie do obsługi danych. Integracja baz danych SQL z aplikacjami to kluczowa umiejętność dla każdego programisty, który chce budować solidne i skalowalne aplikacje internetowe. SQL jest standardowym językiem do zarządzania i manipulowania danymi w relacyjnych bazach danych. W połączeniu z FastAPI, otwiera przed nami szerokie możliwości przechowywania i pobierania danych. Kompatybilność FastAPI z bazami danych SQL realizowana jest poprzez ORM (Object-Relational Mapping), z których najpopularniejszym jest SQLAlchemy. W tym rozdziale skupimy się na tym narzędziu.

Aby rozpocząć, należy zainstalować FastAPI oraz SQLAlchemy w swoim środowisku wirtualnym. Jeśli podążałeś za instrukcjami z rozdziału 1, FastAPI powinno być już zainstalowane. Instalacja SQLAlchemy jest prosta i sprowadza się do jednego polecenia pip: $ pip install sqlalchemy. Po zainstalowaniu SQLAlchemy, kolejnym krokiem jest jego konfiguracja, aby mogło współpracować z FastAPI. Wymaga to ustawienia połączenia z bazą danych, co przeprowadzimy krok po kroku.

SQLAlchemy pełni rolę pomostu pomiędzy kodem Pythona a bazą danych, pozwalając na interakcję z bazą przy użyciu klas i obiektów Pythona, zamiast pisania zapytań SQL. Po zainstalowaniu SQLAlchemy, należy skonfigurować je w aplikacji FastAPI. Pierwszym krokiem jest zdefiniowanie modeli bazy danych, które będą reprezentować tabele bazy danych w kodzie Python. W SQLAlchemy modele definiowane są za pomocą klas, z których każda odpowiada jednej tabeli w bazie danych, a atrybuty klasy odpowiadają kolumnom tabeli.

Model użytkownika w SQLAlchemy może wyglądać następująco:

python
Copy code
from sqlalchemy.orm import (Mapped, mapped_column)

class User(Base):
    __tablename__ = "user"
    id: Mapped[int] = mapped_column(
        primary_key=True,
    )
    name: Mapped[str]
    email: Mapped[str]

W tym modelu klasa User odpowiada tabeli o nazwie "user" w bazie danych, z kolumnami dla id, name i email. Każdy atrybut klasy określa typ danych kolumny.

Po zdefiniowaniu modeli, kolejnym krokiem jest połączenie z bazą danych i stworzenie odpowiednich tabel. SQLAlchemy używa łańcucha połączeń (connection string), aby określić szczegóły połączenia z bazą. Łańcuch ten będzie różnił się w zależności od używanego systemu baz danych. Dla bazy SQLite łańcuch połączenia wyglądałby na przykład tak: DATABASE_URL = "sqlite:///./test.db". SQLite to lekka, plikowa baza danych, która nie wymaga uruchomienia oddzielnego serwera, dlatego doskonale nadaje się do celów rozwojowych i testowych.

Dalszym krokiem jest utworzenie obiektu "Engine" w SQLAlchemy, który reprezentuje interfejs do bazy danych:

python
Copy code
from sqlalchemy import create_engine
engine = create_engine(DATABASE_URL)

Po utworzeniu silnika, możemy przystąpić do tworzenia tabel w bazie. Można to zrobić, przekazując naszą klasę bazową oraz silnik do metody create_all SQLAlchemy:

python
Copy code
Base.metadata.create_all(bind=engine)

Gdy struktura bazy danych jest już gotowa, pora na połączenie aplikacji z bazą danych. Połączenia z bazą danych w SQLAlchemy zarządzane są przez sesje. Sesja to przestrzeń robocza, w której możemy dodawać nowe rekordy lub pobierać istniejące. Każda sesja jest związana z jednym połączeniem do bazy danych. Aby zarządzać sesjami, musimy stworzyć klasę SessionLocal, która będzie służyła do tworzenia i zarządzania obiektami sesji:

python
Copy code
from sqlalchemy.orm import sessionmaker
SessionLocal = sessionmaker(
    autocommit=False, autoflush=False, bind=engine
)

Funkcja sessionmaker tworzy fabrykę sesji. Parametry autocommit i autoflush są ustawione na False, co oznacza, że transakcje muszą być ręcznie zatwierdzane, a zmiany zapisane w bazie muszą być zarządzane przez programistę.

Gdy mamy już klasę SessionLocal, możemy stworzyć funkcję, która będzie używana w funkcjach routujących FastAPI do uzyskiwania nowych sesji bazy danych. Funkcję tę możemy dodać do modułu main.py w następujący sposób:

python
Copy code
from database import SessionLocal

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

W swoich funkcjach routujących możemy używać tej funkcji jako zależności do komunikacji z bazą danych. W FastAPI można to zrobić przy użyciu klasy Depends. Na przykład, możemy dodać punkt końcowy do odczytu użytkowników:

python
Copy code
from fastapi import Depends, FastAPI
from sqlalchemy.orm import Session
from database import SessionLocal
app = FastAPI()
@app.get("/users/")
def read_users(db: Session = Depends(get_db)):
    users = db.query(User).all()
    return users

Takie podejście zapewnia, że dla każdego żądania zostanie utworzona nowa sesja, która zostanie zamknięta po zakończeniu żądania. To kluczowe dla utrzymania integralności transakcji w bazie danych.

Jak zaimplementować zadania tła w FastAPI?

FastAPI, jako jedno z najpopularniejszych narzędzi do budowy aplikacji internetowych w Pythonie, oferuje wiele zaawansowanych funkcji, które umożliwiają łatwe i efektywne zarządzanie asynchronicznymi zadaniami. Jedną z takich funkcji jest obsługa zadań w tle, które pozwalają na wykonywanie operacji wymagających czasu, takich jak zapisywanie danych do bazy, bez blokowania głównego procesu aplikacji. Dzięki temu aplikacja może reagować na żądania użytkowników szybciej, a jednocześnie wykonywać długotrwałe operacje w tle.

Załóżmy, że chcielibyśmy przechować komunikaty z punktu końcowego GET /v2/trips/{category} w zewnętrznej bazie danych w celach analitycznych. Zrealizujemy to w dwóch krokach.

Po pierwsze, zdefiniujemy funkcję, która będzie symulować operację przechowywania danych w zewnętrznej bazie. Funkcja ta znajduje się w dedykowanym module background_tasks.py, który będzie przechowywał logikę operacji w tle:

python
Copy code
import asyncio
import logging
logger = logging.getLogger("uvicorn.error")

async def store_query_to_external_db(message: str):

    logger.info(f"Storing message '{message}'.")
    await asyncio.sleep(2)
    logger.info(f"Message '{message}' stored!")

Zadanie jest tutaj symulowane przez operację asyncio.sleep, co pozwala na wykonanie nieblokującej operacji. W kodzie dodano również logowanie, aby śledzić postęp wykonania zadania.

Drugim krokiem jest dodanie tego zadania w tle do endpointu aplikacji. Modyfikujemy nasz punkt końcowy GET /v2/trips/{category} w pliku main.py w następujący sposób:

python
Copy code
from fastapi import BackgroundTasks
@app.get("/v2/trips/{category}")
def get_trips_by_category(
    background_tasks: BackgroundTasks,
    category: Annotated[select_category, Depends()],
    discount_applicable: Annotated[bool, Depends(check_coupon_validity)],
):
    category = category.replace("-", " ").title()
    message = f"You requested {category} trips."
    if discount_applicable:
        message += "\n. The coupon code is valid! You will get a discount!"
    background_tasks.add_task(store_query_to_external_db, message)
    logger.info("Query sent to background task, end of request.")
    return message

W powyższym przykładzie, po otrzymaniu żądania, zadanie przechowywania danych w tle zostaje dodane do obiektu background_tasks, a cała operacja odbywa się w tle, nie blokując głównego procesu. Po zakończeniu operacji, system loguje wynik wykonania zadania.

Aby uruchomić aplikację, wystarczy skorzystać z komendy:

nginx
Copy code
uvicorn app.main:app

Teraz, przy wywołaniu endpointu GET /v2/trips/cruises, zobaczymy w terminalu logi z funkcji store_query_to_external_db, które będą wyglądać następująco:

vbnet
Copy code
INFO: Query sent to background task, end of request.

INFO: 127.0.0.1:58544 - "GET /v2/trips/cruises"

INFO: Storing message 'You requested Cruises trips.'
INFO: Message 'You requested Cruises trips.' stored!

Implementacja zadań w tle w FastAPI jest więc bardzo prosta. Niemniej jednak, jeśli musimy wykonać bardziej zaawansowane operacje obliczeniowe, warto rozważyć wykorzystanie dedykowanych narzędzi do zarządzania kolejkami zadań, takich jak Celery. Dzięki tym narzędziom możemy wykonywać zadania w oddzielnym procesie, co pozwala uniknąć problemów z wydajnością, które mogą wystąpić, gdy zadania będą wykonywane w tym samym procesie co aplikacja FastAPI.

Jak działa system zadań w tle? Kiedy żądanie trafia do endpointu, zadanie w tle jest dodawane do obiektu BackgroundTasks, który przekazuje je do pętli zdarzeń (event loop) w celu równoczesnego wykonania. Dzięki temu operacje I/O, takie jak zapisywanie danych do bazy czy wysyłanie zapytań HTTP, mogą być wykonywane równolegle, bez blokowania głównego procesu.

Warto jednak pamiętać, że takie podejście nie jest odpowiednie dla bardziej złożonych operacji, które wymagają dużej mocy obliczeniowej. W takich przypadkach, zamiast używać zadań w tle w FastAPI, warto rozważyć wykorzystanie narzędzi takich jak Celery, które oferują bardziej zaawansowane funkcje zarządzania zadaniami i ich kolejkowaniem. Pozwoli to na wykonywanie długotrwałych obliczeń w oddzielnych procesach i uniknięcie problemów związanych z przeciążeniem głównego procesu aplikacji.

Warto również pamiętać, że FastAPI udostępnia bardzo wygodny mechanizm obsługi zależności (dependency injection), który umożliwia łatwe zarządzanie komponentami aplikacji, w tym zadaniami w tle. Dzięki temu możemy w sposób modularny i elastyczny włączać zadania w tle do różnych części aplikacji, co znacznie poprawia organizację kodu i ułatwia jego utrzymanie.

Jak przygotować środowisko deweloperskie do pracy z FastAPI: Kluczowe kroki i narzędzia

Aby rozpocząć przygodę z FastAPI, należy zadbać o odpowiednie środowisko deweloperskie, które będzie wspierać zarówno język Python, jak i funkcjonalności FastAPI. Jest to niezbędna baza, dzięki której będziesz w stanie tworzyć profesjonalne aplikacje webowe. W poniższym rozdziale przedstawiamy szczegółowy proces instalacji i konfiguracji narzędzi, które pozwolą na sprawne rozpoczęcie pracy z FastAPI. Proces ten obejmuje instalację Python, FastAPI, serwera Uvicorn, a także konfigurację środowiska IDE i GitHub, co umożliwi wygodne zarządzanie kodem oraz współpracę z innymi programistami.

Instalacja niezbędnych narzędzi

Po zainstalowaniu Pythona, następnym krokiem jest instalacja FastAPI i Uvicorn. Uvicorn to serwer ASGI, który jest odpowiedzialny za uruchamianie aplikacji FastAPI. W celu jego zainstalowania oraz samego FastAPI, wystarczy wykonać w terminalu poniższe polecenie:

bash
Copy code
pip install fastapi[all]

Komenda ta zainstaluje FastAPI wraz ze wszystkimi rekomendowanymi zależnościami, w tym Uvicorn. Po zakończeniu instalacji, możesz sprawdzić, czy wszystko działa poprawnie, uruchamiając komendę:

bash
Copy code
uvicorn --version

Wybór środowiska IDE

Kolejnym krokiem jest konfiguracja środowiska IDE. Odpowiednie środowisko do pisania i debugowania kodu może znacząco wpłynąć na jakość pracy oraz efektywność. Do pracy z FastAPI i Pythonem często wykorzystywane są dwa popularne IDE: Visual Studio Code (VS Code) oraz PyCharm. Oba narzędzia oferują bogate wsparcie dla Pythona oraz ułatwiają pracę z frameworkiem FastAPI.

Visual Studio Code (VS Code)

VS Code to lekkie, otwartoźródłowe środowisko, które charakteryzuje się ogromną elastycznością. Można je dostosować do swoich potrzeb za pomocą rozszerzeń. Aby rozpocząć pracę, należy pobrać i zainstalować VS Code z oficjalnej strony. Następnie, w celu zainstalowania wsparcia dla Pythona, wystarczy przejść do sekcji Extensions i wyszukać rozszerzenie Python autorstwa Microsoftu. Po zainstalowaniu go, IDE będzie gotowe do pracy.

PyCharm

PyCharm to potężne IDE stworzone specjalnie z myślą o programistach Pythona. Jest dostępne w dwóch wersjach: Community Edition, która jest darmowa, oraz Professional Edition, która oferuje dodatkowe funkcje, ale jest płatna. W kontekście pracy z FastAPI wystarczająca będzie wersja Community, którą można pobrać ze strony JetBrains. Po zainstalowaniu PyCharm, IDE oferuje szereg narzędzi, które wspierają pracę z frameworkiem FastAPI, takich jak integracja z systemami wersjonowania, debuggowanie kodu, czy podpowiedzi kodu.

Integracja z Git i GitHub

Podstawą współczesnego rozwoju oprogramowania jest korzystanie z systemu kontroli wersji. Git jest jednym z najpopularniejszych narzędzi tego typu, a GitHub stanowi świetne rozwiązanie do przechowywania kodu i współpracy z innymi deweloperami. Należy zatem zainstalować Git, jeśli jeszcze tego nie zrobiłeś. Po instalacji Git, warto również założyć konto na GitHubie, aby móc łatwo zarządzać swoimi projektami oraz współpracować z innymi.

Aby zainstalować Git, wystarczy pobrać go ze strony git-scm.com i zainstalować na swoim komputerze. Po zakończeniu instalacji należy skonfigurować swoje dane użytkownika, wykonując polecenia:

bash
Copy code
git config --global user.name "Twoje Imię"

git config --global user.email "[email protected]"

Testowanie aplikacji przy pomocy Postman i Swagger UI

Testowanie API jest nieodzownym elementem procesu tworzenia aplikacji webowych. FastAPI automatycznie generuje interfejs Swagger UI, który pozwala na łatwe testowanie endpointów aplikacji. Swagger UI dostępny jest pod adresem /docs po uruchomieniu aplikacji. Możesz tam testować wszystkie dostępne endpointy i sprawdzać ich działanie na żywo.

Alternatywnie, do testowania możesz użyć Postmana — popularnego narzędzia do testowania API, które oferuje szeroki wachlarz funkcji, takich jak testowanie zapytań HTTP, monitorowanie odpowiedzi oraz automatyzowanie procesów testowych.

Utrzymywanie porządku w projekcie

Po skonfigurowaniu wszystkich niezbędnych narzędzi, kolejnym krokiem jest utrzymanie porządku w projekcie. Istotne jest, aby używać Git do kontrolowania wersji swojego kodu i regularnie commitować zmiany. Dzięki temu nie tylko zabezpieczysz się przed utratą danych, ale również ułatwisz sobie współpracę z innymi programistami. Pamiętaj, aby na bieżąco przeglądać dokumentację FastAPI, ponieważ framework ten jest dynamicznie rozwijany, a jego możliwości ciągle się rozszerzają.

Ważne wskazówki

Pamiętaj, że szybka instalacja narzędzi to tylko początek. Ostateczny sukces w pracy z FastAPI zależy od umiejętności korzystania z tych narzędzi w sposób efektywny. Dlatego warto poświęcić czas na naukę debugowania w swoim IDE, optymalizowania procesów w Git oraz wykorzystywania dostępnych narzędzi do testowania i monitorowania aplikacji. Dbanie o jakość kodu, stosowanie dobrych praktyk oraz korzystanie z zaawansowanych funkcji IDE pomoże Ci w codziennej pracy nad aplikacjami FastAPI.

Jak wdrożyć aplikację FastAPI przy użyciu Railway i Hatch

Jeśli projekt pochodzi z repozytorium FastAPI-Cookbook, lub jeśli katalog główny Twojego projektu nie jest katalogiem głównym repozytorium, kliknij opcję „Add Root Directory” (Dodaj katalog główny) i wprowadź ścieżkę. Dla repozytorium FastAPI-Cookbook ścieżka będzie wynosić /Chapter12/live_application. Po dodaniu ścieżki kliknij ikonę zapisu. Zostaw wybraną gałąź jako „main”.

W pasku adresu przeglądarki pojawi się ikona kłódki, co wskazuje, że połączenie jest bezpieczne i posiada certyfikat. Zwykle, gdy udostępniasz swoją usługę w internecie, platforma hostingowa automatycznie dostarcza certyfikaty. Dzięki temu właśnie wdrożyłeś swoją aplikację FastAPI, która jest teraz dostępna w Internecie i może być wykorzystywana przez użytkowników na całym świecie.

FastAPI jest jednym z najszybciej rozwijających się narzędzi do budowania aplikacji produkcyjnych, szczególnie w czołowych platformach chmurowych. Dlatego znajdziesz obszerne materiały na temat jego użycia, w tym artykuły o wdrażaniu aplikacji FastAPI na takich platformach jak Google Cloud Platform (GCP), Amazon Web Services (AWS) i Microsoft Azure. Przykłady na te tematy dostępne są pod poniższymi linkami:

• „Deploying FastAPI app with Google Cloud Run” (https://dev.to/0xnari/deploying-fastapi-app-with-google-cloud-run-13f3)

• „Deploy FastAPI on AWS EC2” (https://medium.com/@shreyash966977/deploy-fastapi-on-aws-ec2-quick-and-easy-steps-954d4a1e4742)

• „Using FastAPI Framework with Azure Functions” (https://learn.microsoft.com/en-us/samples/azure-samples/fastapi-on-azure-functions/fastapi-on-azure-functions/)

Dodatkowo, warto zapoznać się z platformą Porter, która umożliwia wdrażanie aplikacji na różnych usługach chmurowych, takich jak AWS, GCP czy Azure, z jednego zintegrowanego miejsca. Można to zrobić za pomocą dokumentacji dostępnej pod tym linkiem: (https://docs.porter.run/guides/fastapi/deploy-fastapi).

Kiedy aplikacja FastAPI jest już gotowa, kluczowym krokiem jest jej zapakowanie i wysłanie na zewnątrz. W tym celu dobrze jest używać narzędzi do zarządzania projektami Pythonowymi, takich jak Hatch, które upraszczają proces tworzenia paczek, wersjonowania i dystrybucji aplikacji. Hatch umożliwia łatwą obsługę wielu środowisk wirtualnych, a także integruje się z systemem pakietów w Pythonie, co sprawia, że aplikacja jest łatwa do zainstalowania i utrzymywania.

Aby zbudować i wdrożyć aplikację przy użyciu Hatch, należy wykonać kilka kroków:

1. Zainicjowanie projektu.

2. Instalacja zależności.

3. Utworzenie aplikacji.

4. Zbudowanie dystrybucji.

5. Testowanie paczki.

Rozpoczynamy od utworzenia projektu. Można to zrobić za pomocą komendy hatch new "FCA Server", która utworzy strukturę projektu pod folderem fca-server. Następnie wchodzimy do katalogu projektu, uruchamiamy środowisko wirtualne komendą hatch shell i sprawdzamy, czy środowisko zostało poprawnie aktywowane. Aby zainstalować wymagane zależności, dodajemy pakiet FastAPI do pliku pyproject.toml, w sekcji zależności.

Warto pamiętać, że proces budowy i wdrażania aplikacji FastAPI jest nie tylko związany z jej uruchomieniem w środowisku chmurowym, ale także z odpowiednim przygotowaniem aplikacji do pracy w różnych środowiskach i platformach. Im lepiej przygotujesz aplikację, tym łatwiej będzie ją zarządzać i skalować w przyszłości.