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
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
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.
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.
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.
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.
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.
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.