Dowiedz się, jak utworzyć RESTful API przy użyciu Flask i Postgres, umożliwiając bezproblemową wymianę danych między Twoją aplikacją a systemami zewnętrznymi.

Interfejsy programowania aplikacji (API) są kluczowym elementem budowania i łączenia różnych systemów, umożliwiając aplikacjom komunikację i wymianę danych z innymi usługami.

Chociaż tworzenie zaplecza obejmuje coś więcej niż tylko pisanie interfejsów API — obejmuje również pisanie logiki biznesowej po stronie serwera, projektowanie wydajnego systemu architektury i inne kluczowe funkcje, czytaj dalej, aby dowiedzieć się, jak zbudować proste API CRUD REST z Flask (lekki framework Python) i Postgres Baza danych.

Korzystanie z Flask do tworzenia interfejsów API zaplecza

Kolba jest lekki Ramy Pythona który zapewnia szereg funkcji upraszczających pisanie interfejsów API zaplecza dla klientów sieciowych napisanych przy użyciu różnych technologii, takich jak React i Angular.

Możesz znaleźć kod źródłowy tego projektu w this Repozytorium GitHub.

instagram viewer

Ten przewodnik przeprowadzi Cię przez proces pisania Interfejs API REST, który implementuje cztery operacje CRUD: twórz, czytaj, aktualizuj i usuwaj, aby zarządzać danymi użytkownika przechowywanymi w bazie danych Postgres.

Skonfiguruj bazę danych Postgres

Aby rozpocząć, przejdź do ElephantSQL, oparte na chmurze rozwiązanie do hostingu baz danych, które zapewnia platformę do tworzenia baz danych Postgres w chmurze i zarządzania nimi, rejestrowania się i logowania na stronie przeglądu konta.

Kliknij Utwórz nową instancję przycisk, aby utworzyć nową instancję dla Twojej aplikacji.

Podaj nazwę swojej instancji i wybierz bezpłatny plan, a na koniec wybierz region, w którym będzie hostowana instancja, aby zakończyć proces instalacji.

Po utworzeniu instancji przejdź do strony ustawień i skopiuj plik URL bazy danych, wykorzystasz go do nawiązania połączenia z bazą danych.

Skonfiguruj serwer Flask

Na swoim terminalu utwórz folder projektu i zmień bieżący katalog na ten nowy folder.

Przed zainstalowaniem Flask potwierdź, że używasz Pythona w wersji 3.6+ na swoim komputerze. Jeśli nie, musisz zainstalować najnowszą Pyton wersja.

python — wersja

Następnie zainstaluj wirtualna, aby stworzyć izolowane wirtualne środowisko programistyczne.

pip zainstaluj virtualenv

Następnie uruchom poniższe polecenie, aby utworzyć środowisko wirtualne.

wirtualna wartość venv

Na koniec aktywuj środowisko wirtualne.

# W systemie Windows: 
.\venv\Scripts\aktywacja
# W systemie Unix lub MacOS: 
źródło venv/bin/aktywuj

Zainstaluj wymagane pakiety

W katalogu głównym folderu projektu utwórz plik wymagania.txt plik i dodaj te pakiety.

kolba
python-dotenv
psycopg2-binarny

Następnie zainstaluj pakiety.

pip install -r wymagania.txt

The psycopg2-binarny to biblioteka Pythona, która działa jako oprogramowanie pośredniczące, umożliwiające nawiązywanie połączeń z bazą danych Postgres i wykonywanie różnych operacji na bazie danych.

Na koniec utwórz a .env plik i wklej adres URL bazy danych.

DATABASE_URL= URL twojej bazy danych

Utwórz serwer Flask

Na koniec utwórz plik aplikacja.py plik w katalogu głównym i dodaj poniższy kod.

import os 
import psycopg2
z dotenv import ładuj_dotenv
z kolba import Kolba, prośba, jsonify
load_dotenv()


