Szybki start z FastAPI – jak stworzyć nowoczesne REST API w 15 minut

Wprowadzenie do FastAPI i REST API

FastAPI to nowoczesny framework webowy dla języka Python, zaprojektowany z myślą o tworzeniu wydajnych i łatwych w utrzymaniu interfejsów API. Korzysta z możliwości typowania znanych z Pythona 3.6+, co pozwala na automatyczną walidację danych, generowanie dokumentacji oraz zwiększenie czytelności kodu.

REST API (Representational State Transfer) to styl architektoniczny wykorzystywany do budowania skalowalnych usług sieciowych. W praktyce oznacza to udostępnianie danych i funkcjonalności aplikacji za pomocą standardowych metod HTTP, takich jak GET, POST, PUT czy DELETE. Pozwala to na komunikowanie się z aplikacją w sposób ustandaryzowany i czytelny dla innych systemów.

FastAPI łączy w sobie prostotę Pythona z wysoką wydajnością dzięki wykorzystaniu asynchroniczności (async/await) oraz silnikowi Starlette pod spodem. Framework został zaprojektowany z myślą o szybkim tworzeniu aplikacji zgodnych z zasadami REST, oferując przy tym automatyczne generowanie dokumentacji w czasie rzeczywistym oraz łatwe testowanie endpointów.

Typowe zastosowania FastAPI to między innymi:

• budowanie mikroserwisów i usług backendowych,
• tworzenie interfejsów API dla aplikacji webowych i mobilnych,
• tworzenie systemów przetwarzania danych i integracji,
• tworzenie usług z wykorzystaniem sztucznej inteligencji i uczenia maszynowego.

To, co wyróżnia FastAPI na tle innych frameworków, to:

• Wydajność – porównywalna z Node.js i Go,
• Automatyczna dokumentacja – generowana na podstawie typów danych i dekoratorów,
• Walidacja wejścia – wbudowana i intuicyjna dzięki integracji z biblioteką Pydantic,
• Wsparcie dla asynchroniczności – ułatwiające skalowanie aplikacji.

Dzięki tym cechom FastAPI staje się atrakcyjnym wyborem zarówno dla początkujących, jak i doświadczonych programistów szukających nowoczesnego podejścia do tworzenia interfejsów API w Pythonie.

Instalacja FastAPI i niezbędnych zależności

Zanim rozpoczniemy pracę z FastAPI, musimy przygotować środowisko programistyczne oraz zainstalować kilka kluczowych pakietów. FastAPI działa w oparciu o asynchroniczny model programowania i został zaprojektowany do budowy wydajnych API opartych na standardzie REST. Aby skorzystać z jego możliwości, potrzebujemy tylko kilku podstawowych zależności.

Najprostszym sposobem na rozpoczęcie jest stworzenie wirtualnego środowiska. Dzięki temu unikniemy konfliktów między wersjami bibliotek w różnych projektach. Po aktywacji środowiska możemy zainstalować FastAPI oraz serwer ASGI — Uvicorn, który posłuży nam do uruchamiania aplikacji.

Instalację przeprowadzimy za pomocą menedżera pakietów pip. W konsoli wpisujemy:

pip install fastapi uvicorn

Sama biblioteka FastAPI zapewnia nam możliwość definiowania tras, obsługi zapytań HTTP i integracji z narzędziami dokumentującymi API. Uvicorn natomiast jest lekki i szybki, idealny do uruchamiania aplikacji opartych o ASGI, takich jak FastAPI.

Na tym etapie nie potrzebujemy dodatkowych zależności, ale warto pamiętać, że w przyszłości możemy rozszerzyć projekt o biblioteki do pracy z bazami danych, uwierzytelniania czy testowania.

W kolejnych krokach zbudujemy podstawową strukturę naszej aplikacji i sprawdzimy, jak wykorzystać zainstalowane narzędzia w praktyce.

Tworzenie podstawowej struktury projektu

Przygotowanie przejrzystej i modularnej struktury katalogów to klucz do utrzymania czytelności i skalowalności aplikacji FastAPI. Nawet w prostych projektach warto od początku zadbać o logiczny podział plików, co ułatwi rozwój aplikacji w przyszłości.

Najprostszy projekt FastAPI może składać się z jednego pliku, ale w praktyce dobrze jest rozdzielić logikę na mniejsze elementy. Poniżej prezentujemy przykładową strukturę katalogów dla małej aplikacji REST API:

my_fastapi_app/
├── app/
│   ├── main.py           # Punkt wejścia do aplikacji
│   ├── routes/
│   │   └── items.py      # Endpointy związane z zasobami "items"
│   ├── models.py         # Modele danych (np. Pydantic, ORM)
│   └── services.py       # Logika biznesowa i funkcje pomocnicze
├── requirements.txt      # Lista zależności
└── README.md             # Dokumentacja projektu

