Implementación de un Proyecto de API REST CRUD utilizando FastAPI y PostgreSQL

En este tutorial, te guiaré paso a paso a través de la creación de un proyecto de API REST CRUD utilizando FastAPI y PostgreSQL. FastAPI es un marco web moderno y rápido para la creación de APIs con Python, mientras que PostgreSQL es un sistema de gestión de bases de datos relacional altamente confiable y escalable. Combinar FastAPI con PostgreSQL nos permitirá crear una API potente y eficiente para manejar operaciones CRUD (Crear, Leer, Actualizar y Eliminar) en una base de datos.

A lo largo de este tutorial, crearemos un proyecto que permitirá a los usuarios realizar operaciones CRUD en una base de datos PostgreSQL. El proyecto consistirá en una API REST que expondrá endpoints para crear, recuperar, actualizar y eliminar registros de una tabla en la base de datos.

Paso 1: Configuración del entorno

Antes de comenzar, asegúrate de tener instalados Python y PostgreSQL en tu sistema. Puedes instalar FastAPI y las dependencias necesarias utilizando pip, el administrador de paquetes de Python. Para instalar FastAPI, ejecuta el siguiente comando:

pip install fastapi

Además, instala el servidor web ‘uvicorn’, que FastAPI utiliza internamente para servir la aplicación:

pip install uvicorn

Para interactuar con la base de datos PostgreSQL desde Python, necesitamos instalar el paquete ‘asyncpg’ que proporciona una interfaz de base de datos asíncrona:

pip install asyncpg

Paso 2: Creación de la base de datos PostgreSQL

Una vez que hayas instalado PostgreSQL en tu sistema, crea una nueva base de datos en PostgreSQL utilizando la interfaz de línea de comandos ‘psql’. Inicia la interfaz de línea de comandos de PostgreSQL ejecutando el siguiente comando en la terminal:

psql -U postgres

Luego, crea una nueva base de datos ejecutando el siguiente comando:

CREATE DATABASE fastapi_crud;

Sal de la interfaz de línea de comandos de PostgreSQL escribiendo ‘q’.

Paso 3: Creación del modelo de datos

En este paso, definiremos el modelo de datos que utilizaremos en nuestra aplicación. Crearemos un modelo simple para representar un objeto ‘Item’ con una identificación única, un nombre y una cantidad. Crea un archivo llamado ‘models.py’ y agrega el siguiente código:

from pydantic import BaseModel
from typing import Optional

class Item(BaseModel):
    id: Optional[int]
    name: str
    quantity: int

En este código, importamos la clase ‘BaseModel’ de FastAPI para definir el modelo de datos ‘Item’. El modelo ‘Item’ tiene tres atributos: ‘id’ (opcional), ‘name’ y ‘quantity’.

Paso 4: Configuración de la conexión a la base de datos

Ahora necesitamos configurar la conexión a la base de datos PostgreSQL en nuestra aplicación. Crea un archivo llamado ‘database.py’ y agrega el siguiente código para establecer la conexión a la base de datos:

import asyncpg

async def get_connection():
    return await asyncpg.connect(user='postgres', password='password', database='fastapi_crud', host='localhost')

En este código, creamos una función asincrónica ‘get_connection()’ que devuelve una conexión a la base de datos PostgreSQL utilizando los parámetros de conexión proporcionados.

Paso 5: Creación de los endpoints de la API

Ahora vamos a crear los endpoints de la API que nos permitirán realizar operaciones CRUD en la base de datos. Crea un archivo llamado ‘main.py’ y agrega el siguiente código para definir los endpoints de la API:

from fastapi import FastAPI, HTTPException
from database import get_connection
from models import Item

app = FastAPI()

@app.post("/items/")
async def create_item(item: Item):
    conn = await get_connection()
    new_item_id = await conn.execute("INSERT INTO items (name, quantity) VALUES ($1, $2) RETURNING id", item.name, item.quantity)
    await conn.close()
    return {'id': new_item_id, **item.dict()}

@app.get("/items/")
async def read_items():
    conn = await get_connection()
    items = await conn.fetch("SELECT * FROM items")
    await conn.close()
    return items

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    conn = await get_connection()
    await conn.execute("UPDATE items SET name=$1, quantity=$2 WHERE id=$3", item.name, item.quantity, item_id)
    await conn.close()
    return {'id': item_id, **item.dict()}

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    conn = await get_connection()
    result = await conn.execute("DELETE FROM items WHERE id=$1", item_id)
    await conn.close()
    if result == 'DELETE 1':
        return {'message': 'Item deleted successfully'}
    else:
        raise HTTPException(status_code=404, detail='Item not found')

En este código, creamos cuatro endpoints para crear, recuperar, actualizar y eliminar registros en la base de datos PostgreSQL. Cada endpoint se define con una ruta y una función asincrónica que realiza la operación correspondiente en la base de datos.

Paso 6: Ejecutar la aplicación

Ahora que hemos creado la aplicación, podemos ejecutarla utilizando el servidor web ‘uvicorn’. Abre una terminal en el directorio donde se encuentran los archivos ‘main.py’, ‘models.py’ y ‘database.py’ y ejecuta el siguiente comando para iniciar el servidor FastAPI:

uvicorn main:app --reload

Esto iniciará el servidor FastAPI en el puerto predeterminado 8000. Puedes acceder a la documentación interactiva de la API en tu navegador visitando la URL ‘http://localhost:8000/docs‘.

¡Felicidades! Has creado un proyecto de API REST CRUD utilizando FastAPI y PostgreSQL. Ahora puedes probar la API utilizando herramientas como Postman o cURL para realizar operaciones CRUD en la base de datos PostgreSQL. Espero que este tutorial te haya sido útil y te haya brindado una introducción completa a la creación de APIs con FastAPI y PostgreSQL. ¡Disfruta explorando más funcionalidades y características de FastAPI para crear aplicaciones web modernas y eficientes!