FastAPI: czym jest i jak stworzyć API w Pythonie

Spis treści:

• Czym jest FastAPI
• Co jest dobrego w FastAPI
• Wady FastAPI
• Tworzenie własnego API przy użyciu FastAPI
• Przegląd projektu
• Co dalej?

Python nie słynie z wysokiej szybkości wykonywania kodu, a w przypadku projektów o dużym obciążeniu wielu programistów woli używać Go lub Node.js. Jednak wraz z pojawieniem się FastAPI sytuacja się zmieniła: teraz możliwe jest tworzenie szybkich, asynchronicznych i łatwo skalowalnych aplikacji internetowych w Pythonie. W tym artykule przyjrzymy się temu, co dokładnie wyróżnia FastAPI spośród innych narzędzi i pokażemy, jak można od podstaw opracować pełnoprawny interfejs API z automatycznym generowaniem dokumentacji.

Spis treści

• Czym jest FastAPI
• Jakie są zalety FastAPI
• Wady FastAPI
• Tworzenie własnego interfejsu API za pomocą FastAPI
• Przegląd projektu
• Co dalej?

Czym jest FastAPI

FastAPI to nowoczesne środowisko do tworzenia aplikacji internetowych i interfejsów API w języku Python, które zyskało popularność ze względu na swoją prostotę i dużą szybkość. Za pomocą zaledwie kilku linijek kodu można skonfigurować serwer, który może przyjmować żądania, przetwarzać je i zwracać wyniki — niezależnie od tego, czy są to dane z bazy danych, odpowiedzi sieci neuronowych, czy wyniki obliczeń.

FastAPI został opracowany w 2018 roku, aby zaradzić niedociągnięciom tradycyjnych frameworków Pythona, takich jak Flask i Django. Chociaż narzędzia te dobrze radziły sobie z tworzeniem prostych stron internetowych, zaczęły napotykać problemy z wydajnością wraz ze wzrostem liczby żądań i zmianą asynchronicznego podejścia Pythona.

Ten zupełnie nowy framework łączy szereg kluczowych technologii, zapewniając wyjątkową szybkość i łatwość obsługi:

• Starlette stanowi rdzeń aplikacji i definiuje proces, w którym serwer akceptuje i przetwarza przychodzące żądania. Dzięki temu FastAPI może działać w trybie asynchronicznym i obsługiwać duże obciążenia.
• Pydantic zapewnia weryfikację danych, co jest szczególnie przydatne w sytuacjach, gdy na przykład użytkownik próbuje przesłać tekst zamiast wartości liczbowej. W takich przypadkach framework natychmiast zgłosi błąd, zapobiegając awarii całej aplikacji.
• Adnotacje typu w Pythonie pomagają tworzyć bardziej przejrzysty i bezpieczny kod: wystarczy wskazać, jakich danych się oczekuje, a FastAPI automatycznie je sprawdzi i doda wszystkie niezbędne informacje do dokumentacji.

FastAPI znajduje zastosowanie w sytuacjach wymagających szybkiego przetwarzania żądań, zarówno w małych usługach, jak i na platformach o dużej skali. Programiści Pythona używają go do tworzenia strony serwerowej aplikacji internetowych, a specjaliści DevOps i inżynierowie integracji do tworzenia mikrousług i łączenia różnych systemów. Specjaliści od uczenia maszynowego używają również FastAPI do wdrażania modeli i udostępniania ich za pośrednictwem interfejsów API.

Framework jest wykorzystywany do tworzenia chatbotów, a także urządzeń IoT wymagających szybkiej reakcji na napływające dane.

Co jest tak wspaniałego w FastAPI

Głównymi zaletami FastAPI są wyjątkowa szybkość, niezawodność i możliwość automatycznego generowania dokumentacji.

Wydajność. Porównywalna z językami takimi jak Node.js i Go, dzięki asynchronicznej architekturze: framework nie czeka na zakończenie jednej operacji, aby przejść do następnej. Jest w stanie obsługiwać wiele żądań jednocześnie, a raczej przełączać się między nimi tak szybko, że jest to praktycznie niezauważalne.

Niezależne testy, w tym test Sharkbench, potwierdziły skuteczność frameworka. Aplikacje opracowane z wykorzystaniem FastAPI wykazały jedne z najlepszych wyników szybkości spośród wszystkich frameworków Pythona. Pozwala to na znaczną oszczędność zasobów serwera, co jest szczególnie ważne w przypadku projektów, które oczekują dużego ruchu.

Typowanie i walidacja. Korzystając z FastAPI, zauważysz, że ilość kodu, który musisz napisać, jest znacznie zmniejszona dzięki adnotacjom typu: określasz typy danych, a framework automatycznie je sprawdza.