Podział ten pozwala oddzielić warstwy odpowiedzialne za:

• Routing – definiowanie ścieżek API w folderze routes
• Modele danych – typy wejściowe i wyjściowe w models.py
• Logikę biznesową – funkcje przetwarzające dane w services.py
• Uruchamianie aplikacji – konfiguracja FastAPI w main.py

Dla bardzo prostego projektu wystarczy jeden plik main.py z minimalną konfiguracją:

# main.py
from fastapi import FastAPI

app = FastAPI()

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

Wraz ze wzrostem złożoności projektu, warto przejść do modularnej struktury, która pozwala na łatwą rozbudowę i testowanie poszczególnych komponentów.

Dla porównania, poniższa tabela przedstawia różnice między prostą a modularną strukturą projektu:

W kolejnych etapach rozwoju aplikacji, modularna struktura stanie się znaczną przewagą, zwłaszcza gdy liczba endpointów i zależności zacznie rosnąć. Jeśli chcesz szybciej rozwinąć swoje umiejętności w pracy z Pythonem – zwłaszcza w kontekście automatyzacji i analizy danych – sprawdź nasz Kurs Python - praktyczne wykorzystanie Pythona do analizy danych i automatyzacji.

Definiowanie pierwszych endpointów API

W FastAPI tworzenie endpointów, czyli punktów dostępowych do naszego API, jest szybkie i intuicyjne. Endpointy odpowiadają na konkretne żądania HTTP (np. GET, POST, PUT, DELETE) i pozwalają aplikacji komunikować się z użytkownikiem lub innym systemem. Każdy endpoint to funkcja powiązana z określoną ścieżką URL i metodą HTTP.

FastAPI wykorzystuje dekoratory do definiowania zachowania endpointów. Poniżej znajduje się krótki przykład pokazujący dwa podstawowe typy żądań:

from fastapi import FastAPI

app = FastAPI()

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

@app.post("/hello")
def create_hello(name: str):
    return {"message": f"Hello, {name}!"}

W powyższym przykładzie:

• @app.get("/hello") obsługuje żądania typu GET – zazwyczaj używane do pobierania danych.
• @app.post("/hello") definiuje żądanie POST – wykorzystywane do przesyłania danych do serwera.

Dzięki FastAPI możemy także dokładnie określać, jakie dane przyjmuje i zwraca dana funkcja, co prowadzi do większej przejrzystości i bezpieczeństwa kodu.

Poniższa tabela przedstawia podstawowe metody HTTP oraz ich zastosowanie w kontekście REST API:

Tworząc endpointy w FastAPI, zyskujemy także automatyczne walidowanie danych wejściowych i generowanie dokumentacji, co znacznie przyspiesza proces tworzenia interfejsów API zgodnych z nowoczesnymi standardami.

Uruchamianie serwera aplikacji

Po zdefiniowaniu podstawowych endpointów API, kolejnym krokiem jest uruchomienie serwera, który umożliwi testowanie i korzystanie z naszej aplikacji FastAPI. Domyślnie FastAPI używa serwera Uvicorn – lekkiego i szybkiego serwera ASGI (Asynchronous Server Gateway Interface).

Uruchomienie aplikacji FastAPI jest niezwykle proste i sprowadza się do jednej komendy:

uvicorn main:app --reload

Gdzie:

• main to nazwa pliku (bez rozszerzenia .py), w którym znajduje się aplikacja FastAPI,
• app to instancja FastAPI zadeklarowana w tym pliku,
• --reload aktywuje tryb deweloperski – serwer automatycznie przeładowuje się po każdej zmianie w kodzie.

Oto szybkie porównanie dwóch typowych trybów uruchamiania aplikacji:

Po uruchomieniu serwera, aplikacja będzie domyślnie dostępna pod adresem http://127.0.0.1:8000. W kolejnych krokach możesz przetestować jej działanie oraz sprawdzić automatycznie generowaną dokumentację. Jeśli chcesz pójść o krok dalej i poznać techniki automatyzacji oraz optymalizacji w Pythonie, sprawdź nasz Kurs Python zaawansowany: automatyzacja, skrypty i optymalizacja procesów.

Testowanie i weryfikacja działania API

Po uruchomieniu serwera aplikacji istotnym krokiem jest sprawdzenie, czy nasze REST API działa zgodnie z oczekiwaniami. FastAPI udostępnia kilka wygodnych sposobów testowania endpointów, zarówno ręcznie poprzez przeglądarkę lub narzędzia typu curl, jak i automatycznie za pomocą testów jednostkowych.

