¿Dónde publico una API en Python con FastAPI que hice con IA?

Receta para publicar una API en Python con FastAPI generada con IA: por qué va en Dongee Cloud y no en Live, Dockerfile, docker-compose, Nginx como proxy, HTTPS con certbot, snapshots, errores comunes y precios.

Una API en Python con FastAPI que hiciste con IA se publica en un servidor Dongee Cloud o en Cloud On Demand. Ahí tienes acceso root por SSH y puedes usar Docker y Docker Compose sin restricciones. Dongee Live no ejecuta Python (solo sitios estáticos y Node), así que Live te sirve únicamente si tu API está escrita en Node. Abajo tienes la receta completa, desde el servidor vacío hasta la API con HTTPS.

Actualizado el 21 de noviembre de 2026 · Equipo Dongee

¿Por qué no puedo publicar FastAPI en Dongee Live?

Dongee Live está pensado para apps hechas con ChatGPT, Lovable, Bolt, v0, Claude Code, Cursor o VS Code. Admite sitios estáticos y Node 20, 22 y 24 (Express, Fastify, Koa, Hono, Next.js standalone, TanStack Start). No admite Python, Ruby, PHP ni Docker. Si la IA te generó un backend con FastAPI, necesitas un servidor donde tú controlas el entorno: eso es Dongee Cloud.

Dongee Cloud es autogestionado: tú administras el servidor, pero tienes soporte humano 24/7 en tu idioma por chat y WhatsApp si algo no te cuadra.

¿Qué opción de Dongee conviene para cada API?

Tipo de APIOpción de DongeePrecio de entradaQuién administra
FastAPI / Python, carga estableDongee Cloud (Cloud 1 o Cloud 2)17 USD/mes (Cloud 1) o 34 USD/mes (Cloud 2)Tú (root, Docker)
FastAPI / Python, recursos a medida o carga variableCloud On DemandDesde 17 USD/mesTú (root, Docker)
Node / Express, Fastify, HonoDongee Live0 USD (Live Gratis), 15 USD (Live Pro)Dongee mantiene sistema, servidor web y HTTPS

Con Cloud On Demand eliges los recursos uno a uno: 6 USD por vCPU, 3 USD por GB de RAM y 0,3 USD por GB de disco, con un mínimo de 17 USD/mes. Incluye backups automáticos y recuperación ante desastres sin costo extra.

¿Cómo publico mi API FastAPI paso a paso?

  1. Crea el servidor. Para una API pequeña basta Cloud 1 (1 CPU, 1 GB RAM, 25 GB). Si vas a tener base de datos en el mismo servidor, mejor Cloud 2 (1 CPU, 2 GB). Elige la ubicación más cercana a tus usuarios entre Atlanta, Miami, Nueva York, Dallas, México, São Paulo, Santiago, Frankfurt, Madrid, Londres y Ámsterdam. El despliegue tarda menos de 3 minutos.
  2. Conéctate por SSH. Si nunca lo hiciste, sigue la guía para conectarte por SSH a tu servidor Cloud desde Windows o Mac.
  3. Instala Docker y Docker Compose. En Ubuntu:
sudo apt update
sudo apt install -y docker.io docker-compose-v2 nginx
sudo systemctl enable --now docker
  1. Sube tu código con git clone desde GitHub o con scp. Comprueba que exista un requirements.txt con fastapi, uvicorn y gunicorn.
  2. Crea un Dockerfile mínimo:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "main:app", "-k", "uvicorn.workers.UvicornWorker", "-w", "2", "-b", "0.0.0.0:8000"]

Para una prueba rápida sirve uvicorn main:app --host 0.0.0.0 --port 8000. En producción usa varios workers, con uvicorn --workers 2 o con gunicorn como arriba. Una regla práctica es un worker por CPU, más uno.

  1. Define el docker-compose.yml con la API y, si la necesitas, la base de datos:
services:
  api:
    build: .
    env_file: .env
    ports:
      - "127.0.0.1:8000:8000"
    restart: unless-stopped
    depends_on:
      - db
  db:
    image: postgres:16
    env_file: .env
    environment:
      - PGDATA=/data/pgdata
    volumes:
      - dbdata:/data
    restart: unless-stopped
volumes:
  dbdata:

Fíjate en 127.0.0.1:8000:8000: el puerto solo se publica en el propio servidor, no a internet. El patrón es el mismo que en la guía para instalar n8n con Docker Compose en un servidor Cloud.

  1. Guarda las variables en un archivo .env (claves de API, DATABASE_URL, contraseñas) y añádelo a .gitignore para que nunca llegue al repositorio. Después levanta los contenedores:
docker compose up -d --build
docker compose logs -f api
  1. Pon Nginx como proxy inverso. Crea un archivo llamado api.conf en la carpeta de sitios de Nginx con este bloque:
server {
    listen 80;
    server_name api.tudominio.com;
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Valida y recarga con sudo nginx -t && sudo systemctl reload nginx. Antes, apunta un registro A de tu dominio a la IP dedicada del servidor.

  1. Activa HTTPS con certbot:
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d api.tudominio.com

Certbot edita el bloque de Nginx y programa la renovación automática del certificado.

  1. Crea un snapshot antes de cada actualización y escala cuando crezcas. Todos los planes Cloud traen snapshots incrementales y backup de disco. Si algo sale mal tras un git pull y docker compose up -d --build, vuelves atrás. Cuando la API necesite más potencia, puedes escalar CPU y RAM de tu servidor Cloud sin reiniciar ni migrar.

¿Qué errores son comunes al publicar FastAPI hecho con IA?

  • Hacer bind a 127.0.0.1 dentro del contenedor. Muchos ejemplos generados por IA usan --host 127.0.0.1. Dentro de Docker eso deja la API inaccesible incluso para Nginx. Dentro del contenedor usa 0.0.0.0, y limita la exposición en el ports del compose.
  • CORS abierto o mal configurado. allow_origins=["*"] junto con credenciales es mala idea. Declara en CORSMiddleware solo los dominios de tu frontend.
  • Puerto 8000 abierto a internet sin proxy. Si publicas "8000:8000", la API queda expuesta sin HTTPS. Ten en cuenta que Docker puede saltarse las reglas del firewall del sistema. Publica en 127.0.0.1 y deja que Nginx sea la única puerta.
  • Usar --reload en producción. Es para desarrollo: consume recursos vigilando archivos y no admite varios workers.
  • Claves en el repositorio. Si la IA escribió la clave de tu base de datos o de un modelo directamente en main.py, muévela al .env y rota la clave. Una clave que llegó a GitHub debe considerarse filtrada.
  • No reiniciar tras caídas. Sin restart: unless-stopped, un fallo o un reinicio del servidor deja la API apagada.

Preguntas frecuentes

¿Puedo publicar FastAPI en Dongee Live si lo convierto en estático?

No. Una API necesita un proceso en ejecución, y Live solo ejecuta sitios estáticos y apps Node. Si tu frontend es estático o Node, puedes publicarlo en Live y llamar a la API FastAPI que corre en Dongee Cloud.

¿Cuánto cuesta publicar una API FastAPI en Dongee?

Cloud 1 cuesta 17 USD/mes y Cloud 2, 34 USD/mes. Cloud On Demand empieza en 17 USD/mes y se calcula por vCPU, RAM y disco. Puedes pagar en COP, USD, EUR, MXN, PEN, CLP o BRL.

¿Necesito saber administrar servidores?

Algo, sí: Dongee Cloud es autogestionado y tú instalas y mantienes Docker, Nginx y el sistema. Si te atascas, el soporte 24/7 te ayuda a revisarlo, y también puedes pedir migración asistida.

¿Puedo usar Supabase u otra base de datos externa en lugar de una local?

Sí. Quita el servicio db del compose y pon la cadena de conexión externa en el .env. Así el servidor tiene menos carga y Cloud 1 puede ser suficiente.

¿Qué hago si mi API crece y necesita varios servidores?

Primero escala CPU y RAM sin reiniciar. Si después necesitas varias instancias, puedes conectarlas por la red privada sin costo y montar tu propio balanceador con Nginx o HAProxy. Dongee no vende balanceador gestionado.

En resumen: si tu API es FastAPI, va en Dongee Cloud o en Cloud On Demand, con Docker Compose, Nginx delante y HTTPS con certbot. Si es Node, Dongee Live te ahorra todo ese trabajo de servidor.

Comenta lo que quieras

Unete a la charla
Solo ingresa tu email