FastAPI Python (Cómo Funciona Para Desarrolladores)
FastAPI es un marco web moderno y de alto rendimiento para construir APIs con Python. Está diseñado para ser fácil de usar y aprender, proporcionando potentes características como validación automática, serialización y documentación interactiva automática de API. Además, funciona con cualquier motor de plantillas y te permite utilizar cualquier configuración de plantilla predeterminada necesaria para tu proyecto.
Profundicemos en los detalles de FastAPI, sus características y cómo usarlo eficazmente. 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 principales de FastAPI
- Alto rendimiento: FastAPI es uno de los marcos de Python más rápidos disponibles, comparable a Node.js y Go, gracias a su uso de Starlette para las partes web y Pydantic para las partes de datos.
- Facilidad de uso: Está diseñado para ser intuitivo y reducir el tiempo dedicado a leer la documentación. El marco utiliza sugerencias de tipo estándar de Python para la validación y serialización de datos.
- Documentación interactiva automática: FastAPI genera automáticamente documentación interactiva de API usando OpenAPI y JSON Schema, accesible a través de /docs (Swagger UI) y /redoc (ReDoc). Cualquier actualización en la API se refleja automáticamente en la documentación.
- Soporte para editores: Excelente soporte para completar código y chequeo de tipos en editores como VS Code, lo que hace que el desarrollo sea más rápido y reduce errores.
- 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]"Crear su primera aplicación FastAPI
Aquí tienes un ejemplo sencillo para que comiences con FastAPI y expongas datos de Python a través de una interfaz de usuario:
from fastapi import FastAPI
# Create a FastAPI 'app' instance
app = FastAPI()
# Root path operation
@app.get("/")
def read_root():
return {"Hello": "World"}
# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}from fastapi import FastAPI
# Create a FastAPI 'app' instance
app = FastAPI()
# Root path operation
@app.get("/")
def read_root():
return {"Hello": "World"}
# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}Para ejecutar la aplicación, utiliza Uvicorn:
uvicorn main:app --reloaduvicorn main:app --reloadEste comando iniciará un servidor de desarrollo y recargará automáticamente los cambios en el código. Puedes acceder a la documentación interactiva de API en http://127.0.0.1:8000/docs.
Características avanzadas
FastAPI admite un amplio rango de características avanzadas, haciéndolo adecuado para aplicaciones complejas:
- Inyección de dependencias: FastAPI proporciona un potente sistema de inyección de dependencias que te permite gestionar dependencias de manera limpia y eficiente.
- Tareas en segundo plano: Puedes definir tareas en segundo plano para ejecutarse después de devolver una respuesta, útil para tareas como enviar correos electrónicos o procesar datos.
- WebSockets: FastAPI soporta WebSockets, lo que permite la comunicación en tiempo real entre el cliente y el servidor.
- Seguridad: FastAPI incluye herramientas para manejar seguridad, incluyendo OAuth2, tokens JWT y más.
- Integración con bases de datos: FastAPI puede integrarse fácilmente con bases de datos utilizando bibliotecas como SQLAlchemy o Tortoise-ORM.
Ejemplo: Construcción de una API CRUD
Construyamos una simple API CRUD (Crear, Leer, Actualizar, Eliminar) para gestionar elementos.
- Definir el modelo de datos:
from pydantic import BaseModel
# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = Nonefrom pydantic import BaseModel
# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None- Crear la aplicación FastAPI:
from fastapi import FastAPI, HTTPException
# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}
# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
item_id = len(items) + 1
items[item_id] = item
return item
# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
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]
# Update operation: Replace an existing item
@app.put("/items/{item_id}")
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
# Delete operation: Remove an item by 'item_id'
@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"}from fastapi import FastAPI, HTTPException
# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}
# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
item_id = len(items) + 1
items[item_id] = item
return item
# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
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]
# Update operation: Replace an existing item
@app.put("/items/{item_id}")
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
# Delete operation: Remove an item by 'item_id'
@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"}Presentando IronPDF
IronPDF es una poderosa biblioteca de Python diseñada para crear, editar y firmar PDFs desde HTML, CSS, imágenes, y JavaScript. Ofrece un rendimiento de calidad comercial con un bajo uso de memoria. Las características clave son:
Conversión de HTML a PDF
Convierte archivos HTML, cadenas HTML y URLs a PDFs. Por ejemplo, renderiza una página web como PDF utilizando el renderizador PDF de Chrome.
Soporte multiplataforma
Compatible con varias plataformas .NET, incluyendo .NET Core, .NET Standard y .NET Framework. Es compatible con Windows, Linux y macOS.
Edición y firma
Establece propiedades, añade seguridad con contraseñas y permisos, y aplica firmas digitales a tus PDFs.
Plantillas de página y configuración
Personaliza PDFs con encabezados, pies de página, números de página y márgenes ajustables. Soporta diseños responsivos y tamaños de papel personalizados.
Cumplimiento de normas
Adhiere a normas PDF como PDF/A y PDF/UA. Soporta codificación de caracteres UTF-8 y maneja activos como imágenes, CSS y fuentes.
Generar documentos PDF con IronPDF y FastAPI
pip install fastapi
pip install ironPDFpip install fastapi
pip install ironPDFfrom fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *
# Apply your IronPDF license key
License.LicenseKey = "key"
# Initialize 'app' instance
app = FastAPI()
# Route for simple greeting
@app.get("/")
def read_root():
return {"Hello": "IronPDF"}
# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
# Use ChromePdfRenderer to create PDF from HTML
renderer = ChromePdfRenderer()
content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
content += "<p> Demonstrate PDF generation using User Inputs</p>"
content += f"<p>Greetings from: {greet1}</p>"
content += f"<p>And Greetings from: {greet2}</p>"
pdf = renderer.RenderHtmlAsPdf(content)
# Save the PDF to a file
pdf.SaveAs("fastapi.pdf")
# Create a response with the generated PDF
headers = {
"Content-Disposition": "inline; filename=sample.pdf"
}
return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *
# Apply your IronPDF license key
License.LicenseKey = "key"
# Initialize 'app' instance
app = FastAPI()
# Route for simple greeting
@app.get("/")
def read_root():
return {"Hello": "IronPDF"}
# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
# Use ChromePdfRenderer to create PDF from HTML
renderer = ChromePdfRenderer()
content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
content += "<p> Demonstrate PDF generation using User Inputs</p>"
content += f"<p>Greetings from: {greet1}</p>"
content += f"<p>And Greetings from: {greet2}</p>"
pdf = renderer.RenderHtmlAsPdf(content)
# Save the PDF to a file
pdf.SaveAs("fastapi.pdf")
# Create a response with the generated PDF
headers = {
"Content-Disposition": "inline; filename=sample.pdf"
}
return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)Explicación del código
Este fragmento de código demuestra la integración de IronPDF con FastAPI para generar dinámicamente documentos PDF basados en entradas de usuario y servirlos como respuesta descargable.
Configuración de la clave de licencia: Aplica la clave de licencia de IronPDF para habilitar sus características.
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 rutaitem_idy un parámetro de consulta opcionalq. Devuelve una respuesta JSON con estos parámetros.
Ruta de generación de PDF (
/pdf):get_pdf(): Esta función asincrónica maneja solicitudes GET al endpoint/pdfcon parámetros de consulta opcionales llamadosgreet1ygreet2.- Construye una cadena de HTML (
content) que incluye:- Un encabezado que indica el origen y propósito del documento.
- Un párrafo que demuestra la generación de PDF utilizando entradas de usuario (
greet1ygreet2).
- Usa
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")).
- Suministro del PDF:
- Configura encabezados de respuesta para especificar que el PDF debe ser visto en línea en el navegador (
"Content-Disposition": "inline; filename=sample.pdf"). - Crea un objeto
FileResponseapuntando al archivo PDF generado con el tipo de medio apropiado ("application/pdf"). - Devuelve el objeto
FileResponse, lo que desencadena la descarga del documento PDF cuando se accede al endpoint/pdf.
- Configura encabezados de respuesta para especificar que el PDF debe ser visto en línea en el navegador (
Este fragmento de código ilustra cómo IronPDF puede integrarse perfectamente con FastAPI para generar y servir documentos PDF dinámicamente basados en las entradas del usuario. Muestra la capacidad de convertir contenido HTML en PDFs, haciéndolo adecuado para aplicaciones que requieren generación de documentos sobre la marcha y entrega a través de HTTP.
Resultado
Abajo se muestra la salida swagger generada a partir de las APIs
Licencia de IronPDF
IronPDF se ejecuta con la clave de licencia para Python. IronPDF para Python ofrece una licencia de prueba gratuita para permitir a los usuarios probar las características antes de la compra.
Coloca la clave de licencia al inicio del script antes de usar el paquete IronPDF:
from ironpdf import *
# Apply your license key
License.LicenseKey = "key"from ironpdf import *
# Apply your license key
License.LicenseKey = "key"Conclusión
FastAPI es un marco potente y fácil de usar para construir APIs en Python. FastAPI tiene alto rendimiento, documentación automática y características avanzadas que lo hacen una excelente opción tanto para principiantes como para desarrolladores experimentados. Ya sea que estés construyendo 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 desde contenido HTML. Ofrece características como conversión de HTML a PDF, creación de formularios interactivos, manipulación de PDFs (fusión, división) y extracción de texto. Ideal para generar PDFs dinámicos con facilidad e integrar en varias aplicaciones Python.
Preguntas Frecuentes
¿Cómo puedo convertir contenido HTML a PDF en una aplicación Python?
Puedes usar el ChromePdfRenderer de IronPDF para convertir contenido HTML, CSS y JavaScript en un archivo PDF. Esto permite una integración fluida en aplicaciones Python para generar documentos PDF a partir de contenido web.
¿Cuáles son los beneficios de usar FastAPI para construir APIs?
FastAPI ofrece alto rendimiento, validación automática, serialización y documentación interactiva de API. Aprovecha Starlette y Pydantic para garantizar velocidad y eficiencia, comparable a Node.js y Go, al tiempo que admite estándares abiertos como OpenAPI.
¿Cómo puedo servir un documento PDF en FastAPI?
Puedes servir un documento PDF en FastAPI generándolo con IronPDF y retornándolo usando FileResponse de FastAPI. Este enfoque te permite crear y servir dinámicamente PDFs basados en solicitudes de clientes.
¿Qué hace que FastAPI sea adecuado para aplicaciones en tiempo real?
FastAPI admite WebSockets, lo que permite la comunicación en tiempo real entre el cliente y el servidor, convirtiéndolo en una elección ideal para aplicaciones que requieren actualizaciones instantáneas de datos o interacciones en vivo.
¿Cómo maneja FastAPI la validación y serialización de datos?
FastAPI utiliza modelos Pydantic y sugerencias de tipos estándar de Python para manejar la validación y serialización de datos. Esto asegura que los datos de entrada sean correctamente validados y convertidos al formato deseado, reduciendo el error.
¿Qué características de seguridad ofrece FastAPI?
FastAPI proporciona características de seguridad robustas, incluyendo OAuth2, autenticación JWT, e inyección de dependencias, permitiendo a los desarrolladores construir aplicaciones seguras con un esfuerzo mínimo.
¿Puede IronPDF ser usado en aplicaciones multiplataforma?
Sí, IronPDF está diseñado para ser multiplataforma, compatible con Windows, Linux y macOS. Esto lo convierte en una opción versátil para desarrolladores que buscan integrar la generación de PDF en aplicaciones que se ejecutan en diferentes sistemas operativos.
¿Cómo mejora FastAPI la productividad del desarrollador?
FastAPI mejora la productividad del desarrollador ofreciendo documentación automática de API, autocompletado de código y verificación de tipos. Esto reduce la necesidad de documentación manual extensa y ayuda a detectar errores temprano en el proceso de desarrollo.
Comience gratis
Comience gratis
Reserve demostración en vivo gratis
No se requiere tarjeta de crédito ni creación de cuenta
