Hoe gebruik je Fast API met een relatieve database op Ubuntu

Inleiding

FastAPI heeft snel populariteit gekregen als een hoogscore, gemakkelijk te gebruiken webframeWork voor het bouwen van API’s met Python. Wanneer gekoppeld aan een relatieve database, kan FastAPI worden gebruikt om krachtige, schaalbare toepassingen te maken. Deze gids zal u door het proces van het instellen van een FastAPI-toepassing met een relatieve database op een Ubuntu 24.04-machine leiden. We zullen alles van het installeren van de nodige gereedschappen tot het configureren van de database en het maken van API-eindpunten behandelen.

Gebruik FastAPI met PostgreSQL-database

• Python-omgeving opzetten
• Maak en activeer virtuele omgeving
• Installeer en configureer PostgreSQL
• Snelle FastAPI-toepassing maken
• Installeer vereiste bibliotheken
• Uitvoeren van Python-toepassing
• Testen van FastAPI-toepassingsendpoints

Vereisten

Voordat u de stappen in deze handleiding volgt, heeft u nodig:

• Een server die Ubuntu draait, samen met een niet-rootgebruiker die sudo-rechten heeft en een actieve brandmuur. Voor richtlijnen over hoe u dit kunt instellen, kies uw distributie uit deze lijst en volg onze handleiding voor de eerste serverconfiguratie. Zorg ervoor dat u werkt met een ondersteunde versie van Ubuntu.

• Bekendheid met de Linux commandoregel. Voor een introductie of herinnering aan de commandoregel kunt u deze handleiding over Linux command line primer bezoeken.

• Voer sudo apt-get update in in de Ubuntu terminal uit om er voor te zorgen dat uw systeem de最新versies en beveiligingsupdates heeft voor de software beschikbaar in de op uw systeem geconfigureerde opslagplaatsen.

Stap 1 – Python-omgeving instellen

Ubuntu 24.04 bevat Python 3 standaard. Open het terminal en voer het volgende commando uit om te kijken of Python 3 al geïnstalleerd is:

python3 --version

Als Python 3 al geïnstalleerd is op uw machine, zal dit commando de huidige versie van de Python 3-instelling teruggeven. In het geval dat het niet geïnstalleerd is, kunt u het volgende commando uitvoeren om de Python 3-installatie te krijgen:

sudo apt install python3

Vervolgens moet u de pakketinstallers pip en dev op uw systeem installeren. Voer het volgende commando in het terminal uit:

sudo apt install python3-pip python3-dev

In deze handleiding zullen we PostgreSQL gebruiken als onze relatieve database. Om te interageren met de PostgreSQL-database, moet u de libpq-dev installeren met behulp van het volgende commando:

sudo apt install libpq-dev

Stap 2 – Maak en activeer virtuele omgeving

De volgende stap is het maken van een virtuele omgeving binnen uw Ubuntu-installatie om Python-pakketten van uw systeemomgeving af te isoleren. Om dit te doen, ga naar uw werkdirectory en voer de volgende reeks commando’s uit:

python3 -m venv fastapi-env

Dit commando zal een nieuwe virtuele omgeving aanmaken in een directory genaamd fastapi-env. Het zal zijn eigen set toegewezen Python-pakketten hebben, afgeschermd van andere projecten.

Om te waarborgen dat de pakketten die u vanaf nu installeert worden geïnstalleerd binnen deze afgescheiden omgeving, moet u deze activeren door uit te voeren:

source fastapi-env/bin/activate

Bij uitvoering zult u zien dat de terminalprompt voorafgegaan wordt door de naam van uw virtuele omgeving, zoals dit:

Output
(fastapi-env) ubuntu@user:

Stap 3 – PostgreSQL installeren en configureren

De volgende stap is het installeren van PostgreSQL (of uw keuze van een relatie database).

sudo apt install postgresql postgresql-contrib

Nu is het tijd om de PostgreSQL-dienst te starten en toe te voegen binnen uw virtuele omgeving.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Om PostgreSQL te installeren en te gebruiken met FastAPI, moet u een aantal dingen installeren:

1. asyncpg: Dit is een asynchrone PostgreSQL-stuurprogramma dat FastAPI toestaat om te interageren met een PostgreSQL-database.
2. SQLAlchemy: Dit is een ORM-hulpmiddel dat u helpt database schema’s en queries te beheren met Python-code in plaats van handgeschreven SQL te schrijven.
3. databases: Dit is een databasebibliotheek voor asynchroon gehandeld nodig door SQLAlchemy om asynchroon met FastAPI te werken.

Om deze te installeren, voer de volgende samengevatte opdracht uit:

pip install asyncpg sqlalchemy databases

Volgend, maak een Postgres-database en een gebruiker aan met de vereiste privileges.

