Description
FastAPI hace que el primer endpoint se sienta sin esfuerzo, y por eso justamente tantos servicios de FastAPI están mal en silencio. El framework te da async, validación con Pydantic, inyección de dependencias y docs automáticas, y la mayoría de los equipos usa una fracción: bloquean el event loop con una llamada síncrona a la base de datos dentro de una ruta async, no validan nada porque los tipos parecían suficiente, filtran un modelo de la base de datos directo al cliente, y cablean la autenticación y la configuración a mano en cada endpoint. FastAPI no es difícil de escribir, es fácil de escribir mal, y la diferencia entre un servicio rápido y seguro y uno lento y frágil es entender qué hace de verdad el framework debajo de los decoradores.
Este libro te enseña a construir un servicio de FastAPI como se supone que se construye, para que obtengas la velocidad, la seguridad y las docs automáticas que promete el framework en vez de un servicio que te pelea. Arranca desde qué es de verdad FastAPI (una app ASGI donde los type hints de Python manejan la validación, la serialización y la documentación) y construye desde ahí: las path operations y qué hacen los decoradores, los modelos de Pydantic como el contrato de cada request y response (y por qué un response model separado evita que se filtren los campos de tu base de datos), y los parámetros, bodies y validación hechos de forma declarativa en vez de a mano. Va a fondo en las dos cosas que la gente hace mal: el async y el event loop (cuándo el async de verdad ayuda, por qué una sola llamada bloqueante envenena al worker entero, y cómo correr trabajo síncrono sin congelar el servidor), y la inyección de dependencias (la mejor función de FastAPI para compartir sesiones de base de datos, autenticación y configuración de forma limpia en vez de repetirla en cada ruta). Después construye el servicio real: estructurar una app que crece, hablar con una base de datos sin bloquear, autenticación y autorización con tokens y scopes, background tasks y middleware, manejo de errores que devuelve un contrato limpio, y configuración y secretos hechos una vez. La segunda mitad es producción: testear con el TestClient, las docs OpenAPI autogeneradas y cómo mantenerlas honestas, y desplegar con uvicorn y workers de gunicorn sin perder performance. Los ejemplos son una API real, mostrada construida mal y después bien. Para ingenieros de Python que quieren un servicio de FastAPI rápido de verdad, bien tipado y seguro de sacar a producción.
Escrito para vos si
Este libro es para: ingenieros de Python que están construyendo una API con FastAPI y quieren usar su sistema de tipos, el async y la inyección de dependencias como se supone que se usan, en vez de pelear con el framework y entregar un servicio lento y con fugas.
El método detrás
Los 6 pasos para un servicio que no te despierta a las 3 de la mañana. La forma de construir un servicio de FastAPI que se mantiene rápido, seguro y bien tipado cuando llega el tráfico real. En vez de atornillar features a mano, lo construís como un stack de capas donde cada una sostiene a la siguiente, así el sistema de tipos hace el trabajo que prometió el framework y nada se filtra ni bloquea. Pasás del endpoint que anda en la demo al servicio que sobrevive a producción.
- Entendé qué instalaste en realidad
- Dejá que los tipos definan cada request
- Corré async sin envenenar al worker
- Cableá sesiones, auth y config una sola vez
- Armá la superficie de producción, cada cosa una vez
- Probá que aguanta y sacalo sin perder velocidad
El índice completo
- Capítulo 1: El endpoint que funcionó y el servicio que no
- Capítulo 2: Qué instalaste en realidad
- Capítulo 3: Estás escribiendo a mano lo que FastAPI ya hace
- Capítulo 4: Campos que nunca quisiste mandar
- Capítulo 5: Un solo request puede tirarte abajo todo el servicio
- Capítulo 6: Por qué tu endpoint rápido se comporta como una cola
- Capítulo 7: Tres líneas que pegás en cada ruta
- Capítulo 8: Una página, cincuenta y una consultas
- Capítulo 9: Un token válido no es un permiso
- Capítulo 10: El stack trace que tus usuarios no deberían ver nunca
- Capítulo 11: Cuando main.py llega a cuatrocientas líneas
- Capítulo 12: De esperar que tu API funcione a probar que funciona
- Capítulo 13: El servicio que sobrevive al tráfico real
