Guía completa de API REST con FastAPI y Python para México: pagos, OAuth y despliegue

Introducción

FastAPI ha emergido como la opción preferida para desarrollar **APIs REST** en la **Ciudad de México** gracias a su rendimiento cercano a Node.js y su facilidad para escribir código tipado con Python. Los equipos de desarrollo en la CDMX valoran su generación automática de documentación OpenAPI, su compatibilidad con **async/await** y la integración nativa con herramientas de validación como **Pydantic**. Estas ventajas se traducen en tiempos de entrega más cortos, menor deuda técnica y una mejor experiencia para los clientes de startups y PyMEs mexicanas.

En este contexto, **Light Innovations Lab** se posiciona como socio tecnológico estratégico: somos una fábrica de soluciones AI‑native con sede en la CDMX, y acompañamos a los CTOs y arquitectos en la construcción, pruebas y despliegue de APIs productivas, incluyendo integraciones locales de pagos y autenticación. En los siguientes apartados descubrirás cómo levantar una API FastAPI lista para producción en México, conectar con OpenPay y Conekta, asegurarla con OAuth2 nacional y desplegarla en la nube con latencia mínima para usuarios de la CDMX.

---

Configuración inicial y arquitectura orientada a producción en México

Estructura del proyecto

```text

my_fastapi_app/

├─ app/

│ ├─ api/

│ │ ├─ v1/

│ │ │ ├─ endpoints/

│ │ │ └─ __init__.py

│ ├─ core/

│ │ ├─ config.py

│ │ └─ security.py

│ ├─ db/

│ │ ├─ models.py

│ │ └─ session.py

│ └─ main.py

├─ tests/

├─ .env

├─ Dockerfile

├─ docker-compose.yml

└─ requirements.txt

```

Esta arquitectura separa claramente la capa de **API**, la configuración central y el acceso a la base de datos, facilitando el trabajo de equipos distribuidos en la CDMX.

Manejo de entornos con .env

```python

# app/core/config.py

from pydantic import BaseSettings, Field

class Settings(BaseSettings):

ENV: str = Field(..., env='ENV')

DB_URL: str = Field(..., env='DB_URL')

SECRET_KEY: str = Field(..., env='SECRET_KEY')

OPENPAY_KEY: str = Field(..., env='OPENPAY_KEY')

CONEKTA_KEY: str = Field(..., env='CONEKTA_KEY')

class Config:

env_file = '.env'

settings = Settings()

```

Al mantener las credenciales fuera del repositorio, los equipos pueden trabajar en **dev**, **staging** y **prod** sin riesgos de exposición.

Pydantic y dependencias

FastAPI usa **Pydantic** para validar datos de entrada y salida. Definir esquemas claros reduce los errores de integración con sistemas de pago mexicanos.

```python

# app/api/v1/schemas.py

from pydantic import BaseModel, condecimal

class PaymentRequest(BaseModel):

amount: condecimal(gt=0, max_digits=10, decimal_places=2)

currency: str = 'MXN'

description: str

customer_id: str

```

Las dependencias se inyectan mediante el sistema de **Depends**, lo que permite reutilizar lógica de conexión a bases de datos o a clientes externos (OpenPay, Conekta) sin acoplar el código.

---

Integración con servicios de pago mexicanos (OpenPay y Conekta)

1. Configuración del cliente OpenPay

```python

# app/api/v1/dependencies.py

import openpay

from app.core.config import settings

def get_openpay_client():

client = openpay.Openpay(settings.OPENPAY_KEY, 'YOUR_MERCHANT_ID')

client.production = False # Cambiar a True en prod

return client

```

2. Endpoint de cobro

```python

# app/api/v1/endpoints/payments.py

from fastapi import APIRouter, Depends, HTTPException

from app.api.v1.schemas import PaymentRequest

from app.api.v1.dependencies import get_openpay_client

from sqlalchemy.orm import Session

from app.db.session import get_db

router = APIRouter(prefix='/payments', tags=['payments'])

@router.post('/openpay')

async def create_openpay_charge(payload: PaymentRequest,

client = Depends(get_openpay_client),

db: Session = Depends(get_db)):

try:

charge = client.Charge.create({

'method': 'card',

'source_id': payload.customer_id,

'amount': float(payload.amount),

'currency': payload.currency,

'description': payload.description,

})

# Guardar en MySQL/MariaDB

db.execute("INSERT INTO payments (tx_id, amount, status) VALUES (:id, :amt, :st)",

{'id': charge.id, 'amt': payload.amount, 'st': charge.status})

db.commit()

return {'status': 'ok', 'id': charge.id}

except Exception as e:

raise HTTPException(status_code=400, detail=str(e))

```

3. Validación de webhooks

```python

# app/api/v1/endpoints/webhooks.py

from fastapi import Request, APIRouter, Header, HTTPException

import hmac, hashlib

router = APIRouter(prefix='/webhooks', tags=['webhooks'])

@router.post('/openpay')

async def openpay_webhook(request: Request, x_signature: str = Header(None)):

body = await request.body()

expected = hmac.new(settings.OPENPAY_KEY.encode(), body, hashlib.sha256).hexdigest()

if not hmac.compare_digest(expected, x_signature):

raise HTTPException(status_code=401, detail='Invalid signature')

data = await request.json()

# actualizar estado de la transacción en la base de datos

return {'received': True}

```

4. Integración con Conekta (similar)

Conekta ofrece SDK en Python; el flujo es análogo: crear cliente, generar cargo y registrar webhook. La diferencia principal está en los campos de **order_id** y la necesidad de enviar **livemode** según el entorno.

