Hur man bygger ett REST API med Flask och Postgres Database

Application Programming Interfaces (API) är en kritisk del av att bygga och koppla ihop olika system, vilket gör att dina applikationer kan kommunicera och utbyta data med andra tjänster.

Även om utveckling av backend involverar mer än att bara skriva API: er - omfattar den också att skriva affärslogik på serversidan, design av effektivt system arkitekturer och andra nyckelfunktioner, läs vidare för att lära dig hur du bygger ett enkelt CRUD REST API med Flask (ett lätt Python-ramverk) och Postgres databas.

Använda Flask för att bygga backend-API: er

Flaska är en lättviktare Python ramverk som ger ett antal funktioner för att förenkla skrivning av backend-API: er för webbklienter skrivna med olika tekniker som React och Angular.

Du kan hitta detta projekts källkod i denna GitHub-förråd.

Den här guiden hjälper dig att skriva en REST API som implementerar de fyra CRUD-operationerna

: skapa, läs, uppdatera och ta bort för att hantera användardata som lagras i en Postgres-databas.

Skapa en Postgres-databas

För att komma igång, gå över till ElephantSQL, en molnbaserad databasvärdlösning som ger en plattform för att skapa och hantera Postgres-databaser på molnet, registrera dig och logga in på ditt kontos översiktssida.

Klicka på Skapa ny instans för att skapa en ny instans för din applikation.

Ange namnet på din instans och välj den kostnadsfria planen, och välj slutligen den region där instansen ska vara värd för att slutföra installationsprocessen.

När instansen har skapats, navigera till inställningssidan och kopiera databasens URL, kommer du att använda den för att upprätta en anslutning till databasen.

Konfigurera en kolvserver

På din terminal skapar du en projektmapp och ändrar den aktuella katalogen till den nya mappen.

Innan du installerar Flask, bekräfta att du kör Python version 3.6+ på din maskin. Om inte måste du installera den senaste Pytonorm version.

python --version

Installera sedan virtualenv, för att skapa en isolerad virtuell utvecklingsmiljö.

pip installera virtualenv

Kör sedan kommandot nedan för att skapa en virtuell miljö.

virtualenv venv

Slutligen, aktivera den virtuella miljön.

# På Windows: 
.\venv\Scripts\aktivera
# På Unix eller MacOS: 
source venv/bin/activate

Installera de nödvändiga paketen

I rotkatalogen i din projektmapp skapar du en krav.txt fil och lägg till dessa paket.

flaska
python-dotenv
psychopg2-binär

Installera sedan paketen.

pip installation -r requirements.txt

De psychopg2-binär är ett Python-bibliotek som fungerar som ett mellanprogram, så att du kan upprätta förbindelser med din Postgres-databas och utföra olika databasoperationer.

Slutligen, skapa en .env fil och klistra in din databas-URL.

DATABASE_URL= din databas-URL

Skapa kolvservern

Slutligen, skapa en app.py filen i rotkatalogen och lägg till koden nedan.

importera os 
importera psychopg2
från dotenv importera load_dotenv
från flaska importera Flask, request, jsonify
load_dotenv()
app = Kolv (__namn__)
url = os.getenv("DATABASE_URL")
anslutning = psychopg2.connect (url)
@app.get("/")
defHem():
lämna tillbaka"Hej världen"

Denna kod skapar en instans av Flask-applikationen. Den skapar sedan en anslutning till databasen som anges i URL-strängen och ställer slutligen upp en hemväg som returnerar en sträng som ett svar.

Skapa REST API som möjliggör CRUD-operationer

Bygg nu REST API som implementerar de fyra CRUD-operationerna.

Skapa en demotabell

Skapa en användartabell i databasen.

Lägg till koden nedan i filen app.py.

CREATE_USERS_TABLE = "SKAPA TABELL OM INTE FINNS användare (id SERIELL PRIMÄRNYCKEL, namn TEXT);"
med förbindelse:
med connection.cursor() som markör:
 cursor.execute (CREATE_USERS_TABLE)

• Denna kod skapar en ny PostgreSQL-tabell som heter användare med två kolumner.
• Den använder anslutningsmetoden psycopg2 för att upprätta anslutningen till databasen och skapar ett nytt markörobjekt med hjälp av anslutningsmarkör metod som används för att utföra SQL-frågor.

1. Definiera POST-metoden

Skapa postrutten för att lägga till data.

INSERT_USER_RETURN_ID = "INSERT INTO users (name) VALUES (%s) RETURNING id;"
@app.route("/api/user", methods=["POST"])
defskapa användare():
 data = request.get_json()
 namn = data["namn"]
med förbindelse:
med connection.cursor() som markör:
 cursor.execute (INSERT_USER_RETURN_ID, (namn,))
 user_id = cursor.fetchone()[0]
