Manejo de errores y middlewares

Curso de FastAPI

Introducción a FastAPI

¿Qué es FastAPI? con Sebastián Ramírez @Tiangolo

Instalación de FastAPI y creación de tu primera aplicación

Documentación automática con Swagger

Métodos HTTP en FastAPI

FastAPI Path Operations

Método GET en FastAPI

Crear parámetros de ruta en FastAPI

Parámetros Query en FastAPI

Método POST en FastAPI

Métodos PUT y DELETE en FastAPI

Validaciones con Pydantic

Creación de esquemas con Pydantic

Validaciones de tipos de datos con Pydantic

Validaciones de parámetros con Pydantic

JSONResponse: Tipos de respuestas en FastAPI

Códigos de estado HTTP en FastAPI

Autenticación en FastAPI

Flujo de autenticación en FastAPI

Generando tokens con PyJWT

Validando tokens con PyJWT

Middlewares de autenticación en FastAPI

Conexión con bases de datos en FastAPI

SQLAlchemy: el ORM de FastAPI

Instalación y configuración de SQLAlchemy

Creación de modelos con SQLAlchemy

Registro de datos con SQLAlchemy

Consulta de datos con SQLAlchemy

Modificación y eliminación de datos con SQLAlchemy

SQLModel: el futuro ORM de FastAPI

Modularización

Manejo de errores y middlewares en FastAPI

Creación de routers en FastAPI

Servicios para consultar datos

Servicios para registrar y modificar datos

Despliegue de Aplicación en FastAPI

Preparando el proyecto para desplegar a producción

¿Cómo elegir entre GitHub y GitLab?

Crear repositorio en GitLab

Crear Droplet en Digital Ocean

Instalación de herramientas para el servidor

Ejecutando FastAPI con NGINX

Próximos pasos

¿Quieres más cursos de FastAPI?

Bonus

Cómo crear una API de alto rendimiento en tiempo récord - Sebastián Ramírez

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

Aportes 5

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Facundo Soto

hace 5 meses

Pro tip: Podemos exportar el JWTBearer mas rápido; si haces segundo click en la clase y clickeas en "Refactorizar" (refactor) puedes elegir exportarla en un nuevo archivo, y esto funciona tanto para la clase como los imports necesarios!

Cindy Marcela Jiménez Saldarriaga

hace 9 meses

Hay un error en el video, 1:42, en realidad el metodo **** `__init__(self)`**** no es ningun metodo constructor es un inicializador , hay una gran discussion alrededor de todo esto, pero los pythonistas en realidad no llamamos a esto constructor. Puedes revisar en StackOverflow init-as-a-constructor .

Angello Triviño Umaña

hace 7 meses

**Error:** ../middlewares/error\_handler.py", line 9, in ErrorHandler async def dispatch(self, request: Request, call\_next) -> Response | JSONResponse: TypeError: unsupported operand type(s) for |: 'type' and 'type' En la linea del archivo "error\_handler.py": ```python async def dispatch(self, request: Request, call_next) -> Response | JSONResponse: ```Quitar la clase: "JSONResponse:" ```js async def dispatch(self, request: Request, call_next) -> Response: ```

Faustino Vasquez

hace 6 meses

```js from fastapi.responses import JSONResponse from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint from fastapi import FastAPI, Request from starlette.responses import Response class ErrorHandler(BaseHTTPMiddleware): def __init__(self, app: FastAPI) -> None: super().__init__(app) async def dispatch(self, request: Request, call_next) -> Response |JSONResponse: try: return await call_next(request) except Exception as e: return JSONResponse(status_code=500, content={'error':str(e)}) ```

Joan Sebastián Muñoz Ramírez

hace 8 meses

Usando Pycharm me manda el siguiente error al agregar el Middleware "Expected type 'Type\[\_MiddlewareClass]' (matched generic type 'Type\[\_MiddlewareClass\[ParamSpec("P")]]'), got 'Type\[ErrorHandler]' instead "from starlette.requests import Request from starlette.responses import JSONResponse class ErrorHandler: async def \_\_call\_\_(self, request: Request, call\_next): try: response = await call\_next(request) return response except Exception as e: return JSONResponse({"error": str(e)}, status\_code=500) y esta es la solución. El **ErrorHandler** debe ser de esta manera: ```python from starlette.requests import Request from starlette.responses import JSONResponse class ErrorHandler: async def __call__(self, request: Request, call_next): try: response = await call_next(request) return response except Exception as e: return JSONResponse({"error": str(e)}, status_code=500) ```from starlette.requests import Request from starlette.responses import JSONResponse class ErrorHandler: async def \_\_call\_\_(self, request: Request, call\_next): try: response = await call\_next(request) return response except Exception as e: return JSONResponse({"error": str(e)}, status\_code=500)