Oto na przykład podstawowa funkcja, która dodaje dwie liczby i nie zawiera żadnych adnotacji:

W powyższym przykładzie Python nie ma informacji o typach zmiennych a i b. W związku z tym funkcja albo sumuje liczby, albo łączy ciągi znaków, w zależności od przekazanych danych. Jeśli typy są niepoprawne, program nie wyświetli błędów, ale wynik końcowy może być niepoprawny.

Oto przykład użycia FastAPI, gdzie typowanie jest określone bezpośrednio w argumentach funkcji:

W tym przypadku a: int i b: int to parametry, które FastAPI automatycznie weryfikuje, zapewniając, że przychodzące żądanie zawiera wartości liczbowe. Format żądania przedstawia się następująco:

Odpowiedź:

Jeśli zamiast liczby zostanie przekazana wartość, na przykład a=pięć, FastAPI natychmiast wygeneruje błąd, wskazując, że wprowadzone dane są nieprawidłowe.

Interaktywna dokumentacja. FastAPI automatycznie tworzy dokumentację, tworząc stronę wyświetlającą wszystkie dostępne punkty końcowe (adresy żądań), parametry i możliwe odpowiedzi.

Po uruchomieniu aplikacji FastAPI automatycznie tworzy dwie ścieżki specjalne – zazwyczaj /docs i /redoc. Jeśli uzyskasz dostęp do tych stron za pomocą przeglądarki, znajdziesz interaktywny interfejs, który umożliwia wybranie dowolnej metody API, wyświetlenie akceptowanych przez nią danych i przetestowanie jej bezpośrednio w przeglądarce.

Programiści, testerzy i analitycy mogą monitorować zmiany w strukturze API wynikające z aktualizacji oprogramowania, monitorować dodawanie nowych pól, identyfikować błędy i sprawdzać serwer odpowiedzi.

Wady FastAPI

FastAPI to doskonały i szybki framework, ale nie jest pozbawiony pewnych wad.

Podejście asynchroniczne. Operacje asynchroniczne są jednym z czynników wpływających na wysoką szybkość FastAPI, ale wymagają ostrożności. Jeśli przypadkowo użyjesz kodu synchronicznego wewnątrz funkcji asynchronicznej, serwer będzie czekał na zakończenie tej operacji, co zniweczy wszystkie korzyści płynące z asynchroniczności. Dlatego tworzenie i debugowanie aplikacji w FastAPI może być trudniejszym zadaniem, szczególnie dla tych, którzy dopiero zaczynają przygodę z tą technologią.

Wydajność nie zawsze jest doskonała. FastAPI przewyższa Flask w sytuacjach, gdy konieczne jest jednoczesne obsłużenie dużej liczby żądań, zwłaszcza w trybie asynchronicznym. Jednak jeśli aplikacja obsługuje proste zadania pojedynczo, różnica w szybkości staje się ledwo zauważalna. W niektórych przypadkach Flask lub Django mogą działać nawet lepiej, ponieważ mają mniej wbudowanych sprawdzeń, co skraca czas przetwarzania każdego pojedynczego żądania.

Ekosystem FastAPI jest mniej rozwinięty. Podczas gdy Django to w pełni rozwinięte środowisko do tworzenia aplikacji internetowych, FastAPI przypomina raczej zestaw komponentów, z których programista musi złożyć wszystko, co potrzebne. Nie ma wbudowanych rozwiązań do administracji, zadań w tle ani zarządzania użytkownikami – programista musi sam zaimplementować algorytmy rejestracji, autoryzacji i potwierdzania wiadomości e-mail.

Ta metoda oferuje swobodę wyboru i elastyczność, ale wymaga dużego doświadczenia i czasu. FastAPI jest idealne dla tych, którzy wolą samodzielnie decydować, z których narzędzi korzystać, zamiast polegać na istniejącej architekturze.

Przeczytaj również:

Tworzenie idealnego interfejsu API internetowego: zalecenia i typowe błędy, których należy unikać

Tworzenie interfejsu API internetowego wymaga ostrożnego podejścia i znajomość wielu niuansów. Aby stworzyć naprawdę efektywny interfejs, ważne jest rozważenie kilku kluczowych aspektów i zwrócenie uwagi na typowe błędy.

Przede wszystkim kluczowe jest prawidłowe zaprojektowanie struktury API. Konieczne jest jasne zdefiniowanie, jakie dane będą dostępne i w jaki sposób użytkownicy będą mogli o nie wnioskować. Standardowe praktyki, takie jak stosowanie zasad RESTful, mogą znacznie uprościć proces tworzenia i interakcji z API. Ważne jest również, aby wziąć pod uwagę, że różni klienci mogą mieć różne wymagania, dlatego warto rozważyć elastyczność i rozszerzalność interfejsu.