aplikacja = Kolba (__nazwa__)
url = os.pobierz(„URL_BAZY DANYCH”)
połączenie = psycopg2.connect (url)
@app.get("/")
pokdom():
powrót"Witaj świecie"

Ten kod konfiguruje instancję aplikacji Flask. Następnie tworzy połączenie z bazą danych określoną w ciągu adresu URL, a na koniec ustawia trasę domową, która zwraca ciąg jako odpowiedź.

Utwórz interfejs API REST umożliwiający operacje CRUD

Teraz zbuduj interfejs API REST, który implementuje cztery operacje CRUD.

Utwórz tabelę demonstracyjną

Utwórz tabelę użytkowników w bazie danych.

W pliku app.py dodaj poniższy kod.

CREATE_USERS_TABLE = „UTWÓRZ TABELĘ, JEŚLI NIE ISTNIEJE użytkowników (identyfikator SERIAL PRIMARY KEY, nazwa TEKST);”
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.execute (CREATE_USERS_TABLE)
  • Ten kod tworzy nową tabelę PostgreSQL o nazwie użytkownicy z dwiema kolumnami.
  • Wykorzystuje metodę połączenia psycopg2 do nawiązania połączenia z bazą danych i tworzy nowy obiekt kursora za pomocą metody połączenie.kursor metoda, która jest używana do wykonania zapytania SQL.

1. Zdefiniuj metodę POST

Utwórz trasę pocztową, aby dodać dane.

INSERT_USER_RETURN_ID = „INSERT INTO users (name) VALUES (%s) RETURNING id”;
@app.route("/api/user", metody=["POST"])
pokStwórz użytkownika():
 dane = żądanie.get_json()
 nazwa = dane["nazwa"]
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.execute (INSERT_USER_RETURN_ID, (nazwa,))
 identyfikator_użytkownika = kursor.pobieranie()[0]
powrót {"ID": identyfikator użytkownika, "nazwa": nazwa, "wiadomość": f"Użytkownik {nazwa} Utworzony."}, 201
  • Ciąg zapytania SQL definiuje instrukcję SQL, która zostanie wykonana przy użyciu kursor.wykonaj metodę wstawiania nowego wiersza z nazwą użytkownika do pliku użytkowników tabela w bazie danych. Zwraca identyfikator nowo utworzonego użytkownika.
  • The Stwórz użytkownika funkcja przyjmuje nazwę jako parametr do przechowywania w bazie danych, podczas gdy funkcja kursor.pobierz Metoda jest wywoływana w celu pobrania identyfikatora nowo utworzonego użytkownika. Na koniec zwracany jest słownik zawierający identyfikator i nazwę nowo utworzonego użytkownika, wraz z komunikatem wskazującym, że użytkownik został pomyślnie utworzony.

2. Zdefiniuj metodę GET

Zdefiniuj dwie trasy pobierania: jedną, aby pobrać wszystkie dane z bazy danych, i dwie, aby pobrać określone dane z bazy danych na podstawie identyfikatora.

SELECT_ALL_USERS = „WYBIERZ * OD użytkowników;”
@app.route("/api/user", metody=["GET"])
pokget_all_users():
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.wykonaj (SELECT_ALL_USERS)
 użytkownicy = kursor.pobierz()
Jeśli użytkownicy:
 wynik = []
Do użytkownik W użytkownicy:
 wynik.dołącz({"ID": użytkownik[0], "nazwa": użytkownik[1]})
powrót jsonify (wynik)
w przeciwnym razie:
powrót jsonify({"błąd": f"Nie znaleziono użytkowników."}), 404
@app.route("/api/użytkownik/", metody=["POBIERZ"])
pokpobierz_użytkownika(identyfikator użytkownika):
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.wykonaj(„WYBIERZ * Z użytkowników WHERE id = %s”, (identyfikator użytkownika,)) 
 użytkownik = kursor.pobierz()
