1. Introducción a FastAPI

¿Qué es FastAPI?

FastAPI es un framework web moderno, rápido (de alto rendimiento) para construir APIs con Python 3.7+ que se ha convertido en una de las opciones más populares para desarrollo backend. Fue creado por Sebastián Ramírez (tiangolo) y combina lo mejor de tecnologías modernas para ofrecer una experiencia de desarrollo excepcional.

FastAPI se caracteriza por:

  • Rendimiento excepcional: Comparable con NodeJS y Go, se puede considerar el framework más rápido de Python, superando a frameworks como Django y Flask.

  • Desarrollo ultrarrápido: es un framework que permite una reducción de código repetitivo en ~40%.

  • Documentación interactiva automática: Incluye documentación interactiva automática (OpenAPI y JSON Schema).

  • Autocompletado inteligente en editores de código: Ofrece autocompletado inteligente en editores de código.

  • Fácil de aprender: Cuenta con una sintaxis intuitiva.

  • Diseño minimalista pero potente: Posee un diseño minimalista pero potente.

Soporte completo para type hints: Incluye soporte completo para type hints.

Validación automática de datos

Requisitos Previos

Antes de comenzar, necesitarás:

  • Python 3.7 o superior
  • pip (gestor de paquetes de Python).

Instalación del proyecto

Para empezar, crearemos un una nueva carpeta donde nosotros queramos.

mkdir fastapi_project
cd fastapi_project

Y comenzaremos a crear el entorno de desarrollo, creando un entorno virtual.

¿Qué es un Entorno Virtual?

Un entorno virtual es un espacio aislado que contiene todas las librerías necesarias para un proyecto específico. Imagínalo como una caja de herramientas independiente para cada uno de tus proyectos de Python, donde puedes instalar versiones específicas de bibliotecas sin afectar otros proyectos.

Si no usaramos un entorno virtual, todas las librerías que instalamos con pip se instalarían en nuestro sistema de forma global, lo que podría causar conflictos entre proyectos.

Para crear el entorno virtual, usaremos venv. Este es un módulo estándar de Python (incluido desde Python 3.3) que te permite crear entornos virtuales ligeros. Aunque no es la única, es la forma sencillla en Python para gestionar entornos virtuales, que no requiere instalaciones adicionales.

Otras alternativa muy recomendada es virtualenv, que es una herramienta externa que permite crear entornos virtuales con más control y flexibilidad. Es mi recomendacion si tienes experiencia con Python o quieres indagar mas en este tipo de herramientas.

Instalación Básica

Ahora sabiendo que es un entorno virtual, procedemos a crearlo:

# Crear el entorno virtual
python -m venv venv

# El entorno virtual con venv se crea en una carpeta 
# llamada .venv, la cual vamos a encontrar en nuestro proyecto.

# Sin embargo, aquí solo hemos creado el entorno, ahora debemos activarlo.

# Activar el entorno virtual
# En Windows:
.\venv\Scripts\activate

# En macOS/Linux:
source venv/bin/activate

# Una vez activado, verás que el nombre del entorno 
# virtual aparece al inicio de la línea de comandos.

(venv) usuario@hostname:~/fastapi_project$ 

# Esto indica que el entorno virtual está activado y que todas 
# las instalaciones de paquetes se harán dentro de este espacio de trabajo. 
# Si deseas desactivar el entorno virtual, simplemente ejecuta:

# En Windows:
.\venv\Scripts\deactivate

# En macOS/Linux:
deactivate

Ahora que tenemos nuestro entorno virtual activado, procedemos a instalar las dependencias necesarias para nuestro proyecto.

pip install fastapi[standard]

FastAPI es el framework que vamos a usar para crear nuestra API y uvicorn es el servidor que vamos a usar para ejecutar nuestra API. Entendemos como servidor a la librería la cual le permitirá a nuestra API recibir peticiones HTTP y devolver respuestas, mientras que fast api es el framework que nos permitirá crear la API.

Hasta el momento, nuestro proyecto luce así:

fastapi_project
└── .venv

Unicamente con el entorno virtual creado.

Ahora vamos a crear nuestra api creando una carpeta app, y dentro de app crearemos un archivo init.py y main.py en donde copiaremos lo siguiente:

from fastapi import FastAPI # Importamos FastAPI

app = FastAPI() # Creamos una instancia de FastAPI, este es el punto de entrada de 
# nuestra API

# A partir de aquí, crearemos nuestra api:

# Creamos una ruta GET, esta se ejecutará si el usuario accede a la ruta /.
# Ejemplo: http://localhost:8000/
@app.get("/") 
def read_root():
    return {"message": "¡Hola, FastAPI!"}

# Creamos una ruta GET con un parámetro, 
# esto se ejecutará si el usuario accede a la ruta /items/{item_id}.
# Ejemplo: http://localhost:8000/items/1
@app.get("/items/{item_id}") 
def read_item(item_id: int):
    return {"item_id": item_id}

En la segunda ruta, nota como estamos indicando el tipo de dato en item_id. En este caso, item_id es un entero, por lo tanto indicamos que es int usando dos puntos.

Esto es lo que se conoce como type hints, y en python podemos tipar cada variable de acuerdo a lo que nosotros queramos que esa variable contenga. Por ejemplo, si tuviera la variable mi_variable, podria tiparla de la siguiente forma:

mi_variable: int # Indica que el parámetro mi_variable es un entero.
mi_variable: str # Indica que el parámetro mi_variable es un string.
mi_variable: float # Indica que el parámetro mi_variable es un float.
mi_variable: bool # Indica que el parámetro mi_variable es un booleano
mi_variable: list # Indica que el parámetro mi_variable es una lista.
mi_variable: dict # Indica que el parámetro mi_variable es un diccionario.

Esto es muy importante, ya que nos puede solventar muchos errores, especialmente cuando intentamos hacer operaciones entre tipos de datos. Además que los editores de código al saber el tipo de dato, ofrecen autocompletado, lo que nos ayuda a escribir código más rápido y con menos errores.

Hasta este punto, nuestro proyecto lucirá así:

fastapi_project
├── .venv
└── app/
    ├── __init__.py
    └── main.py

Ahora que tenemos nuestra primera aplicación, procedemos a ejecutarla.

fastapi dev app/main.py

Verificación de la Instalación

Al ejecutar el codigo anterior, deberias aparecer muchos detalles en la terminal, entre ellos, dos lineas parecias a estas:

server   Server started at http://127.0.0.1:8000
server   Documentation at http://127.0.0.1:8000/docs

Esto indica que nuestro servidor se ha iniciado correctamente y que la documentación de nuestra API se encuentra disponible en http://127.0.0.1:8000/docs.

Primero vamos a abrir nuestro navegador y escribiremos en la url http://127.0.0.1:8000 deberías ver el mensaje: {“message”:“¡Hola, FastAPI!”}.

alt text

Si el mensaje no aparece, es porque el servidor no se ha iniciado correctamente.

Luego, vamos a irnos a la segunda url, http://127.0.0.1:8000/docs, en donde veremos algo parecido a esto:

alt text

En esta página podemos probar nuestros endpoints de forma fácil y rápida, dando click en los endpoints y luego en try out.

Siguientes Pasos

Felicidades, ahora tienes una API básica con FastAPI. Sin embargo, hay mucho más que aprender. Asi que ahora iremos al siguiente capítulo en donde detallaremos cómo crear rutas con FastAPI y pydantic.