Podczas projektowania ważne jest zachowanie spójności nazw punktów końcowych i typów żądań. To nie tylko ułatwia pracę programistom, ale także sprawia, że ​​API jest bardziej intuicyjne dla użytkowników. Ponadto prawidłowe użycie kodów statusu HTTP pozwala na jaśniejszą komunikację dotyczącą wyniku żądania, poprawiając ogólne wrażenia.

Bezpieczeństwo API jest równie ważne. Należy wdrożyć metody uwierzytelniania i autoryzacji, aby chronić dane i zapobiegać nieautoryzowanemu dostępowi. Korzystanie z tokenów i szyfrowania danych pomoże zwiększyć bezpieczeństwo Twojego API.

Dokumentacja to również dobry punkt wyjścia. Dobrze napisana i przejrzysta dokumentacja znacznie uprości proces integracji dla programistów korzystających z Twojego API. Ważne jest, aby szczegółowo opisać wszystkie możliwości interfejsu, przykłady żądań i odpowiedzi, a także wskazać możliwe błędy i sposoby ich rozwiązania.

Na koniec nie zapomnij o testowaniu. Regularne sprawdzanie funkcjonalności i wydajności Twojego API pomoże wcześnie zidentyfikować wady i poprawić jego jakość.

Zapoznając się z powyższymi zaleceniami i unikając typowych błędów, możesz stworzyć niezawodne i przyjazne dla użytkownika API internetowe, które spełni potrzeby Twoich użytkowników.

Tworzenie własnego API za pomocą FastAPI

Opracujemy pełnoprawne API, które będzie zawierało obsługę bazy danych, a także funkcje autoryzacji i uwierzytelniania użytkowników. Nie martw się, jeśli nie masz doświadczenia w pracy z bazami danych — użyjemy symulowanej. Ważne jest jednak, abyś posiadał podstawową znajomość Pythona w wersji 3.8 lub nowszej oraz rozumiał podstawy pracy z terminalem, w przeciwnym razie będziesz miał trudności z opanowaniem materiału.

Najpierw musisz utworzyć środowisko wirtualne. Środowisko wirtualne to odizolowane środowisko do pracy z Pythonem, oddzielone od głównego środowiska systemu operacyjnego. Jest to konieczne, aby uniknąć konfliktów między pakietami a systemem. Wprowadź następujące polecenie w terminalu:

Lub:

Utworzyłeś katalog o nazwie fastapi_project i zainstalowałeś środowisko wirtualne. Zakładając, że wszystkie kroki zostały wykonane poprawnie, folder fastapi_project powinien zawierać katalogi bin, include, lib, lib64, a także plik o nazwie pyvenv.cfg.

Teraz musisz aktywować środowisko. Jeśli używasz systemu Linux lub Mac:

W systemie Windows:

Jeśli wykonałeś wszystkie kroki, nazwa (fastapi_project) powinna zostać wyświetlona przed monitem w terminalu. Oznacza to, że Twoje środowisko zostało pomyślnie aktywowane.

Zainstaluj FastAPI:

Teraz, gdy projekt jest po pomyślnej konfiguracji możesz przystąpić do wykonywania zadań.

Przeczytaj także:

Instalacja PIP dla Pythona: przewodnik krok po kroku i polecenia klawiszowe

PIP, menedżer pakietów dla Pythona, umożliwia łatwą instalację i zarządzanie bibliotekami innych firm. Aby rozpocząć korzystanie z funkcji PIP, musisz ją zainstalować. Zobaczmy, jak to zrobić.

1. Sprawdź, czy Python jest zainstalowany. Otwórz terminal lub wiersz poleceń i wpisz polecenie:
«`
python —version
«`
lub
«`
python3 —version
«`
Jeśli Python jest zainstalowany, zobaczysz jego wersję. W przeciwnym razie musisz najpierw pobrać i zainstalować Pythona z oficjalnej strony internetowej.

2. Jeśli Python jest już zainstalowany, funkcja PIP może być zainstalowana razem z nim. Aby to zrobić, uruchom następujące polecenie:
«`
python -m Ensurepip
«`
lub
«`
python3 -m Ensurepip
«`

3. Jeśli masz już PIP, ale chcesz dokonać aktualizacji do najnowszej wersji, użyj polecenia:
«`
python -m pip install —upgrade pip
«`
lub
«`
python3 -m pip install —upgrade pip
«`

Po zainstalowaniu PIP możesz zacząć go używać do instalowania bibliotek. Oto kilka podstawowych poleceń, które mogą Ci się przydać:

