Alojar Flask en un VPS: Gunicorn, Nginx y puesta en producción

Si una herramienta de IA te ha generado una aplicación Flask, que funcione con flask run en tu ordenador no significa que esté lista para recibir tráfico público. Flask es una aplicación WSGI: en producción necesitas un servidor WSGI, un proxy HTTP y una configuración segura. El VPS es autogestionado: te da acceso al sistema para montar esa pila y te deja a cargo de las actualizaciones, la seguridad, las copias y la recuperación.

Esta guía usa Debian o Ubuntu, Gunicorn y Nginx. Los nombres hello, app y create_app son ejemplos: debes sustituirlos por los módulos y objetos reales de tu repositorio. No ejecutes el servidor de desarrollo ni el depurador de Flask en producción.

1. Comprueba qué aplicación tienes

Revisa el repositorio y localiza requirements.txt o pyproject.toml, el módulo de entrada y, si existe, una fábrica como create_app(). Anota la versión de Python y los servicios externos que necesita: base de datos, almacenamiento, tareas, correo o API. Comprueba también si el proyecto contiene un frontend separado con Node; Gunicorn ejecuta el backend Flask, no compila por sí mismo ese frontend.

Antes de publicarla, prueba las rutas, formularios, carga de archivos y llamadas externas en local. Revisa el código generado por IA en busca de debug=True, credenciales incluidas en el repositorio y configuración que solo funcione con localhost. Un proyecto con dependencias o servicios distintos necesitará ajustar los pasos siguientes.

2. Prepara el VPS y una cuenta de servicio

Elige un VPS Hostbrid con Debian o Ubuntu compatible con el Python del proyecto. Conéctate por SSH, aplica las actualizaciones y limita los puertos abiertos a los necesarios. Crea una cuenta para el servicio, en vez de ejecutar la aplicación como root:

sudo apt update
sudo apt install git python3-venv nginx
sudo adduser --system --group --home /srv/flaskapp flaskapp

Clona el repositorio en /srv/flaskapp/current. Para repositorios privados, usa una clave de despliegue de solo lectura y protege su clave privada. Crea un entorno virtual e instala las dependencias fijadas por el proyecto:

sudo -u flaskapp python3 -m venv /srv/flaskapp/venv
sudo -u flaskapp /srv/flaskapp/venv/bin/pip install -r /srv/flaskapp/current/requirements.txt

Incluye gunicorn entre las dependencias de producción del proyecto. No instales paquetes de la aplicación en el Python global del sistema.

3. Configura el entorno de producción

Guarda las variables de producción fuera de Git, en un archivo como /etc/flaskapp.env, con permisos restringidos. Flask no convierte automáticamente cualquier variable en ajustes de la aplicación: tu código debe leerlas. Genera una clave secreta única para SECRET_KEY, configura la base de datos y las credenciales de API, y no reutilices valores de desarrollo. No incluyas secretos en el HTML, JavaScript del navegador, imágenes ni logs.

Desactiva el modo debug y limita los nombres de host que acepta la aplicación. Si usas Flask 3.1 o posterior, revisa TRUSTED_HOSTS; en otras versiones comprueba la protección equivalente disponible. Los nombres exactos y la forma de leer la configuración dependen del código de tu app.

Haz una copia antes de cualquier cambio que afecte a datos. Si tu aplicación usa SQLite, comprueba dónde guarda el archivo y quién puede escribirlo; en una app con más tráfico o varios procesos evalúa una base de datos apropiada y documenta cómo restaurarla. Guarda los archivos subidos por usuarios aparte del código y define su política de retención y copia.

4. Arranca Flask con Gunicorn y systemd

Prueba primero la importación de la aplicación. Gunicorn espera el formato módulo:objeto; para una instancia directa puede ser hello:app, y para una fábrica de Flask, hello:create_app(). Cambia el ejemplo por el punto de entrada real de tu proyecto:

cd /srv/flaskapp/current
sudo -u flaskapp /srv/flaskapp/venv/bin/gunicorn --bind 127.0.0.1:8000 'hello:create_app()'

Cuando la prueba funcione, usa systemd para iniciar el proceso al arrancar el VPS y reiniciarlo si falla. Guarda la unidad en /etc/systemd/system/flaskapp.service:

[Unit]
Description=Flask application
After=network.target

[Service]
User=flaskapp
Group=flaskapp
WorkingDirectory=/srv/flaskapp/current
EnvironmentFile=/etc/flaskapp.env
ExecStart=/srv/flaskapp/venv/bin/gunicorn --bind 127.0.0.1:8000 'hello:create_app()'
Restart=on-failure

[Install]
WantedBy=multi-user.target

Adapta el módulo WSGI y confirma que systemd puede leer el archivo de entorno sin exponerlo a otros usuarios. Después ejecuta sudo systemctl daemon-reload, sudo systemctl enable --now flaskapp y revisa sudo systemctl status flaskapp y journalctl -u flaskapp. Mantén Gunicorn ligado a 127.0.0.1; no lo expongas directamente a Internet si Nginx va delante.

5. Configura Nginx, el dominio y HTTPS

Un bloque inicial de Nginx puede reenviar las peticiones a Gunicorn. Sustituye el dominio y confirma que la aplicación atiende en el puerto configurado:

server {
    listen 80;
    server_name example.com www.example.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;
    }
}

Guarda la configuración en el directorio de sitios de tu distribución, habilítala, valida con sudo nginx -t y recarga Nginx. Apunta el dominio al VPS, permite el tráfico web necesario y configura un certificado TLS con el método compatible con tu sistema. Redirige HTTP a HTTPS antes de aceptar credenciales o datos sensibles.

Si Flask necesita conocer el protocolo o la dirección originales, configura ProxyFix solo cuando las peticiones pasen realmente por el proxy que controlas y con el número correcto de proxies. Confiar cabeceras reenviadas sin limitar esa cadena puede permitir que un cliente falsifique valores.

6. Prueba y prepara la operación

Prueba la portada, rutas internas, formularios, inicio de sesión, archivos estáticos y subida de archivos desde fuera del VPS. Reinicia el servicio y verifica que vuelve a arrancar. Revisa los logs para detectar errores y secretos; confirma que las copias de la base de datos y archivos se pueden restaurar. Si la app depende de trabajos en segundo plano, configura y supervisa esos procesos por separado.

Esta receta es para una aplicación Flask que quieres administrar en un servidor Linux. Hostbrid proporciona VPS con acceso root; tú instalas y mantienes Python, Flask, Gunicorn, Nginx, HTTPS, el firewall y las copias. Compara las opciones de VPS y los precios vigentes con el uso medido de CPU, memoria y disco de tu aplicación.

Fuentes de implementación: documentación oficial de Flask sobre despliegue en producción, Gunicorn, Nginx y ProxyFix.