lämna tillbaka {"id": användar ID, "namn": namn, "meddelande": f"Användare {namn} skapat."}, 201

• SQL-frågesträngen definierar en SQL-sats som kommer att exekveras med hjälp av cursor.execute metod för att infoga en ny rad med en användares namn i användarnas tabell i databasen. Den returnerar den nyskapade användarens ID.
• De skapa användare funktionen tar in ett namn som en parameter att lagra i databasen medan cursor.fetchone metod anropas för att hämta den nyskapade användarens ID. Slutligen returneras en ordbok som innehåller den nyskapade användarens ID och namn, tillsammans med ett meddelande som anger att användaren skapades framgångsrikt.

2. Definiera GET-metoden

Definiera två hämta-rutter: en, för att hämta all data i databasen, och två, för att hämta specifik data från databasen baserat på ID.

SELECT_ALL_USERS = "VÄLJ * FRÅN användare;"
@app.route("/api/user", methods=["GET"])
deffå_alla_användare():
med förbindelse:
med connection.cursor() som markör:
 cursor.execute (SELECT_ALL_USERS)
 användare = cursor.fetchall()
om användare:
 resultat = []
för användare i användare:
 result.append({"id": användare[0], "namn": användare[1]})
lämna tillbaka jsonify (resultat)
annan:
lämna tillbaka jsonify({"fel": f"Användare hittades inte."}), 404
@app.route("/api/användare/", methods=["GET"])
defget_user(användar ID):
med förbindelse:
med connection.cursor() som markör:
 cursor.execute("VÄLJ * FRÅN användare WHERE id = %s", (användar ID,)) 
 användare = cursor.fetchone()
om användare:
lämna tillbaka jsonify({"id": användare[0], "namn": användare[1]})
annan:
lämna tillbaka jsonify({"fel": f"Användare med ID {användar ID} hittades inte."}), 404

• Denna första API-rutt hanterar HTTP GET-förfrågningar för att hämta alla användare från databasen. Den hämtar alla användare från databasen och returnerar resultaten i ett JSON-format i svaret.

• Denna andra API-rutt hanterar HTTP GET-förfrågningar för att hämta data för en specifik användare från databasen. Den tar in användar ID som en parameter, hämtar användarens data från databasen och returnerar resultaten i ett JSON-format i svaret.

3. Definiera PUT-metoden

Skapa putsrutten för att uppdatera lagrad data i databasen.

@app.route("/api/användare/", methods=["PUT"])
defupdate_user(användar ID):
 data = request.get_json()
 namn = data["namn"]
med förbindelse:
med connection.cursor() som markör:
 cursor.execute (UPDATE_USER_BY_ID, (namn, användar-id))
om cursor.rowcount == 0:
lämna tillbaka jsonify({"fel": f"Användare med ID {användar ID} hittades inte."}), 404
lämna tillbaka jsonify({"id": användar ID, "namn": namn, "meddelande": f"Användare med ID {användar ID} uppdaterad."})

• De update_user funktionen tar parametern användar-ID som indata och använder den för att uppdatera namnet på den angivna användaren i databasen.
• Om uppdateringen lyckas returnerar den ett JSON-objekt med det uppdaterade användar-ID, namn och ett framgångsmeddelande i svaret.

4. Definiera DELETE-metoden

Implementera borttagningsvägen för att radera lagrad data för en specifik användare i databasen.

@app.route("/api/användare/", methods=["DELETE"])
defdelete_user(användar ID):
med förbindelse:
med connection.cursor() som markör:
 cursor.execute (DELETE_USER_BY_ID, (user_id,))
om cursor.rowcount == 0:
lämna tillbaka jsonify({"fel": f"Användare med ID {användar ID} hittades inte."}), 404
lämna tillbaka jsonify({"meddelande": f"Användare med ID {användar ID} raderade."})

• Denna API-rutt hanterar raderingsfunktionen för en specifik användare från databasen baserat på deras ID. Om användaren inte hittas returnerar den en 404-statuskod med ett felmeddelande. Men om borttagningen lyckas, returnerar den ett JSON-objekt med ett framgångsmeddelande i svaret.

Skriva REST API: er med kolv

Den här guiden visar hur man använder Flask och Postgres för att bygga ett enkelt CRUD REST API tillsammans med hur att upprätta en databasanslutning och exekvera olika SQL-frågor för att läsa och skriva data till en databas. Du kan nu skapa ett enkelt REST API som kan hantera de fyra CRUD-operationer som krävs i vilken webbapplikation som helst.

Oavsett om du bygger en enkel blogg eller en komplex webbapplikation erbjuder Flask och Postgres kraftfulla funktioner och kapaciteter som krävs för att skapa ett robust backend-system. Alternativt kan du använda andra tekniker som FastAPI och MongoDB för att bygga RESTful API: er.