Instalación de FastAPI y configuración

Instalación de FastAPI y Uvicorn

Para comenzar a desarrollar con FastAPI, necesitamos instalar dos componentes esenciales: el propio framework FastAPI y Uvicorn, que actuará como nuestro servidor ASGI. ASGI (Asynchronous Server Gateway Interface) es el estándar que permite a FastAPI manejar peticiones de forma asíncrona y eficiente.

Verificación de Python

Antes de proceder con la instalación, asegúrate de tener Python 3.13 instalado en tu sistema. Puedes verificarlo ejecutando el siguiente comando en tu terminal o línea de comandos:

python --version

Si el comando anterior no funciona, prueba con:

python3 --version

Deberías ver una salida similar a Python 3.13.x. Si no tienes Python 3.13 instalado, descárgalo desde el sitio oficial de Python antes de continuar.

Configuración del entorno de desarrollo

Antes de instalar FastAPI, es una buena práctica configurar un entorno virtual. Los entornos virtuales nos permiten aislar las dependencias de nuestro proyecto, evitando conflictos entre diferentes proyectos de Python y manteniendo nuestro sistema limpio.

Creación del entorno virtual

Python incluye la herramienta venv para crear entornos virtuales. Navega hasta la carpeta donde quieres crear tu proyecto y ejecuta:

python -m venv fastapi_env

Si estás en un sistema donde necesitas especificar Python 3, utiliza:

python3 -m venv fastapi_env

Este comando creará una nueva carpeta llamada fastapi_env que contendrá:

• Una copia del intérprete de Python
• Las herramientas pip y setuptools
• Un directorio para instalar paquetes de forma aislada

Activación del entorno virtual

Una vez creado el entorno virtual, necesitas activarlo. Los comandos varían según tu sistema operativo:

En Windows (PowerShell):

fastapi_env\Scripts\Activate.ps1

En Windows (Command Prompt):

fastapi_env\Scripts\activate.bat

En macOS y Linux:

source fastapi_env/bin/activate

Cuando el entorno esté activado, verás el nombre del entorno entre paréntesis al inicio de tu prompt:

(fastapi_env) C:\tu\ruta\del\proyecto>

Creación del archivo requirements.txt

Es recomendable mantener un registro de todas las dependencias de tu proyecto en un archivo requirements.txt. Crea este archivo en la raíz de tu proyecto con el siguiente contenido:

fastapi==0.115.0
uvicorn[standard]==0.31.0

Este archivo especifica:

• fastapi: El framework web que utilizaremos
• uvicorn[standard]: El servidor ASGI con dependencias adicionales para mejor rendimiento

Instalación desde requirements.txt

Con el entorno virtual activado, instala todas las dependencias ejecutando:

pip install -r requirements.txt

Este comando instalará automáticamente FastAPI, Uvicorn y todas sus dependencias en el entorno virtual aislado.

Instalación alternativa (solo si no usas requirements.txt)

Como alternativa al método recomendado anterior, también puedes instalar los paquetes directamente con pip:

pip install fastapi uvicorn

Nota: Recuerda siempre tener tu entorno virtual activado antes de instalar cualquier paquete.

Verificación de la instalación

Para confirmar que la instalación se completó correctamente, puedes verificar las versiones instaladas:

pip show fastapi

pip show uvicorn

Estos comandos mostrarán información detallada sobre los paquetes instalados, incluyendo la versión. FastAPI v0.115 incluye mejoras significativas en rendimiento y nuevas características que utilizaremos a lo largo del curso.

Posibles problemas y soluciones

Si encuentras errores durante la instalación, aquí tienes las soluciones más comunes:

Error de permisos: En algunos sistemas, especialmente macOS y Linux, podrías necesitar usar sudo antes del comando pip, aunque no es la práctica recomendada.

Comando pip no encontrado: Si pip no es reconocido, prueba con python -m pip install fastapi uvicorn o python3 -m pip install fastapi uvicorn.

Versión antigua de pip: Actualiza pip con pip install --upgrade pip antes de instalar FastAPI.

Una vez completada la instalación, tendrás todo lo necesario para crear tu primera aplicación FastAPI. En la siguiente sección crearemos nuestro primer "Hello World" y lo ejecutaremos usando Uvicorn.

Creación del primer "Hello World"

Ahora que tenemos FastAPI y Uvicorn instalados, vamos a crear nuestra primera aplicación web. Comenzaremos con el ejemplo más básico: un "Hello World" que responda a las peticiones HTTP.

Estructura del proyecto

Crea una nueva carpeta para tu proyecto y dentro de ella los archivos necesarios. La estructura recomendada es:

mi_proyecto_fastapi/
├── fastapi_env/          # Entorno virtual (generado automáticamente)
├── requirements.txt      # Dependencias del proyecto
└── main.py              # Punto de entrada de la aplicación

El archivo main.py será el punto de entrada de nuestra aplicación, mientras que requirements.txt contiene todas las dependencias necesarias.

Código del Hello World

Abre el archivo main.py en tu editor de texto favorito y escribe el siguiente código:

from fastapi import FastAPI

# Crear una instancia de la aplicación FastAPI
app = FastAPI()

# Definir una ruta básica
@app.get("/")
def read_root():
    return {"message": "Hello World"}

Este código hace tres cosas fundamentales:

• Importa FastAPI: Traemos la clase principal del framework
• Crea la aplicación: La variable app es nuestra aplicación web
• Define una ruta: El decorador @app.get("/") indica que esta función responderá a peticiones GET en la ruta raíz

Explicación del código

La función read_root() es lo que llamamos un path operation function. Cuando alguien visite la URL base de nuestra aplicación, FastAPI ejecutará esta función y devolverá el diccionario como respuesta JSON.

El decorador @app.get("/") tiene dos partes importantes:

• get: Especifica el método HTTP (GET, POST, PUT, DELETE, etc.)
• “/”: Define la ruta o path donde estará disponible esta función

Ejecutar la aplicación

Para poner en marcha nuestro servidor de desarrollo, asegúrate de que tu entorno virtual esté activado, abre una terminal en la carpeta donde guardaste main.py y ejecuta:

uvicorn main:app --reload

Este comando le dice a Uvicorn que:

• main: Busque el archivo main.py
• app: Use la variable app como aplicación ASGI
• --reload: Reinicie automáticamente cuando detecte cambios en el código

Verificar que funciona

Si todo va bien, verás una salida similar a esta en tu terminal:

INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [12345] using StatReload
INFO:     Started server process [12346]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Ahora abre tu navegador web y visita http://127.0.0.1:8000 o http://localhost:8000. Deberías ver:

{"message": "Hello World"}

Documentación automática

Una de las características más útiles de FastAPI es que genera documentación automática. Sin escribir código adicional, puedes acceder a:

• Swagger UI: Visita http://127.0.0.1:8000/docs
• ReDoc: Visita http://127.0.0.1:8000/redoc

Estas interfaces te permiten probar tu API directamente desde el navegador y ver toda la documentación generada automáticamente.

Detener el servidor

Para detener el servidor de desarrollo, simplemente presiona Ctrl+C en la terminal donde está ejecutándose Uvicorn. Verás un mensaje confirmando que el servidor se ha detenido correctamente.

Desactivar el entorno virtual

Cuando termines de trabajar en tu proyecto, puedes desactivar el entorno virtual ejecutando:

deactivate

Este comando te devuelve al entorno global de Python. El prompt volverá a su estado normal sin mostrar el nombre del entorno virtual.