Guía Definitiva: Crear una API con FastAPI y SQLite en Pocos Pasos 2024
¡Hola! De vuelta por aquí después de un largo tiempo sin publicar. Ya era justo dedicarle algo de tiempo a esta web. Esta vez les traigo un tutorial corto pero conciso sobre cómo crear una API con FastAPI y SQLite. Después de terminar de leer este tutorial, te darás cuenta de lo fácil y sencillo que es crear una API. ¡Vamos a ello!
Preparativos Iniciales
Instalación de Python y Herramientas Necesarias
Asegúrate de tener Python instalado en tu sistema. Puedes verificarlo con el comando:
python3 --versionInstala pip si aún no lo tienes:
sudo apt-get install python3-pipCrear un Entorno Virtual
Es una buena práctica usar un entorno virtual para gestionar las dependencias del proyecto:
¿Cómo insertar una imagen en HTML fácilmente?python3 -m venv venv source venv/bin/activateInstalar FastAPI y Uvicorn
FastAPI es el framework para crear la API, y Uvicorn es el servidor ASGI para ejecutar la API:
pip install fastapi uvicornInstalar SQLite
SQLite viene preinstalado con Python, por lo que no necesitas instalarlo por separado.
Crear la Estructura del Proyecto
Organiza tu proyecto creando una estructura básica:
mkdir myapi
cd myapi
mkdir database
touch main.py database.py models.py schemas.pyImplementar la API
Definir el Modelo de Datos
En models.py, define el modelo para el libro:
¿Cómo crear un buscador HTML eficiente y personalizado?models.py
from typing import List, Optional
from pydantic import BaseModel
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Book(Base):
__tablename__ = "books"
id = Column(Integer, primary_key=True, index=True)
title = Column(String, index=True)
author = Column(String)
pages = Column(Integer)`
Configurar la Base de Datos
En database.py, configura la conexión y la sesión con SQLite:
database.py
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import DeclarativeMeta
from sqlalchemy.orm import sessionmaker
SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = DeclarativeMeta()
def init_db():
Base.metadata.create_all(bind=engine)Crear los Esquemas
En schemas.py, define los esquemas para validar los datos:
¿Quieres aprender sobre animaciones con CSS, ejemplos sorprendentes?schemas.py
from pydantic import BaseModel
class BookBase(BaseModel):
title: str
author: str
pages: int
class BookCreate(BookBase):
pass
class Book(BookBase):
id: int
class Config:
orm_mode = TrueImplementar las Rutas
En main.py, crea las rutas para manejar los libros:
main.py
# main.py
from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.orm import Session
from database import SessionLocal, init_db
import models, schemas
app = FastAPI()
# Initialize the database
init_db()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.post("/books/", response_model=schemas.Book)
def create_book(book: schemas.BookCreate, db: Session = Depends(get_db)):
db_book = models.Book(**book.dict())
db.add(db_book)
db.commit()
db.refresh(db_book)
return db_book
@app.get("/books/", response_model=List[schemas.Book])
def read_books(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
return db.query(models.Book).offset(skip).limit(limit).all()
@app.get("/books/{book_id}", response_model=schemas.Book)
def read_book(book_id: int, db: Session = Depends(get_db)):
book = db.query(models.Book).filter(models.Book.id == book_id).first()
if book is None:
raise HTTPException(status_code=404, detail="Book not found")
return book
@app.put("/books/{book_id}", response_model=schemas.Book)
def update_book(book_id: int, book: schemas.BookCreate, db: Session = Depends(get_db)):
db_book = db.query(models.Book).filter(models.Book.id == book_id).first()
if db_book is None:
raise HTTPException(status_code=404, detail="Book not found")
for key, value in book.dict().items():
setattr(db_book, key, value)
db.commit()
db.refresh(db_book)
return db_book
@app.delete("/books/{book_id}", response_model=schemas.Book)
def delete_book(book_id: int, db: Session = Depends(get_db)):
db_book = db.query(models.Book).filter(models.Book.id == book_id).first()
if db_book is None:
raise HTTPException(status_code=404, detail="Book not found")
db.delete(db_book)
db.commit()
return db_bookEjecutar la API
Inicia el servidor Uvicorn para probar tu API:
¿Cómo cambiar el color de un enlace en CSS?uvicorn main:app --reloadProbar la API con curl
Agregar Libros
curl -X POST "http://127.0.0.1:8000/books/" -H "Content-Type: application/json" -d '{"title": "1984", "author": "George Orwell", "pages": 328}Repite el comando con diferentes datos para agregar más libros.
Leer Todos los Libros
curl -X GET "http://127.0.0.1:8000/books/"Leer un Libro por ID
curl -X GET "http://127.0.0.1:8000/books/1"Actualizar un Libro
curl -X PUT "http://127.0.0.1:8000/books/1" -H "Content-Type: application/json" -d '{"title": "Updated Title", "author": "Updated Author", "pages": 300}'Eliminar un Libro
curl -X DELETE "http://127.0.0.1:8000/books/1"Finalmente está listo!!
¡Felicidades! Has creado una API con FastAPI que utiliza SQLite para manejar datos de libros. Has aprendido a definir modelos, configurar la base de datos, crear esquemas y manejar rutas HTTP. También has probado la API usando curl para agregar, leer, actualizar y eliminar datos.
Recursos Adicionales
Espero que este tutorial te sea útil y te ayude a profundizar en el desarrollo de APIs con FastAPI y SQLite.
¿Cómo hacer animaciones de imágenes en HTML CSS?Si quieres conocer otros artículos parecidos a Guía Definitiva: Crear una API con FastAPI y SQLite en Pocos Pasos 2024 puedes visitar la categoría Lenguaje de Programación.