— Aby zainstalować pakiet, uruchom polecenie:
«`
pip install nazwa_pakietu
«`

— Aby odinstalować pakiet, użyj polecenia:
«`
pip uninstall nazwa_pakietu
«`

— Aby wyświetlić listę wszystkich zainstalowanych pakietów, uruchom polecenie:
«`
pip list
«`

— Aby uzyskać informacje o konkretnym pakiecie, użyj:
«`
pip show package_name
«`

Te polecenia pomogą Ci efektywnie zarządzać bibliotekami Pythona za pomocą PIP.

Zacznijmy tworzyć nasze pierwsze API. W tym celu utwórz plik main.py w katalogu fastapi_project i wklej do niego następujący kod:

Aby uruchomić serwer, upewnij się, że jesteś w katalogu fastapi_project:

Uruchom przeglądarkę i wpisz adres http://127.0.0.1:8000. Na ekranie pojawi się komunikat {«message»: «Witaj świecie»}.

Dokumentację można przeglądać pod następującym adresem: http://127.0.0.1:8000/docs. Następnie wybierz GET /, kliknij przycisk „Wypróbuj”, a następnie uruchom polecenie, aby zobaczyć wynik.

Odpowiedź będzie widoczna również w terminalu.

Aby zamknąć serwer, użyj kombinacji klawiszy Ctrl + C. Ponowne uruchomienie serwera po edycji kodu nie jest możliwe. Wymagane, ponieważ FastAPI ma funkcję automatycznego ładowania zmian. Jeśli Twój edytor tekstu nie ma funkcji automatycznego zapisywania, pamiętaj o zapisaniu pliku po każdej zmianie, w przeciwnym razie zmiany w kodzie nie zostaną uwzględnione na serwerze.

Punkty końcowe to adresy w interfejsie API, których klienci używają do wysyłania żądań. Korzystaliśmy już z automatycznie utworzonego punktu końcowego /docs podczas przeglądania dokumentacji. Teraz utwórzmy nasz własny. Aby to zrobić, utwórz plik o nazwie endpoints.py w katalogu fastapi_project:

Edytujmy plik main.py, importując funkcję register_endpoints i wywołując ją.

Sprawdźmy, czy wszystko działa poprawnie. Otwórz link http://127.0.0.1:8000/items/5 — w odpowiedzi powinieneś zobaczyć {«item_id»: 5}.

Podczas próby dostępu do adresu http://127.0.0.1:8000/items/abc, FastAPI wygeneruje błąd, ponieważ oczekuje przekazania liczby w tym miejscu.

Struktura reprezentowana przez {«item_id»: 5} jest powszechnie nazywana parametrem ścieżki. Jest to element adresu URL, który może się zmieniać. W tym przykładzie po fragmencie items/ można wstawić dowolną liczbę całkowitą.

Wprowadźmy parametr zapytania — jest to informacja przekazywana przez adres URL po symbolu ?. Na przykład adres http://127.0.0.1:8000/items/5?q=hello przekazuje parametr q o wartości hello. Użycie parametrów zapytania pozwala na wygodne przekazywanie dodatkowych informacji, takich jak zapytania wyszukiwania. Teraz zmieńmy punkt końcowy items/:

Teraz, klikając link http://127.0.0.1:8000/items/5?q=hello, otrzymamy następującą odpowiedź: {«item_id»: 5, «q»: «hello»}.

Pod adresem http://127.0.0.1:8000/items/5 możesz zobaczyć następującą odpowiedź: {«item_id»: 5, «q»: null}.

W niektórych przypadkach konieczne jest ustawienie ograniczeń na wartości, które użytkownik może przekazać za pośrednictwem adresu URL. Załóżmy na przykład, że utworzymy punkt końcowy models/ z parametrem {model}, który może akceptować tylko dwie wartości: a i b. Wbudowany moduł Enum idealnie nadaje się do tego celu, ponieważ został zaprojektowany do tworzenia wyliczeń stałych. W pliku endpoints.py dodaj import dla Enum i utwórz klasę do przechowywania tych wartości:

Na końcu funkcji register_endpoints zaimplementujemy nowy punkt końcowy, uwzględniając poprawne wcięcie:

Przejdź do http://127.0.0.1:8000/models/a, a otrzymasz odpowiedź w formacie {«model»: «a»}. To samo stanie się, jeśli przejdziesz do http://127.0.0.1:8000/models/b. Jeśli jednak spróbujesz uzyskać dostęp do http://127.0.0.1:8000/models/c, FastAPI zwróci błąd, ponieważ c nie znajduje się na liście prawidłowych wartości określonych w modelu.