sudo -u postgres psql
CREATE DATABASE <user_db>;
CREATE ROLE <username> WITH PASSWORD '<password>';
GRANT ALL PRIVILEGES ON DATABASE <user_db> TO <username>;
exit

Stap 4 – Maak een voorbeeld Python-toepassing

U heeft een uitvoerbare Python-toepassing nodig die toegang tot uw database krijgt via FastAPI. Als u geen draaiende Python-toepassing heeft, kunt u een ervan snel aanmaken door de volgende stappen te volgen:

Maak een nieuwe Python-bestand aan genaamd postgres_db.py in uw projectdirectory.

nano postgres_db.py

In de tekstverwerker zult u logica schrijven om een databaseverbinding te maken en een tabel binnen de database aan te maken. In dit voorbeeld maken we een verbinding met de PostgreSQL-database door middel van het pakket databases en definiëren we de structuur van een books-tabel met behulp van SQLAlchemy.

from databases import Database
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Float

DB_URL = "postgresql://username:password@localhost/user_db"

database = Database(DB_URL)
metadata = MetaData()

books = Table (
  "books",
  metadata,
  Column("id", Integer, primary_key=True, index=True),
  Column("title", String, index=True),
  Column("author", String, index=True),
  Column("price", Float),
)

engine = create_engine(DB_URL)
metadata.create_all(engine)

Sla het bestand op en sluit het af.

Vervolgens maak een main.py binnen hetzelfde directory.

nano main.py

Schrijf de hoofdlogica van uw toepassing in dit bestand:

from fastapi import FastAPI
from typing import List
from pydantic import BaseModel
from postgres_db import books, database

app = FastAPI()

class BookCreate(BaseModel):
    title: str
    author: str
    price: float

class BookResponse(BaseModel):
    id: int
    title: str
    author: str
    price: float

class Config:
  orm_mode=True

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.post("/books/", response_model=BookResponse)
async def create_book(book: BookCreate):
    query = books.insert().values(title=book.title, author=book.author, price=book.price)
    last_book_id = await database.execute(query)

    query = books.select().where(books.c.id == last_book_id)
    inserted_book = await database.fetch_one(query)
    return inserted_book

@app.get("/books/", response_model=List[BookResponse])
async def get_books():
    query = books.select()
    return await database.fetch_all(query)

Dit code gebruikt FastAPI om nieuwe boekeninschrijvingen in de PostgreSQL-database te schrijven en de verzameling boeken daaruit op te halen.

Stap 5 – Installeer Vereiste Bibliotheken

In uw Python-toepassing verwijst u naar verschillende bibliotheken en pakketten. voordat u de toepassing draait, zorg ervoor dat u de vereiste bibliotheken hebt geïnstalleerd.

pip install fastapi uvicorn psycopg2

Stap 6 – Uitvoeren van de Python-toepassing

Nu is het tijd om de applicatie die u heeft gemaakt te draaien.

uvicorn main:app --reload

uvicorn is een Asynchronous Server Gateway Interface (ASGI) die wordt gebruikt om FastAPI-toepassingen te hosten. Het gebruik van uvicorn is de voorkeursmethode om een FastAPI-toepassing te draaien, aangezien FastAPI zelf een asynchrone webframework is.

Als de bovenstaande opdracht zonder fouten wordt uitgevoerd, zult u een uitvoer zien die er ongeveer uitziet:

Output
INFO:     Will watch for changes in these directories: ['/path/to/your/project']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [XXXX] using StatReload
INFO:     Started server process [YYYY]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

In een webbrowser navigeer naar http://127.0.0.1:8000 om de queryuitvoer te zien.

Stap 7 [OPTIONEEL] – Test de Endpoints

U kunt de endpoints die zijn gedefinieerd in uw main.py (d.w.z. POST en GET) testen door HTTP-verzoeken naar de server die draait op http://127.0.0.1:8000 te versturen.

{
  "title": "The Great Gatsby",
  "author": "F. Scott Fitzgerald",
  "price": 10.99
}

Hetzelfde geldt voor een GET-aanroep naar dezelfde server om de lijst van boeken op te halen die in uw Postgres-database aanwezig zijn.

Conclusie

In deze handleiding heb je de stappen doorlopen om een eenvoudige FastAPI-toepassing op te zetten die interactie heeft met een PostgreSQL-database. Deze stappen zijn ook nuttig voor AI-toepassingen, vooral wanneer u een web API moet bouwen om te interactieven met uw AI-modellen of om gegevens te beheren die gerelateerd zijn aan uw AI-processen. Met deze basis in plaats kun je nu uw FastAPI-projecten bouwen en uitbreiden.

Blijf gemakkelijk op de hoogte van meer artikelen over hoe te werken met FastAPI.