Índice de contenido
- Lo que aprenderás en este Curso Maestro (Resumen Ejecutivo)
- De Principiante a Senior: La Verdad Sobre Aprender FastAPI
- La decisión en Python: ¿Qué aprender primero?
- ¿Por Qué Aprender FastAPI Hoy?
- Ventajas reales frente a otros frameworks
- Qué problemas resuelve FastAPI
- ¿Qué es FastAPI y Cómo Funciona? (Explicación Simple)
- ¿Por qué elegir FastAPI frente a otros Frameworks?
- Pydantic: El corazón de las validaciones
- Starlette: El motor que hace volar a FastAPI
- El Poder del Tipado: Menos errores, más velocidad
- Objetivo
- Para quien es este libro
- Recursos Gratuitos para Profundizar
- Lee los Primeros Capítulos Gratis
- Repositorios Base y Apps Completas
- Prueba la Aplicación Demo
- ¿Por qué aprender conmigo?
- Temario del curso y libro
- Capítulos Detallados
- Módulos del Curso
- Preguntas Frecuentes
- 1. Introducción
- 2. Ambiente de desarrollo
- 3. Verificar el comando de acceso a Python 3 y Pip
- 4. Preparar el entorno
- 5. Instalar paquetes
- 6. Parámetros en las rutas (path)
- 7. Comandos básicos
- 8. Hola Mundo
- 9. pciones del comando de uvicorn
- 10. Tipos de rutas
- 11. FastAPI Extensión OFICIAL para Visual Studio Code
- 1. Introducción
- 2. Consola interactiva/consola de Python
- 3. Archivos de Python
- 4. Variables y tipo de datos
- 5. Operaciones matemáticas
- 6. Concatenación de String
- 7. Casteos
- 8. Listas
- 9. Condicionales
- 10. Ciclos
- 11. Funciones
- 12. Funciones parte 2
- 13. Diccionarios
- 14. Clases, Primeros pasos
- 15. Clases, Primeras clases
- 16. Clases, Método constructor
- 17. Clases, Herencia
- 1. Introduccion
- 2. Primeros pasos
- 3. Ruteo entre múltiples archivos
- 4. CRUD básico
- 5. Prefijo en las rutas
- 6. Limitar los valores permitidos (Datos predefinidos)
- 7. Definir modelo en un archivo aparte
- 8. Parámetros con Query()
- 9. Path con Path()
- 10. Body
- 11. Validación de cuerpos de solicitud utilizando modelos Pydantic
- 12. Validaciones en las clases bases modelos
- 13. Anidar clases
- 14. Herencia
- 15. FastAPI documentación automática
- 16. Validación por campos
- 17. Tipos de campos
- 18. Valores opcionales y valores por defecto
- 19. Usar una lista como argumento
- 20. Publicar en Github
- 1. Introduccion
- 2. Códigos de estado en HTTP
- 3. Personalizar el código de estado de la respuesta en los métodos
- 4. Manejo de errores
- 5. Publicar en Github
- 1. introducción
- 2. Datos de ejemplos en modelos
- 3. Datos de ejemplos en modelos: Relaciones anidadas
- 4. Datos de ejemplos desde el argumento, Body
- 5. Listado de datos de ejemplos: OpenAPI
- 6. Datos de ejemplos en argumentos, primitivas
- 1. Introduccion
- 2. Presentación
- 3. Crear nuevo archivo de rutas
- 4. Clase File
- 5. Clase UploadFile: Bases
- 6. Clase UploadFile: Guardar archivo
- 7. Clase UploadFile: Manejar múltiples archivos
- 8. Publicar en Github
- 1. Introducción
- 2. Presentación
- 3. Instalar dependencias
- 4. Configurar conexión
- 5. Cambios en los modelos
- 6. Crear modelos (tablas) de la base de datos
- 7. Crear las tablas en la base de datos
- 8. Errores de conexión
- 9. Errores: Tabla no creada
- 10. Utilizar la conexión a la base de datos
- 11. Inyectar dependencia de la sesión de la base de datos en las rutas
- 12. Obtener una tarea
- 13. Demo: yield vs return
- 14. Resumen de conexión de SQLAlchemy y FastAPI
- 15. Métodos CRUD para las tareas: Detalle
- 16. Métodos CRUD para las tareas: Todos
- 17. Métodos CRUD para las tareas: Crear
- 18. Métodos CRUD para las tareas: Actualizar
- 19. Métodos CRUD para las tareas: Eliminar
- 20. * Cambio para Pydantic 2v
- 21. Métodos CRUD para las tareas: Paginación
- 22. Relaciones en SQLAlchemy, One to Many, categorías
- 23. Relaciones en SQLAlchemy, One to Many, categorías
- 24. Cambios en el CRUD de tareas (base de datos)
- 25. Obtener la relación desde la entidad principal
- 26. Relaciones invertidas
- 27. Reto: Relaciones invertidas: Usuario
- 28. Cambios en el CRUD de tareas (métodos de la API), Listado
- 29. Cambios en el CRUD de tareas (métodos de la API), Data de ejemplo
- 30. Adaptamos el método de crear de la rest api para que crea una tarea en la base de datos.
- 31. Cambios en el CRUD de tareas (métodos de la API), Actualizar
- 32. Cambios en el CRUD de tareas (métodos de la API), Detalle
- 33. Cambios en el CRUD de tareas (métodos de la API), Eliminar
- 34. Cambios en el CRUD de tareas (métodos de la API), Verificar que el ID existe
- 35. Cambios en el CRUD de tareas (métodos de la API), Retornar tarea en crear y actualizar
- 36. Integración de las clases de SQLAlchemy y Pydantic en la respuesta de los métodos de la API
- 37. Modelos de Pydantic de lectura y escritura
- 38. Remover columnas desde las consultas en SQLAlchemy
- 39. Relación de tipo Many to Many
- 40. Relación de tipo Many to Many, Pruebas
- 41. Emplear fechas
- 42. Extra: Métodos de la API para la relación de muchos a muchos
- 43. backref en las relaciones de tipo muchos a muchos
- 44. Publicar en Github
- 45. Primeros pasos con Alembic
- 46. Parámetros y configuraciones de Alembic y primera migración
- 47. Aplicar migraciones
- 48. Revertir cambios
- 49. Introducción a MongoDB en FastAPI con Motor
- 50. Instalar MongoDB en MacOS con Homebrew o Windows + GUI Compass
- 51. Motor: El Driver Asíncrono para MongoDB
- 52. Primera conexión a MongoDB con Motor
- 53. CRUD de Tareas con MongoDB y FastAPI
- 54. Ejemplo del Esquema Relacional en MongoDB
- 55. Relaciones
- 56. Implementación de Relaciones 1:N en MongoDB
- 1. Introducción
- 2. Presentación
- 3. Instalar y configurar Jinja en el proyecto
- 4. Bloques de control: Condicionales
- 5. Bloques de control: Ciclo for
- 6. Filtros
- 7. Filtro default
- 8. Filtro escape
- 9. Filtro conversion
- 10. Filtro max y min
- 11. Filtro round
- 12. Filtro replace
- 13. Filtro join
- 14. Filtro lower y upper
- 15. Filtro reverse
- 16. Filtro length
- 17. Filtro sort
- 18. Filtro slice
- 19. Establecer variables
- 20. Bloque
- 21. Bloque raw
- 22. Bloque macro
- 23. Templates
- 24. Herencia en los templates
- 25. Listado de tareas
- 26. Crear tarea mediante JavaScript: fetch
- 27. Crear tarea mediante JavaScript: Formulario
- 28. Crear tarea mediante JavaScript: Editar, lógica inicial
- 29. Crear tarea mediante JavaScript: Editar
- 30. Crear tarea mediante JavaScript: Resumen
- 31. Crear tarea mediante JavaScript: Eliminar
- 32. Formularios en HTML, un poco de teoría
- 33. Formularios en HTML
- 34. Publicar en github
- 1. Introducción
- 2. Presentación
- 3. Dependencias en el path (decorador de los métodos de la API)
- 4. Definir dependencias como variables
- 5. Publicar en Github
- 6. Dependencias Anidadas o Subdependencias
- 7. Patron Repository en el uso CLAVE con las Depends y Annotations
- 8. Dependencias Avanzadas con yield
- 9. El Pool de Conexiones, claves en las dependencias
- 1. Introducción
- 2. Presentación
- 3. Crear un middleware
- 4. Publicar en Github
- 1. Introducción
- 2. Presentación
- 3. Autenticación básica
- 4. Sobre la autenticación empleando la base de datos
- 5. Autenticación BD: passlib
- 6. Autenticación BD: Cambio modelo de usuario y modelo tokens
- 7. Autenticación BD: Schemas
- 8. Autenticación BD: Manejo de contraseña
- 9. Autenticación BD: Función de login
- 10. Autenticación BD: Función para crear token
- 11. Autenticación BD: Ruta para registrar un usuario
- 12. Autenticación BD: Ruta para hacer el login/crear token
- 13. Autenticación BD: Proteger rutas, esquema inicial
- 14. Autenticación BD: Proteger rutas con usuario autenticado
- 15. Autenticación BD: Logout
- 16. Protección de los métodos de la API mediante la dependencia OAuth2PasswordBearer
- 17. Verificar token de acceso al momento de crear el token
- 18. Publicar en Github
- 19. Autenticación, versión moderna
- 1. Notación de Ellipsis
- 2. Anotaciones/Annotated, primeros pasos
- 3. Anotaciones/Annotated, ejemplos
- 4. Tipos devueltos
- 1. Introducción
- 2. Presentación
- 3. Creando las primeras pruebas unitarias
- 4. Más casos
- 5. Eliminando la repetición con pytest fixtures
- 6. Extra: Loop event, presentación
- 7. Extra: Loop event, primer ejemplo
- 8. Extra: Loop event, segundo ejemplo
- 9. Configuraciones bases: BD y pytest.ini loop
- 10. Configuraciones bases: loop
- 11. Configuraciones bases: client
- 12. Probar modulo de usuario: registrar, definir función
- 13. Probar modulo de usuario: registrar, probar
- 14. Probar modulo de usuario: login
- 15. Probar modulo de usuario: logout
- 16. Probar modulo de tareas: crear una tarea
- 17. Probar modulo de tareas: crear una tarea (FormData)
- 18. Probar modulo de tareas: actualizar una tarea
- 19. Probar modulo de tareas: obtener las tareas
- 20. Probar modulo de tareas: obtener por id
- 21. Probar modulo de tareas: eliminar tareas
- 22. Probar modulo de tareas: eliminar tareas, tarea no existe
- 23. Publicar en Github
- 1. Introducción
- 2. Presentación
- 3. Configuración base
- 4. Probar modulo de usuario: registrar
- 5. Probar modulo de usuario: login
- 6. Probar modulo de usuario: logout
- 7. Probar modulo de tareas: crear una tarea
- 8. Probar modulo de tareas: crear una tarea (FormData)
- 9. Probar modulo de tareas: actualizar una tarea
- 10. Probar modulo de tareas: obtener las tareas
- 11. Probar modulo de tareas: obtener por id
- 12. Probar modulo de tareas: eliminar tareas
- 13. Probar modulo de tareas: eliminar tareas, tarea no existe
- 14. Otras pruebas: Definir módulos
- 15. Otras pruebas: Probar token en la base de datos
- 16. Otras pruebas: Rutas con OAuth2PasswordBearer
- 17. Conclusiones
- 18. Publicar en github
- 19. Dependencias Override
- 1. VSC: Seleccionar intérprete
- 2. Modo debug en VSC
- 3. Tareas en segundo plano
- 4. Introducción a Celery: Procesamiento en Segundo Plano en Python: FastAPI Django y Flask
- 5. Introducción a Celery: Procesamiento en Segundo Plano en Python: FastAPI Django y Flask
- 1. introducción
- 2. Datos de ejemplos en modelos
- 3. Relaciones anidadas
- 4. Lista de opciones en los modelos
- 5. Datos de ejemplos en argumentos, primitivas
- 6. Lista de opciones en los métodos de la API
- 7. Publicar en Github
- 1. Railway, deploy de tus aplicaciones en PHP, Python web, Node... como en Heroku GRATIS
- 2. Deploy en Railway
- 3. Deployment: Unicorn Gunicorn
- 4. Docker para desarrolladores: FastAPI
- 1. Introducción
- 2. Crear proyecto en FastAPI e instalar WebSockets
- 3. ¿Qué es un WebSocket?
- 4. Creación de una aplicación mínima con WebSockets en FastAPI
- 5. Excepciones, desconectar y conexiones simple
- 6. Gestión de Múltiples Conexiones (Connection Manager) con WebSockets
- 7. Configurar los CORS en FastAPI para consumir desde Vue
- 8. Autenticación mediante tokens para los WS, demo
- 9. Login: Demo
- 10. Definir los modelos
- 11. Recursos Rest para Habitaciones y Mensajes
- 12. Implementación de Login y Logout
- 13. Registro de usuario
- 14. Probar el Login y el Logout
- 15. Lifespan Events en FastAPI: Eventos del ciclo de vida
- 16. Configurar el Room ID en el WS para multiples conexiones
- 17. Actualizar la dependencia de verificar el token
- 18. Obtener las Alertas (Mensajes)
- 19. Recargar mensajes al recibir un mensaje
- 20. Las siguientes clases de esta sección
- 21. Arquitectura Limpia y Clean Code
- 22. Rediseño con IA: Google Antigravity
- 1. Email
- 2. FastAPI User
- 3. Gestión de Variables de Entorno con Pydantic Settings
- 4. Control de Tráfico en FastAPI: Implementando Rate Limiting
- 5. Logs con Loguru
- 6. Creando un AutoCRUD en FastAPI + SQLAlchemy
- 7. FastAPI Cache 2: Optimización con Caché
- 8. Streaming en FastAPI
- Algunas recomendaciones
Aprender FastAPI hoy no es una ventaja competitiva: es casi un requisito si quieres crear APIs modernas, rápidas y seguras con Python. Cuando empecé a explorar FastAPI, me di cuenta de que la mayoría de los recursos estaban incompletos o demasiado dispersos.
Por eso construí el curso MÁS completo de FastAPI para principiantes, actualizado por años y acompañado con recursos gratuitos desde mi blog para garantizar que domines esta tecnología de principio a fin.
Lo que aprenderás en este Curso Maestro (Resumen Ejecutivo)
- Velocidad Extrema: Domina el framework más rápido de Python (al nivel de Go y Node.js).
- ️ Validación con Pydantic: Olvídate de validar datos manualmente; FastAPI lo hace por ti de forma nativa.
- Documentación Swagger: Tu API se documenta sola de forma interactiva mientras escribes código.
- ⚡ Asincronía Real: Aprende a manejar miles de peticiones simultáneas con async/await sin bloquear el servidor.
- Seguridad de Producción: Implementa OAuth2 y JWT (Tokens) para proteger tus aplicaciones profesionales.
- Despliegue Profesional: Lleva tus contenedores o código al mundo real con total confianza y escalabilidad.
Aprender FastAPI hoy no es solo una ventaja: es el estándar para quienes buscan eficiencia, velocidad y una sintaxis impecable en Python. Este curso nace de una frustración personal: la falta de guías que conecten la teoría básica con los problemas reales de producción.
Por eso construí el programa más sólido para principiantes, actualizado permanentemente y con un enfoque 100% orientado a resultados.
A lo largo de este artículo verás qué incluye el curso, por qué es diferente a todo lo que hay ahí fuera y cómo FastAPI se convertirá en tu herramienta favorita para crear APIs profesionales.
Este es el curso MÁS completo que encontrarás de FastAPI para iniciales. Veremos desde aspectos básicos como rutas, vistas y templates, hasta el manejo avanzado de formularios, validaciones y el desarrollo de REST APIs con tokens de autenticación, el corazón de FastAPI.
Lo mejor es que es una inversión para varios años; mantendré el curso actualizado a las nuevas versiones, ofreciendo soporte continuo a través de nuestra Academia. Además, el curso es equivalente al 100% de mi libro sobre FastAPI.
De Principiante a Senior: La Verdad Sobre Aprender FastAPI
Aprender un framework backend hoy en día puede parecer abrumador. Tutoriales desactualizados, documentación técnica densa y la típica confusión: "¿Uso Pydantic o validación manual? ¿Cómo manejo la asincronía real sin bloquear el servidor? ¿Cómo estructuro mis modelos?"
Si alguna vez has sentido que la curva de aprendizaje de las APIs modernas es un muro interminable, déjame decirte algo: estás en el lugar correcto. La mayoría de los desarrolladores fracasan no por falta de capacidad, sino por seguir rutas desorganizadas. Aquí te ofrezco el puente definitivo hacia tu siguiente nivel profesional con FastAPI.
La decisión en Python: ¿Qué aprender primero?
| Objetivo | Framework Ideal | ¿Por qué? |
|---|---|---|
| Control total, APIs rápidas y microservicios | Flask | Microframework. Añade solo las piezas necesarias. Ideal para entender la web. |
| Proyectos monolíticos con CMS listo para usar | Django | Framework "Pilas incluidas". Trae administrador y ORM integrado. |
| Fast data y APIs modernas de alto rendimiento | FastAPI | Enfoque moderno, asincronía nativa y tipado estricto para evitar bugs. |
¿Por Qué Aprender FastAPI Hoy?
FastAPI es rápido, moderno y muy "Pythonico". Pero hay razones aún más prácticas para elegirlo:
Ventajas reales frente a otros frameworks
- Rendimiento altísimo gracias a ASGI.
- Validaciones automáticas sin esfuerzo.
- Documentación interactiva generada sola (Swagger y ReDoc).
- Tipado fuerte que ayuda a detectar errores antes de tiempo.
“FastAPI te obliga a programar bien sin que te des cuenta”. El propio framework te guía hacia las mejores prácticas.
Qué problemas resuelve FastAPI
- Crear APIs REST escalables de forma sencilla.
- Validar datos sin escribir código repetitivo.
- Desarrollar autenticación sólida en minutos.
¿Qué es FastAPI y Cómo Funciona? (Explicación Simple)
FastAPI es un framework web estupendo para la creación de APIs modulares y bien estructuradas. Se basa en dos pilares fundamentales:
- Pydantic: Para la validación de datos mediante modelos.
- Starlette: El motor ASGI liviano para servicios asíncronos rápidos.
¿Por qué elegir FastAPI frente a otros Frameworks?
| Característica | FastAPI | Tradicionales |
|---|---|---|
| Rendimiento | Máximo (ASGI) | Limitado (WSGI) |
| Validación | Nativa (Pydantic) | Manual / Plugins |
| Documentación | Automática | Escrita a mano |
Pydantic: El corazón de las validaciones
Pydantic valida datos como si fuera magia, ahorrándote cientos de líneas de código "sucio".
Starlette: El motor que hace volar a FastAPI
Starlette permite crear aplicaciones asíncronas y eficientes. Por eso FastAPI destaca sobre los demás.
El Poder del Tipado: Menos errores, más velocidad
FastAPI utiliza los "Type Hints" para validar todo el tráfico. Mira la diferencia:
Ejemplo Básico (A evitar)
def create_user(data):
if not data.get("email"): return "Error"
if type(data.get("age")) != int: return "Error"
# Código propenso a bugs ENFOQUE PRO
Buena Práctica Profesional
class User(BaseModel):
email: str
age: int
@app.post("/users")
async def create_user(user: User):
# ¡FastAPI ya validó todo!
return user
Objetivo
Iremos conociendo los fundamentos de FastAPI a través de una aplicación práctica que expandiremos capítulo tras capítulo.
- Dominar Pydantic para validación.
- Implementar servicios web asíncronos.
- Conectar bases de datos reales.
- Devolver respuestas en formato HTML con Jinja2.
Para quien es este libro
Dirigido a cualquier persona que quiera aprender a desarrollar sus primeras APIs con FastAPI.
- Si buscas algo más rápido que Flask o Django.
- Si quieres crear APIs reales sin complicaciones.
- Si buscas dar el salto profesional en Python.
Recursos Gratuitos para Profundizar
Accede a repositorios y demostraciones para comprobar la calidad del código que desarrollarás:
Recurso Gratuito
Lee los Primeros Capítulos Gratis
Descubre mi estilo de enseñanza antes de tomar tu decisión final.
CÓDIGO FUENTE
Repositorios Base y Apps Completas
Tendrás acceso a mis repositorios públicos con aplicaciones listas para arrancar:
Prueba la Aplicación Demo
Interactúa con el proyecto final que construirás en el curso.
Garantía de Experiencia
¿Por qué aprender conmigo?
No solo enseño sintaxis; enseño cómo construir software que aguante el tráfico real. He desarrollado sistemas escalables con FastAPI integrando bases de datos SQL y NoSQL, sistemas de colas y microservicios. En este curso no encontrarás teoría vacía, sino atajos profesionales para que puedas ir directo al éxito corporativo.
Temario del curso y libro
Capítulos Detallados
- Cap 1-2: Software y Preparación.
- Cap 3-4: Ruteo y Códigos de Estado.
- Cap 5-6: Datos de Ejemplo y Carga de Archivos.
- Cap 7-8: MySQL y Motor de Plantillas (Jinja).
- Cap 9-11: Dependencias, Middlewares y Usuarios (JWT).
Módulos del Curso
- Módulo 1: Rutas, vistas, templates y primeras páginas
- Instalación del entorno
- Rutas simples
- Templates HTML
- Primeras vistas funcionales
- Aquí uso un ejemplo muy parecido al que construí para la demo inicial.
- Módulo 2: Modelos, formularios y validaciones
- Creación de modelos con Pydantic
- Manejo de formularios
- Validaciones automáticas
- Tipado estático
- Módulo 3: APIs REST con FastAPI
- Endpoints
- Respuestas personalizadas
- Manejo de errores
- Módulo 4: Autenticación con tokens (la parte más importante)
- JWT
- Tokens de acceso
- Seguridad
- Autenticación y autorización
- Módulo 5: Base de datos, ORM y consultas
- Integramos persistencia real:
- Conexión a BD
- ORM
- CRUD completo
Preguntas Frecuentes
- ¿Para quién es este curso realmente?
- Este programa está diseñado para tres perfiles claros:
- Principiantes: Que quieren aprender a crear APIs desde cero con una base sólida.
- Desarrolladores Django/Flask: Que buscan una alternativa más rápida, moderna y tipada.
- Fullstack Devs: Que necesitan un backend potente y ligero para conectar con React, Vue o Mobile.
- Este programa está diseñado para tres perfiles claros:
- ¿FastAPI es realmente tan rápido como dicen?
- Sí. Gracias a su arquitectura basada en Starlette y Uvicorn (ASGI), FastAPI se sitúa en los primeros puestos de los benchmarks mundiales, compitiendo directamente en rendimiento con herramientas de Go y Node.js.
- ¿Qué incluye el soporte y las actualizaciones?
- Al inscribirte, no solo compras un curso, sino una inversión a largo plazo. El curso se actualiza periódicamente a las nuevas versiones de FastAPI (como el salto de Pydantic v1 a v2) y tendrás acceso al foro de la Academia para resolver dudas técnicas.
- ¿Aprenderé a llevar mi API a producción?
- Totalmente. No nos quedamos en "localhost". El curso culmina enseñándote cómo manejar la seguridad con JWT, la inyección de dependencias y las bases para el despliegue profesional en servidores reales.
- ¿Qué diferencia este curso de otros gratuitos?
- La diferencia es la curación y la profundidad. Aquí no saltamos de un tema a otro; seguimos una ruta lógica que evita que te pierdas en "tutorial hell". Todo el código es equivalente al libro oficial del curso, garantizando coherencia pedagógica.