FastAPI Python (Cómo Funciona Para Desarrolladores)

Introducción

FastAPI es un framework web moderno y de alto rendimiento para construir APIs con Python. Está diseñado para ser fácil de usar y aprender, mientras ofrece características potentes como la validación automática, la serialización y la documentación interactiva automática de la API. Además, funciona con cualquier motor de plantillas y te permite usar cualquier configuración de plantilla predeterminada que necesites para tu proyecto.

Vamos a profundizar en los detalles de FastAPI, sus características y cómo usarlo efectivamente. Más adelante en este artículo, también analizaremos IronPDF, un paquete de generación de PDF en Python de Iron Software.

Características clave de FastAPI

1. Alto Rendimiento: FastAPI es uno de los frameworks más rápidos de Python disponibles, comparable a Node.js y Go, gracias a su uso de Starlette para las partes web y Pydantic para las partes de datos.

2. Facilidad de uso: Está diseñado para ser intuitivo y reducir el tiempo dedicado a leer la documentación. El framework utiliza pistas de tipo estándar de Python para la validación y serialización de datos.

3. Documentación Interactiva Automática: FastAPI genera automáticamente documentación interactiva de API utilizando OpenAPI y JSON Schema, accesible a través de /docs (Swagger UI) y /redoc (ReDoc) y la actualización de las docs de API interactivas significa que esta documentación se actualiza automáticamente. La actualización de la documentación API alternativa también reflejará esto.

4. Soporte del editor: Excelente soporte para la autocompletación de código y la verificación de tipos en editores como VS Code, lo que hace que el desarrollo sea más rápido y reduce errores.

5. Basado en estándares: Está basado en (y es totalmente compatible con) los estándares abiertos para APIs: OpenAPI y JSON Schema.

Instalación

Puedes instalar FastAPI y Uvicorn (un servidor ASGI) usando pip:

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Creación de tu primera aplicación FastAPI

Aquí tienes un ejemplo sencillo para comenzar con FastAPI y exponer datos de Python a través de una interfaz de usuario:

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

py

Para ejecutar la aplicación, use Uvicorn:

uvicorn main:app --reload

py

Este comando iniciará un servidor de desarrollo y recargará automáticamente para los cambios en el código. Puede acceder a la documentación interactiva de la API en http://127.0.0.1:8000/docs.

Funciones avanzadas

FastAPI es compatible con una amplia gama de funciones avanzadas, lo que lo hace adecuado para aplicaciones complejas:

1. Inyección de Dependencias: FastAPI ofrece un poderoso sistema de inyección de dependencias que te permite gestionar dependencias de manera limpia y eficiente.

2. Tareas en segundo plano: Puede definir tareas en segundo plano para ejecutarse después de devolver una respuesta, útil para tareas como enviar correos electrónicos o procesar datos.

3. WebSockets: FastAPI admite WebSockets, lo que permite la comunicación en tiempo real entre el cliente y el servidor.

4. Seguridad: FastAPI incluye herramientas para manejar la seguridad, incluyendo OAuth2, tokens JWT, y más.

5. Integración de Bases de Datos: FastAPI se puede integrar fácilmente con bases de datos usando bibliotecas como SQLAlchemy o Tortoise-ORM.

Ejemplo: Creación de una API CRUD

Construyamos una API CRUD (Crear, Leer, Actualizar, Borrar) simple para gestionar elementos.

1. Definir el modelo de datos:

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

py

1. Crear la aplicación FastAPI:

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

py

Presentación de IronPDF

IronPDF es una potente biblioteca de Python diseñada para crear, editar y firmar PDFs a partir de HTML, CSS, imágenes y JavaScript. Ofrece un rendimiento de nivel comercial con un bajo consumo de memoria. Las características clave incluyen:

Conversión de HTML a PDF

Convierta archivos HTML, cadenas HTML y URL en PDF. Por ejemplo, renderiza una página web como PDF utilizando el renderizador de PDF de Chrome.

Soporte multiplataforma

Compatible con varias plataformas .NET, incluidas .NET Core, .NET Standard y .NET Framework. Es compatible con Windows, Linux y macOS.

