Guía completa de API REST con FastAPI y Python para desarrolladores en la CDMX

Introducción: Por qué FastAPI es la mejor opción para APIs REST en la CDMX

FastAPI se ha convertido en el framework favorito de los desarrolladores que buscan **velocidad**, **tipado estático** y una **comunidad vibrante**. En la Ciudad de México, donde los proyectos fintech y las iniciativas gubernamentales requieren respuestas en milisegundos y cumplimiento normativo, FastAPI ofrece ventajas claras:

• **Rendimiento**: construido sobre Starlette y Pydantic, FastAPI alcanza velocidades cercanas a Node.js y Go, algo esencial para aplicaciones que manejan cientos de transacciones por segundo en la CDMX.
• **Tipado y documentación automática**: gracias a los *type hints* de Python 3.11, el IDE genera autocompletado y la documentación OpenAPI/Swagger está disponible al instante, reduciendo el tiempo de desarrollo.
• **Comunidad local**: cada vez más meet‑ups y workshops en México adoptan FastAPI, lo que facilita encontrar talento y soporte técnico.

En este artículo, veremos paso a paso cómo instalar, configurar y desplegar una API REST con FastAPI, siempre con ejemplos y consideraciones específicas para **México**.

---

1. Instalación y configuración inicial adaptada al entorno mexicano

1.1 Requisitos de sistema

1. **Python 3.11** – La versión más reciente ofrece mejoras de rendimiento y tipado.

2. **virtualenv** – Aísla las dependencias del proyecto.

3. **Variables de entorno** – Necesarias para conectar con servicios del SAT, AFIRME y otros sistemas gubernamentales.

```bash

# Instalar pyenv (opcional) para gestionar versiones de Python

curl https://pyenv.run | bash

# Instalar Python 3.11

pyenv install 3.11.9

pyenv global 3.11.9

# Crear entorno virtual

python -m venv .venv

source .venv/bin/activate

# Instalar FastAPI y Uvicorn

pip install fastapi[all] uvicorn

```

1.2 Configuración de variables de entorno para SAT/AFIRME

En México, la facturación electrónica requiere credenciales del **SAT** y la plataforma **AFIRME**. Guardamos estas claves en un archivo `.env` y las cargamos con **python‑dotenv**.

```bash

# .env

SAT_RFC=AAA010101AAA

SAT_CERT_PATH=/path/to/cert.cer

SAT_KEY_PATH=/path/to/key.key

AFIRME_TOKEN=eyJhbGciOi... (jwt)

```

```python

# config.py

from pathlib import Path

from dotenv import load_dotenv

env_path = Path('.') / '.env'

load_dotenv(dotenv_path=env_path)

import os

SAT_RFC = os.getenv('SAT_RFC')

SAT_CERT_PATH = os.getenv('SAT_CERT_PATH')

SAT_KEY_PATH = os.getenv('SAT_KEY_PATH')

AFIRME_TOKEN = os.getenv('AFIRME_TOKEN')

```

Con esta configuración, cualquier endpoint que necesite firmar CFDI o validar datos contra AFIRME podrá hacerlo sin exponer credenciales.

---

2. Casos de uso locales: integración con servicios gubernamentales de la CDMX

2.1 API de datos abiertos de la CDMX

La **CDMX** publica cientos de datasets vía su portal de datos abiertos. Un caso típico es exponer un endpoint que filtre el catálogo de **parques** y lo sirva a una aplicación móvil.

```python

from fastapi import FastAPI, Query

import httpx

app = FastAPI(title="API de Parques CDMX")

CDMX_DATA_URL = "https://datos.cdmx.gob.mx/api/3/action/package_show?id=parques"

@app.get("/parques")

async def listar_parques(limit: int = Query(10, ge=1, le=100)):

async with httpx.AsyncClient() as client:

resp = await client.get(CDMX_DATA_URL)

data = resp.json()["result"]["resources"][0]["records"]

return data[:limit]

```

2.2 Facturación electrónica (CFDI) con SAT

Para una fintech que emite facturas electrónicas, el flujo típico es:

1. Recibir datos del cliente.

2. Generar el XML del CFDI.

3. Firmar con el certificado del SAT.

4. Enviar al timbrado.

```python

from fastapi import FastAPI, Body, HTTPException

from lxml import etree

import subprocess

app = FastAPI()

@app.post("/cfdi")

async def timbrar_cfdi(payload: dict = Body(...)):

# 1. Generar XML (simplificado)

root = etree.Element("cfdi:Comprobante", Version="4.0")

# ... agregar nodos con datos del payload ...

xml_bytes = etree.tostring(root, xml_declaration=True, encoding="UTF-8")

# 2. Firmar con OpenSSL (se asume que OpenSSL está instalado)

with open('cfdi.xml', 'wb') as f:

f.write(xml_bytes)

try:

subprocess.check_output([

"openssl", "smime", "-sign",

"-in", "cfdi.xml",

"-signer", os.getenv('SAT_CERT_PATH'),

"-inkey", os.getenv('SAT_KEY_PATH'),

"-outform", "DER",

"-out", "cfdi_signed.der"

])

except subprocess.CalledProcessError as e:

raise HTTPException(status_code=500, detail="Error al firmar CFDI")

# 3. Enviar al timbrado (simulado)

return {"status": "timbrado", "file": "cfdi_signed.der"}

```

2.3 Pagos SPEI a través de bancos mexicanos

Muchas startups utilizan la red **SPEI** para transferencias instantáneas. Con la API de **BBVA México** (ejemplo), podemos crear un endpoint que inicie un pago.