---

Autenticación y autorización con proveedores OAuth2 nacionales

En México, además de Google y Azure, muchas empresas requieren integración con el **SAT (e.firma)** para validar la identidad de usuarios de gobierno. FastAPI Security simplifica la configuración.

```python

# app/core/security.py

from fastapi.security import OAuth2AuthorizationCodeBearer

from starlette.config import Config

config = Config('.env')

# Google México

google_oauth = OAuth2AuthorizationCodeBearer(

authorizationUrl='https://accounts.google.com/o/oauth2/v2/auth',

tokenUrl='https://oauth2.googleapis.com/token',

scopes={'openid': 'OpenID Connect'}

)

# Azure AD (Región México)

azure_oauth = OAuth2AuthorizationCodeBearer(

authorizationUrl='https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize',

tokenUrl='https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token',

scopes={'api://your-api/.default': 'Acceso a la API'}

)

# SAT e.firma (ejemplo simplificado)

sat_oauth = OAuth2AuthorizationCodeBearer(

authorizationUrl='https://login.sat.gob.mx/oauth/authorize',

tokenUrl='https://login.sat.gob.mx/oauth/token',

scopes={'signature': 'Firma electrónica'}

)

```

Uso en rutas protegidas

```python

@router.get('/secure-data')

async def secure_endpoint(token: str = Depends(google_oauth)):

# Decodificar y validar token, refrescar si es necesario

return {'msg': 'Acceso concedido'}

```

FastAPI permite combinar varios esquemas; basta con declarar varios **Depends** y validar el origen del token.

---

Despliegue en la nube con región México (DigitalOcean México, Azure México, AWS Saúl)

Dockerfile optimizado

```Dockerfile

FROM python:3.11-slim

ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .

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

COPY . .

EXPOSE 8000

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

```

CI/CD con GitHub Actions (region‑aware)

```yaml

name: Deploy to DigitalOcean

on:

push:

branches: [main]

jobs:

build-and-deploy:

runs-on: ubuntu-latest

steps:

• uses: actions/checkout@v3
• name: Set up Python

uses: actions/setup-python@v4

with:

python-version: '3.11'

• name: Install deps

run: pip install -r requirements.txt

• name: Build Docker image

run: |

docker build -t registry.digitalocean.com/mi-registro/fastapi-app:${{ github.sha }} .

• name: Push to DOCR

env:

DOCKER_PASSWORD: ${{ secrets.DOCR_PASSWORD }}

run: |

echo $DOCKER_PASSWORD | docker login registry.digitalocean.com -u ${{ secrets.DOCR_USER }} --password-stdin

docker push registry.digitalocean.com/mi-registro/fastapi-app:${{ github.sha }}

• name: Deploy to App Platform (Mexico)

uses: digitalocean/app-action@v1

with:

api-token: ${{ secrets.DO_API_TOKEN }}

app-id: ${{ secrets.DO_APP_ID }}

```

Configuración de bases de datos gestionadas

• **DigitalOcean Managed PostgreSQL – Región: `nyc3` (latencia mínima para CDMX)**
• **Azure Database for MySQL – Región: `Mexico Central`**
• **AWS RDS (Saúl) – Región: `us-east-2` (proximal a la CDMX)**

En los archivos de configuración (`.env`) se añaden los endpoints y credenciales seguros.

CDN y SSL local

Utiliza **Cloudflare México** o **Azure Front Door** para servir la documentación OpenAPI vía HTTPS y reducir la latencia. Configura certificados automáticos con **Let’s Encrypt** dentro del contenedor o delega a la plataforma cloud.

---

Pruebas de carga, profiling y buenas prácticas de seguridad para producción en CDMX

Herramientas de carga

• **Locust** – script Python que simula usuarios concurrentes desde un servidor en la CDMX.
• **k6** – ejecutable ligero que se puede correr en una VM de DigitalOcean México.

```bash

locust -f tests/load_test.py --host=https://api.midominio.com.mx

```

Profiling con Py‑Spy

```bash

py-spy top --pid $(pgrep -f uvicorn) --rate 1000

```

Esto ayuda a identificar cuellos de botella en rutas críticas, como la generación de cargos.

Hardening de FastAPI

• **CORS**: limitar orígenes a dominios `.mx` y sub‑dominios de la empresa.

```python

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(

CORSMiddleware,

allow_origins=["https://*.midominio.com.mx"],

allow_credentials=True,

allow_methods=["GET", "POST", "PUT", "DELETE"],

allow_headers=["*"],

)

```

• **Rate limiting** con **slowapi** para evitar ataques de fuerza bruta.
• **HTTPS obligatorio** – forzar redirección en el nivel del load balancer (Azure Application Gateway, DigitalOcean Load Balancer).
• **Monitoreo**: Grafana + Loki + Prometheus desplegados en una VM en la CDMX para recolectar métricas de latencia, errores 5xx y trazas de logs.

---

Conclusión

FastAPI se ha convertido en la herramienta ideal para crear APIs REST robustas y escalables en México, ofreciendo rendimiento, tipado y una experiencia de desarrollo que encaja con los equipos de la **Ciudad de México**. Con esta guía has visto cómo estructurar el proyecto, integrar pagos locales como OpenPay y Conekta, asegurar la API con OAuth2 nacional y desplegarla en la nube con latencia mínima para usuarios de la CDMX. ¿Listo para llevar tu producto al siguiente nivel? Descarga nuestro checklist de despliegue y **[Contáctanos](https://lightinnovationlab.com/#contact)** para recibir asesoría personalizada de Light Innovations Lab.