Edición y firma

Establezca propiedades, añada seguridad con contraseñas y permisos, y aplique firmas digitales a sus PDF.

Plantillas de página y configuración

Personalice los PDF con encabezados, pies de página, números de página y márgenes ajustables. Admite diseños adaptables y tamaños de papel personalizados.

Cumplimiento de las normas

Cumple estándares PDF como PDF/A y PDF/UA. Admite la codificación de caracteres UTF-8 y gestiona activos como imágenes, CSS y fuentes.

Generar documentos PDF utilizando IronPDF y FastAPI

pip install fastapi
pip install ironPDF

pip install fastapi
pip install ironPDF

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

py

Código Explicación

Este fragmento de código demuestra la integración de IronPDF con FastAPI para generar dinámicamente documentos PDF basados en las entradas del usuario y servirlos como una respuesta descargable.

1. Estableciendo la clave de licencia: Aplica la clave de licencia de IronPDF para habilitar sus funciones.

2. Inicialización de FastAPI: Inicializa una instancia de FastAPI (`app`) para manejar solicitudes HTTP. Manejadores de Rutas Básicas: `read_root()`: Responde con un mensaje JSON simple que indica "Hello IronPDF" al acceder a la URL raíz (`/`). `read_item()`: Acepta un parámetro de ruta `item_id` y un parámetro de consulta opcional `q`. Devuelve una respuesta JSON con estos parámetros de función.

3. Ruta de Generación de PDF (`/pdf`): `get_pdf()`

   • Esta función asíncrona maneja las solicitudes GET al punto de acceso `/pdf` con un parámetro de consulta opcional llamado (`greet1` y `greet2`).
   • Construye una cadena HTML (`content`) que incluye: Un encabezado que indica el origen y el propósito del documento. Un párrafo que demuestra la generación de PDF utilizando entradas de usuario (`greet1` y `greet2`). Utiliza `ChromePdfRenderer()` de IronPDF para renderizar el contenido HTML en un PDF (`pdf = renderer.RenderHtmlAsPdf(content)`).
   • Guarda el PDF generado como "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).5. Servir el PDF:
   • Configura los encabezados de respuesta para especificar que el PDF debe visualizarse en línea en el navegador (`"Content-Disposition": "inline; filename=sample.pdf"`).
   • Crea un objeto `FileResponse` que apunta al archivo PDF generado con el tipo de medio apropiado (`"application/pdf"`).
   • Devuelve el objeto `FileResponse`, que activa la descarga del documento PDF cuando se accede al endpoint `/pdf`.

   Este fragmento de código ilustra cómo IronPDF se puede integrar perfectamente con FastAPI para generar y servir dinámicamente documentos PDF basados en las entradas del usuario. Muestra la capacidad de convertir contenido HTML en PDFs, haciéndolo adecuado para aplicaciones que requieren generación y entrega de documentos sobre la marcha a través de HTTP.

Salida

A continuación se muestra la salida de Swagger generada a partir de las API.

PDF

Licencia IronPDF

IronPDF se ejecuta con la clave de licencia para Python. IronPDF for Python ofrece una clave de licencia de prueba gratuita para permitir a los usuarios probar las funciones antes de la compra.

Coloque la clave de licencia al inicio del script antes de usar el paquete IronPDF:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

py

Conclusión

FastAPI es un framework potente y fácil de usar para construir APIs en Python. FastAPI tiene un alto rendimiento, documentación automática y características avanzadas que lo convierten en una excelente opción tanto para principiantes como para desarrolladores experimentados. Ya sea que estés desarrollando una API simple o una aplicación web compleja, FastAPI proporciona las herramientas que necesitas para tener éxito.

IronPDF es una robusta biblioteca de Python para crear, manipular y renderizar documentos PDF a partir de contenido HTML. Ofrece características como la conversión de HTML a PDF, creación de formularios interactivos, manipulación de PDF (fusionar, dividir) y extracción de texto. Ideal para generar PDFs dinámicos con facilidad e integrarse en diversas aplicaciones de Python.