Ręczne testowanie przy użyciu przeglądarki i narzędzi HTTP

Najprostszym sposobem weryfikacji działania API jest wywołanie endpointów za pomocą przeglądarki lub narzędzia takiego jak Postman czy curl. Dla przykładu, jeśli nasza aplikacja działa pod adresem http://127.0.0.1:8000, możemy przetestować metodę GET w ten sposób:

curl http://127.0.0.1:8000/items/42

W odpowiedzi powinniśmy otrzymać dane w formacie JSON, np.:

{
  "item_id": 42,
  "name": "Przykladowy produkt"
}

W przypadku bardziej złożonych zapytań (np. POST z danymi JSON), można użyć komendy:

curl -X POST http://127.0.0.1:8000/items/ \
     -H "Content-Type: application/json" \
     -d '{"name": "Nowy produkt", "price": 12.99}'

Porównanie metod testowania

Automatyczne testy z użyciem pytest i TestClient

Dla bardziej zorganizowanego podejścia warto wykorzystać bibliotekę pytest razem z klasą TestClient z FastAPI. Przykładowy test może wyglądać tak:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_item():
    response = client.get("/items/1")
    assert response.status_code == 200
    assert response.json()["item_id"] == 1

Dzięki temu możemy szybko sprawdzić poprawność działania kodu po każdej zmianie, a także zautomatyzować testy w procesach CI/CD.

Na tym etapie warto upewnić się, że wszystkie endpointy działają zgodnie z założeniami: zwracają odpowiednie kody statusu oraz oczekiwane dane. To pozwoli uniknąć błędów na dalszych etapach rozwoju aplikacji.

Dodanie dokumentacji Swagger UI

FastAPI oferuje wbudowaną, automatycznie generowaną dokumentację REST API w formacie Swagger UI, co stanowi jedną z jego największych zalet. Dzięki temu już od pierwszych chwil pracy z aplikacją możesz przeglądać, testować i udostępniać swoje endpointy bez konieczności ręcznego tworzenia dokumentacji.

Swagger UI jest dostępny pod domyślnym adresem /docs, a alternatywnie możesz skorzystać z dokumentacji w formacie ReDoc pod adresem /redoc. Obydwie wersje są generowane dynamicznie na podstawie definicji endpointów, typów danych i parametrów wejściowych.

Dokumentacja ta nie tylko opisuje dostępne ścieżki i operacje HTTP, ale również pozwala bezpośrednio testować działanie API za pomocą interaktywnego formularza. Jest to szczególnie przydatne podczas rozwoju aplikacji oraz przy współpracy z zespołem frontendowym.

Jeśli uruchomisz swoją aplikację FastAPI, a następnie przejdziesz do przeglądarki i wpiszesz adres serwera zakończony /docs, zobaczysz czytelną, interaktywną stronę zawierającą wszystkie zdefiniowane endpointy.

W przypadku bardziej zaawansowanych zastosowań, możliwe jest dostosowanie wyglądu dokumentacji, dodanie własnych opisów, tagów czy przykładów odpowiedzi, ale te tematy zostaną omówione osobno.

Podsumowanie i kolejne kroki

FastAPI to nowoczesny framework webowy dla języka Python, który umożliwia szybkie tworzenie wydajnych i dobrze udokumentowanych REST API. Dzięki swojej architekturze opartej na typowaniu i asynchroniczności, FastAPI oferuje znacznie wyższą wydajność w porównaniu do tradycyjnych rozwiązań, takich jak Flask czy Django REST Framework.

REST API (Representational State Transfer) to styl architektoniczny oparty na zasobach i operacjach HTTP, który jest obecnie standardem komunikacji w aplikacjach webowych i mobilnych. FastAPI wpisuje się w ten model, dostarczając jednocześnie narzędzia ułatwiające automatyczne generowanie dokumentacji, walidację danych oraz integrację z narzędziami frontendowymi czy systemami mikroserwisów.

W praktyce oznacza to, że tworząc API w FastAPI, dostajesz „w pakiecie” wiele funkcjonalności, które w innych frameworkach wymagają dodatkowych bibliotek lub konfiguracji. To czyni go świetnym wyborem zarówno dla początkujących, jak i profesjonalistów budujących produkcyjne aplikacje.

W kolejnych krokach dowiesz się, jak skonfigurować środowisko projektowe, stworzyć pierwsze endpointy oraz uruchomić i przetestować działające API.

Definiowanie KPI dla operacji na danych i AI 20 lipca 2025

Praktyczne wykorzystanie Excela – proste analizy, tabele, podstawowe formuły 18 lipca 2025