```python

@app.post("/spei/pagar")

async def pagar_spei(monto: float = Body(...), referencia: str = Body(...)):

# Simulación de llamada al SDK del banco

response = await banco_sdk.transferir(monto, referencia)

if response['status'] != 'OK':

raise HTTPException(status_code=502, detail="Error en el banco")

return {"status": "exitoso", "referencia": referencia}

```

---

3. Buenas prácticas de seguridad para datos sensibles en México

3.1 Autenticación con JWT y OAuth2

FastAPI incluye soporte nativo para OAuth2 con **Password flow**. Para cumplir con la **Ley Federal de Protección de Datos Personales en Posesión de los Particulares (LFPDPPP)**, es fundamental usar tokens firmados y expiración corta.

```python

from fastapi.security import OAuth2PasswordBearer

from jose import JWTError, jwt

SECRET_KEY = "supersecretkey" # debe almacenarse en vault o secret manager

ALGORITHM = "HS256"

ACCESS_TOKEN_EXPIRE_MINUTES = 30

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")

def crear_token(data: dict):

to_encode = data.copy()

expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)

to_encode.update({"exp": expire})

return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

```

3.2 Encriptación con OpenSSL y almacenamiento seguro

Los datos de tarjetas o RFC deben guardarse cifrados. Utiliza **AES‑256‑GCM** mediante la librería `cryptography` y guarda la clave en **AWS KMS** o **Azure Key Vault**.

```python

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

import os

key = os.getenv('AES_KEY') # 32 bytes base64

aesgcm = AESGCM(key)

nonce = os.urandom(12)

ciphertext = aesgcm.encrypt(nonce, b"datos sensibles", None)

```

3.3 Cumplimiento de la Ley de Protección de Datos

• **Consentimiento explícito**: registra en base de datos la aceptación del titular.
• **Registro de auditoría**: guarda logs de acceso en **CloudWatch** o **Stackdriver** con IP y timestamp.
• **Derecho al olvido**: implementa endpoint `DELETE /usuarios/{id}` que elimine toda la información personal y notifique al usuario.

---

4. Despliegue y performance en la nube mexicana

4.1 AWS México (Region us‑mexico‑1)

1. **Crear VPC** con subredes públicas y privadas.

2. **RDS Aurora Serverless** para la base de datos.

3. **Elastic Container Service (ECS) Fargate** para el contenedor Docker de FastAPI.

4. **Application Load Balancer** con terminación TLS (certificado ACM).

```dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY . .

RUN pip install --no-cache-dir -r requirements.txt

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

```

4.2 Azure México (Region mexico‑central)

• **App Service** con plan B1 (Linux) para despliegue rápido.
• **Azure Database for PostgreSQL – Flexible Server**.
• **Azure Key Vault** para secretos.

```bash

az webapp up --name fastapi-cdmx --runtime "PYTHON|3.11" --resource-group rg-cdmx

```

4.3 Google Cloud México (Region northamerica‑northeast1)

• **Cloud Run** (fully managed) para scalabilidad automática.
• **Cloud SQL (PostgreSQL)**.
• **Secret Manager** para variables.

```bash

gcloud run deploy fastapi-cdmx \

--image gcr.io/$PROJECT_ID/fastapi-cdmx \

--region northamerica-northeast1 \

--allow-unauthenticated

```

4.4 Comparativa de costos (aprox. mensual, 2026)

| Proveedor | Instancia/Plan | CPU | RAM | Precio MXN* |

|-----------|----------------|-----|-----|--------------|

| AWS | Fargate 0.5 vCPU + 1 GB | 0.5 | 1 GB | $1,200 |

| Azure | App Service B1 | 1 | 1.75 GB | $1,050 |

| GCP | Cloud Run (256 MiB) | 0.25 | 256 MiB | $950 |

\* estimado con uso promedio de 150 mil solicitudes/mes.

4.5 Pruebas de carga con Locust

```python

from locust import HttpUser, task, between

class APIUser(HttpUser):

wait_time = between(1, 3)

@task(2)

def listar_parques(self):

self.client.get("/parques?limit=20")

@task(1)

def timbrar_cfdi(self):

self.client.post("/cfdi", json={"rfc": "AAA010101AAA", "total": 1500})

```

Ejecuta `locust -f locustfile.py --host=https://api.tuempresa.com` y observa que una configuración de 50 usuarios concurrentes mantiene **latencia < 200 ms** en AWS y **< 180 ms** en GCP, cumpliendo los SLA típicos de la CDMX.

---

Conclusión

FastAPI se posiciona como la herramienta ideal para construir APIs REST robustas y rápidas en la **Ciudad de México**. Desde la instalación con Python 3.11 hasta la integración con servicios del SAT, AFIRME y la red SPEI, pasando por prácticas de seguridad alineadas con la legislación mexicana y despliegues optimizados en las tres nubes principales del país, esta guía te brinda todo lo necesario para lanzar tu proyecto con confianza.

Próximos pasos

1. **Prototype** tu primer endpoint siguiendo los ejemplos.

2. **Asegura** tus datos con JWT, encriptación y auditoría.

3. **Despliega** en la nube que mejor se ajuste a tu presupuesto.

4. **Escala** con pruebas de carga y monitoreo continuo.

En **Light Innovations Lab** ofrecemos servicios de **IT as a Service**, **CTO as a Service** y desarrollo a medida para acelerar tu puesta en producción. Nuestro equipo está basado en la CDMX y conoce a fondo los requerimientos regulatorios de México.

[Contáctanos](https://lightinnovationlab.com/#contact) para que juntos llevemos tu API al siguiente nivel.