Jeśli użytkownik:
powrót jsonify({"ID": użytkownik[0], "nazwa": użytkownik[1]})
w przeciwnym razie:
powrót jsonify({"błąd": f"Użytkownik z identyfikatorem {identyfikator użytkownika} nie znaleziono."}), 404
  • Ta pierwsza trasa API obsługuje żądania HTTP GET w celu pobrania wszystkich użytkowników z bazy danych. Pobiera wszystkich użytkowników z bazy danych i zwraca wyniki w formacie JSON w odpowiedzi.
  • Ta druga trasa API obsługuje żądania HTTP GET w celu pobrania danych dla określonego użytkownika z bazy danych. Zajmuje identyfikator użytkownika jako parametr pobiera dane użytkownika z bazy danych i zwraca wyniki w formacie JSON w odpowiedzi.

3. Zdefiniuj metodę PUT

Utwórz trasę put, aby zaktualizować dane przechowywane w bazie danych.

@app.route("/api/użytkownik/", metody=["PUT"])
pokużytkownik_aktualizacji(identyfikator użytkownika):
 dane = żądanie.get_json()
 nazwa = dane["nazwa"]
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.execute (UPDATE_USER_BY_ID, (nazwa, identyfikator_użytkownika))
Jeśli kursor.liczba wierszy == 0:
powrót jsonify({"błąd": f"Użytkownik z identyfikatorem {identyfikator użytkownika} nie znaleziono."}), 404
powrót jsonify({"ID": identyfikator użytkownika, "nazwa": nazwa, "wiadomość": f"Użytkownik z identyfikatorem {identyfikator użytkownika} zaktualizowane”.})
  • The użytkownik_aktualizacji Funkcja pobiera parametr identyfikatora użytkownika jako dane wejściowe i używa go do aktualizacji nazwy określonego użytkownika w bazie danych.
  • Jeśli operacja aktualizacji zakończy się pomyślnie, zwraca obiekt JSON ze zaktualizowanym identyfikatorem użytkownika, nazwą i komunikatem o powodzeniu w odpowiedzi.

4. Zdefiniuj metodę DELETE

Zaimplementuj trasę usuwania, aby usunąć zapisane dane określonego użytkownika w bazie danych.

@app.route("/api/użytkownik/", metody=["USUŃ"])
pokUsuń użytkownika(identyfikator użytkownika):
z połączenie:
z połączenie.kursor() Jak kursor:
 kursor.execute (DELETE_USER_BY_ID, (identyfikator_użytkownika,))
Jeśli kursor.liczba wierszy == 0:
powrót jsonify({"błąd": f"Użytkownik z identyfikatorem {identyfikator użytkownika} nie znaleziono."}), 404
powrót jsonify({"wiadomość": f"Użytkownik z identyfikatorem {identyfikator użytkownika} usunięte."})
  • Ta trasa interfejsu API obsługuje funkcję usuwania określonego użytkownika z bazy danych na podstawie jego identyfikatora. Jeśli użytkownik nie zostanie znaleziony, zwraca kod stanu 404 z komunikatem o błędzie. Jeśli jednak operacja usunięcia zakończy się pomyślnie, zwraca obiekt JSON z komunikatem o powodzeniu w odpowiedzi.

Pisanie interfejsów API REST za pomocą Flask

W tym przewodniku pokazano, jak używać Flask i Postgres do zbudowania prostego interfejsu API REST CRUD, a także jak to zrobić nawiązać połączenie z bazą danych i wykonać różne zapytania SQL w celu odczytu i zapisu danych do Baza danych. Możesz teraz utworzyć prosty interfejs API REST, który może obsłużyć cztery operacje CRUD wymagane w dowolnej aplikacji internetowej.

Niezależnie od tego, czy budujesz prosty blog, czy złożoną aplikację internetową, Flask i Postgres oferują potężne funkcje i możliwości wymagane do stworzenia solidnego systemu zaplecza. Alternatywnie możesz skorzystać z innych technologii, takich jak FastAPI i MongoDB, aby zbudować interfejsy API RESTful.