[Tutoriel] FastAPI SQLAlchemy, PostgreSQL, Alembic et Docker Part-2 (version asynchrone)

Une imitation d'une base de données utilisant des boîtes

Intro

Le but de cet article est de créer un guide simple sur l'utilisation de FastAPI avec des bases de données relationnelles de manière asynchrone et l'utilisation d'Alembic pour les migrations. Avant de vous lancer dans ce didacticiel, veuillez consulter la partie 1 .

Voici le code de travail complet sur github

Commençons

Installez le package requis databases

databasesest un package léger prenant en charge asyncio pour de nombreuses bases de données relationnelles et utilise les sqlalchemyrequêtes principales.

pour les besoins de ce didacticiel, j'utiliserai pipenv , mais vous pouvez utiliser pip ou poetry ou conda ou tout autre gestionnaire de paquets que vous souhaitez.

pipenv install databases
pipenv install databases[postgresql]
pipenv install asyncpg

Dockerfile

# Pull base image
FROM python:3.7

# Set environment varibles
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

WORKDIR /code/

# Install dependencies
RUN pip install pipenv
COPY Pipfile Pipfile.lock /code/
RUN pipenv install --system --dev

COPY . /code/

EXPOSE 8000

version: "3"

services:
  db:
    image: postgres:11
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=test_db
  web:
    build: .
    command: bash -c "uvicorn main:app --host 0.0.0.0 --port 8000 --reload"
    volumes:
      - .:/code
    ports:
      - "8000:8000"
    depends_on:
      - db

  pgadmin:
    container_name: pgadmin
    image: dpage/pgadmin4
    environment:
      - [email protected]
      - PGADMIN_DEFAULT_PASSWORD=admin
    ports:
      - "5050:80"
    depends_on:
      - db

from pydantic import BaseModel


class User(BaseModel):
    first_name: str
    last_name: str
    age: int

    class Config:
        orm_mode = True

nous allons changer . env à

DATABASE_URL=postgresql://postgres:postgres@db:5432/postgres

import os
from databases import Database
from dotenv import load_dotenv
import sqlalchemy
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
load_dotenv(os.path.join(BASE_DIR, ".env"))

db = Database(os.environ["DATABASE_URL"])
metadata = sqlalchemy.MetaData()

from db import db
from fastapi import FastAPI


app = FastAPI(title="Async FastAPI")


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


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

from db import db

users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("first_name", sqlalchemy.String),
    sqlalchemy.Column("last_name", sqlalchemy.String),
    sqlalchemy.Column("age", sqlalchemy.Integer),
)

import sqlalchemy
from db import db, metadata, sqlalchemy


users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("first_name", sqlalchemy.String),
    sqlalchemy.Column("last_name", sqlalchemy.String),
    sqlalchemy.Column("age", sqlalchemy.Integer),
)


class User:
    @classmethod
    async def get(cls, id):
        query = users.select().where(users.c.id == id)
        user = await db.fetch_one(query)
        return user

    @classmethod
    async def create(cls, **user):
        query = users.insert().values(**user)
        user_id = await db.execute(query)
        return user_id

modifions maintenant main.py en conséquence

import uvicorn
from models import User as ModelUser
from schema import User as SchemaUser
from app import app
from db import db


@app.post("/user/")
async def create_user(user: SchemaUser):
    user_id = await ModelUser.create(**user.dict())
    return {"user_id": user_id}


@app.get("/user/{id}", response_model=SchemaUser)
async def get_user(id: int):
    user = await ModelUser.get(id)
    return SchemaUser(**user).dict()


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Il est temps de modifier notre Alembicconfig.

changement

import models

target_metadata = models.Base.metadata

import models
from db import metadata

target_metadata = metadata

construire

docker-compose build

docker-compose run web alembic revision --autogenerate

docker-compose run web alembic upgrade head

docker-compose up

Demande POST pour créer un utilisateur
réponse à la demande précédente
GET demande du même utilisateur avec réponse

J'espère que ce tutoriel était suffisamment complet sur la façon d'utiliser FastAPI avec PostgreSQL, SQLAlchemy et Alembic en utilisant la puissance de l'async.

Le code complet de cet article est ici sur github.

Suggested posts

Comment exécuter gratuitement les plugins ChatGPT avec Langchain

Comment exécuter gratuitement les plugins ChatGPT avec Langchain

Vous devez avoir entendu parler de tous les nouveaux plugins ChatGPT puissants comme le navigateur, l'interpréteur de code, etc. Mais il y a un problème, l'accès aux plugins est limité à une liste d'attente et donc beaucoup n'y ont pas accès.

Mes ressources de codage les plus utilisées

Mes ressources de codage les plus utilisées

Cette semaine, j'ai reçu un e-mail d'un membre de la liste de diffusion quotidienne. Ils voulaient savoir : Quelles ressources consultez-vous quotidiennement, hebdomadairement et mensuellement ? Grande question ! Je suis heureux d'essayer de partager quelques idées sur mon flux de travail et les principales ressources que j'utilise.

Related posts

L'art est-il toujours apolitique ?

L'art est-il toujours apolitique ?

Hier, nous avons fermé la porte du concours Eurovision de la chanson de cette année avec une grande finale scintillante et chaotique où la chanteuse suédoise Loreen a remporté le trophée, devenant la première femme à gagner deux fois et ramenant la couronne à la Suède 50 ans après qu'ABBA a remporté le concours. avec "Waterloo". Ils sont devenus l'un des plus grands groupes du canon de la musique pop.

Repenser les médias : les cinq vérités de McChesney et l'avenir des communications

Dans le monde hyper-connecté d'aujourd'hui, les systèmes médiatiques jouent un rôle central dans la formation de l'opinion publique et, par conséquent, dans la prise de décision démocratique. Dans son analyse approfondie de l'économie politique de la communication, le chercheur Robert McChesney remet en question la sagesse conventionnelle et présente ce qu'il appelle les « cinq vérités » sur les médias.

Journal ouvert

Journal ouvert

Journal ouvert : une image par jour. J'ai toujours été fasciné par les histoires.

"La fosse des Mariannes dévoilée : dévoiler les terrifiantes vérités cachées de l'abîme"

"La fosse des Mariannes dévoilée : dévoiler les terrifiantes vérités cachées de l'abîme"

Introduction :Bienvenue, courageux lecteurs, dans un voyage qui nous emmènera dans les profondeurs les plus sombres de notre planète. Dans ce blog, nous plongeons dans le monde énigmatique de la fosse des Mariannes, découvrant ses secrets cachés et découvrant les vérités effrayantes qui se cachent sous sa surface.