Comment utiliser Fast API avec une base de données relationnelle sur Ubuntu

Introduction

FastAPI a rapidement gagné en popularité en tant que framework web hautement performant et facile à utiliser pour construire des API avec Python. En association avec une base de données relationnelle, FastAPI peut être utilisé pour créer des applications puissantes et scalables. Ce guide vous guidera à travers le processus de configuration d’une application FastAPI avec une base de données relationnelle sur une machine Ubuntu 24.04. Nous aborderons tout, depuis l’installation des outils nécessaires jusqu’à la configuration de la base de données et la création des extrémités API.

Utilisez FastAPI avec une Base de Données PostgreSQL

• Configuration de l’Environnement Python
• Créer et Activer un Environnement Virtuel
• Installer et Configurer PostgreSQL
• Créer une application FastAPI
• Installer les bibliothèques requises
• Exécuter l’application Python
• Tester les points d’entrée des applications FastAPI

Prérequis

Avant de suivre les étapes de ce tutoriel, vous devez :

• Un serveur fonctionnant sous Ubuntu ainsi qu’un utilisateur non-root avec des privilèges sudo et un pare-feu actif. Pour de la guidance sur la configuration de cela, veuillez choisir votre distribution de cette liste et suivez notre guide de configuration initiale du serveur. Veuillez vous assurer de travailler avec une version supportée d’Ubuntu.

• Familiarité avec la ligne de commande Linux. Pour une introduction ou un rappel à la ligne de commande, vous pouvez visiter ce guide sur le primer de la ligne de commande Linux.

• Exécutez sudo apt-get update dans le terminal Ubuntu pour vous assurer que votre système dispose des dernières versions et des mises à jour de sécurité des logiciels disponibles à partir des dépôts configurés sur votre système.

Étape 1 – Configuration de l’environnement Python

Ubuntu 24.04 fournit Python 3 par défaut. Ouvrez le terminal et exécutez le commande suivante pour vérifier l’installation de Python 3 :

python3 --version

Si Python 3 est déjà installé sur votre machine, ce commande retournera la version actuelle de l’installation de Python 3. Dans le cas contraire, vous pouvez exécuter la commande suivante pour installer Python 3 :

sudo apt install python3

Next, you need to install the pip and dev package installers on your system. Run the following command in the terminal:

sudo apt install python3-pip python3-dev

Dans ce tutoriel, nous utiliserons PostgreSQL comme base de données relationnelle. Pour interagir avec la base de données PostgreSQL, vous devez installer libpq-dev en utilisant la commande suivante :

sudo apt install libpq-dev

Étape 2 – Créer et activer le environnement virtuel

La prochaine étape consiste à créer un environnement virtuel à l’intérieur de votre installation d’Ubuntu pour isoler les paquets Python de votre environnement système. Pour ce faire, allez dans votre dossier de travail et exécutez les commandes suivantes :

python3 -m venv fastapi-env

Cette commande créera un nouvel environnement virtuel dans un dossier nommé fastapi-env. Il aura son propre ensemble de paquets Python dédiés, isolés d’autres projets.

Afin que les paquets que vous installez à partir de maintenant soient installés dans cet environnement isolé, vous devez le激活er en exécutant :

source fastapi-env/bin/activate

À l’exécution, vous remarquerez que le prompt de terminal est précédé du nom de votre environnement virtuel comme ceci :

Output
(fastapi-env) ubuntu@user:

Étape 3 – Installer et configurer PostgreSQL

La prochaine étape consiste à installer PostgreSQL (ou de votre choix de base de données relationnelle).

sudo apt install postgresql postgresql-contrib

Maintenant, il est temps de démarrer et d’activer le service PostgreSQL à l’intérieur de votre environnement virtuel.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Pour installer et utiliser PostgreSQL avec FastAPI, vous devez installer quelques choses :

1. asyncpg : C’est un pilote asynchrone PostgreSQL qui permet à FastAPI d’interagir avec une base de données PostgreSQL.
2. SQLAlchemy : C’est une bibliothèque ORM qui vous permet de gérer les schémas de base de données et les requêtes en écrivant du code Python plutôt que de coder en SQL brut.
3. databases : C’est une bibliothèque de base de données pour les opérations asynchrones requises par SQLAlchemy pour travailler asynchronement avec FastAPI.

Pour installer ces composants, exécutez le commande suivante regroupée :

pip install asyncpg sqlalchemy databases

Next up, create a Postgres database and user with the required 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

Étape 4 – Créer une application Python de test

Vous devez avoir une application Python exécutable qui accède à votre base de données via FastAPI. Si vous n’avez pas déjà une application Python en cours d’execution, vous pouvez en créer une rapidement en suivant les étapes suivantes :

Créer un nouveau fichier Python nommé postgres_db.py dans votre répertoire de projet.

nano postgres_db.py

Dans l’éditeur de texte, vous écrirez la logique pour créer une connexion à la base de données et créer une table à l’intérieur de la base. Dans cet exemple, nous créons une connexion à la base de données PostgreSQL en utilisant le package databases et définissons la structure d’une table books en utilisant 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)

Enregistrer et fermer le fichier.

Ensuite, créez un main.py dans le même répertoire.

nano main.py

Écrivez la logique principale de votre application dans ce fichier :

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)

Ce code utilise FastAPI pour écrire de nouvelles entrées de livres dans la base de données PostgreSQL et récupérer la collection de livres depuis elle.

Étape 5 – Installer les bibliothèques requises

Dans votre application Python, vous référencez diverses bibliothèques et paquets. Avant d’exécuter l’application, assurez-vous d’installer les bibliothèques requises.

pip install fastapi uvicorn psycopg2

Étape 6 – Exécuter l’application Python

Maintenant, il est temps de lancer l’application que vous avez créée.

uvicorn main:app --reload

uvicorn est un serveur de passerelle intergiciel asynchrone (ASGI) utilisé pour servir les applications FastAPI. Utiliser uvicorn est la méthode préférée pour exécuter une application FastAPI, car FastAPI est un framework web asynchrone lui-même.

Si la commande ci-dessus s’exécute sans rencontrer d’erreur, vous verrez une sortie similaire à celle suivante :

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.

Dans un navigateur Web, naviguez vers http://127.0.0.1:8000 pour voir la sortie de la requête.

Étape 7 [OPTIONNEL] – Tester les Points d’Accès

Vous pouvez tester les points d’accès définis dans votre main.py (c’est-à-dire POST et GET) en envoyant des demandes HTTP au serveur exécuté sur http://127.0.0.1:8000.

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

De même, vous pouvez effectuer une requête GET identique au serveur pour récupérer la liste des livres présents dans votre base de données Postgres.

Conclusion

Dans ce tutoriel, vous avez suivi le processus de configuration d’une application FastAPI simple qui interagit avec une base de données PostgreSQL. Ces étapes sont également utiles pour les applications AI, en particulier lorsque vous devez construire une API Web pour interagir avec vos modèles AI ou gérer les données liées à vos processus AI. Avec cette base en place, vous pouvez maintenant construire et étendre vos projets FastAPI.

Restez à l’affaire pour plus d’articles sur la manipulation de FastAPI.