La respuesta corta

Para desplegar Django en producción, manage.py runserver no es el servidor. Corre un servidor WSGI o ASGI en 0.0.0.0 y en el puerto que te da la plataforma, con DEBUG = False, un SECRET_KEY estable y ALLOWED_HOSTS en el hostname real. Recolectá los estáticos, dejá las subidas de usuarios en almacenamiento durable y corré las migraciones una vez, como paso de release.

Si estás eligiendo hosting para Django, en Unbroker ese camino es un servicio con Dockerfile y pide Pro. La página de producto es Desplegar Django. Los pasos están en Deploy a Django application.

runserver no es el servidor de producción

runserver levanta un servidor de desarrollo liviano. Por defecto escucha el puerto 8000 en 127.0.0.1. Django avisa que es un servidor de desarrollo y que producción necesita un servidor WSGI o ASGI. El checklist de deploy dice lo mismo: dejá manage.py runserver. La referencia del comando es runserver.

El servidor de desarrollo recarga el código de Python mientras editás, y sirve estáticos cuando django.contrib.staticfiles está activo. Eso es comodidad de desarrollo. No es un proceso de producción.

Desarrollo (runserver)Servidor de producción
ProcesoEl servidor de desarrollo de Django. No es para producción.Un servidor WSGI como Gunicorn, o un servidor ASGI como Uvicorn.
Dirección127.0.0.1:8000, salvo que pases otra. Otras máquinas no llegan a ese default.0.0.0.0 y el PORT que te dan. El ejemplo de Unbroker cae a 8000 solo si PORT está vacío.
EstáticosLos sirve runserver cuando staticfiles está activo.collectstatic, y después WhiteNoise u otro host. Gunicorn solo no los sirve.
SettingsDEBUG suele estar prendido.DEBUG = False, un SECRET_KEY secreto y ALLOWED_HOSTS con el hostname real.
MigracionesMuchas veces se aplican a mano en una máquina.Una vez, como paso de release, no cuando arranca cada copia de la app.

WSGI o ASGI

La plataforma de deploy principal de Django es WSGI. startproject crea wsgi.py con un callable application, y runserver usa esa app WSGI. No usa asgi.py. El panorama está en How to deploy with WSGI.

Gunicorn es el servidor WSGI que usa la guía de Unbroker. El comando de inicio de Django es gunicorn myproject.wsgi. Arranca un proceso y un thread en 127.0.0.1:8000. La referencia es How to use Django with Gunicorn.

Usá ASGI cuando el proyecto se despliega por asgi.py. El comando de Uvicorn en la doc de Django es python -m uvicorn myproject.asgi:application, y en esa forma simple también escucha en 127.0.0.1:8000. Para producción, Django documenta correr Uvicorn debajo de Gunicorn con -k uvicorn_worker.UvicornWorker. La referencia es How to use Django with Uvicorn y How to deploy with ASGI.

La guía de Unbroker asume una aplicación WSGI y muestra Gunicorn. Si pasás al comando ASGI, mantené el mismo bind: todas las interfaces, y el puerto que te dan.

Settings que tienen que cambiar

Seguí el checklist de deploy de Django y corré python manage.py check --deploy con los settings de producción. La guía de Unbroker pide el mismo chequeo.

Poné DEBUG = False. Django dice que nunca hay que dejar el debug prendido en producción. Con debug activo, las páginas de error pueden mostrar código, variables locales y settings.

Leé SECRET_KEY del entorno. El checklist muestra os.environ["SECRET_KEY"] como una forma. Conservá el mismo valor entre deploys. La guía de Unbroker dice que un secreto distinto en cada arranque invalida datos firmados y sesiones. No lo commitees. Cómo se reparten las variables está en Variables de entorno y secretos.

Poné en ALLOWED_HOSTS el hostname con el que el servicio responde de verdad. Con DEBUG en False, Django no funciona sin un valor válido. Un request cuyo host no está permitido lanza DisallowedHost. Esa excepción es una SuspiciousOperation. Si nadie más la maneja, Django responde con la vista de bad request: un mensaje “Bad Request”, estado 400, y solo cuando DEBUG es False. La lista de excepciones está en SuspiciousOperation. La guía dice que un error DisallowedHost apunta a la configuración del host. No lo arregles permitiendo todos los hosts.

Sumá los orígenes HTTPS finales a CSRF_TRUSTED_ORIGINS donde la app los necesite. El default es una lista vacía. Una entrada es un origen, como https://example.com, no un hostname sin el esquema. El setting es CSRF_TRUSTED_ORIGINS. Una falla de CSRF pide revisar el origen y la cookie. No desactives la protección CSRF.

Cuando el sitio ya está en HTTPS, el checklist también dice que pongas CSRF_COOKIE_SECURE y SESSION_COOKIE_SECURE en True, para que esas cookies no viajen por HTTP plano.

SECURE_PROXY_SSL_HEADER importa cuando el TLS termina en un proxy y Django, si no, vería el request como HTTP. El default es None. Django dice que lo configures solo si controlás ese proxy, el proxy saca el header de los requests que entran, y el proxy pone el header él mismo en los requests que llegaron por HTTPS. La guía de Django de Unbroker no nombra un header para confiar. No cargues un valor de ejemplo hasta saber que el proxy que está delante de la app cumple esas condiciones. Un loop de redirects después de prender SECURE_SSL_REDIRECT es el síntoma que Django documenta para este caso. El setting es SECURE_PROXY_SSL_HEADER.

Un dominio propio es un paso posterior, y requiere Pro. Cuando esté listo, sumá ese hostname a ALLOWED_HOSTS y su origen HTTPS a CSRF_TRUSTED_ORIGINS. El DNS y el certificado están en Dominio personalizado y HTTPS.

Archivos estáticos y media

En producción definís STATIC_ROOT. collectstatic copia ahí los estáticos. El servidor de desarrollo no hace ese trabajo. La entrada del checklist es STATIC_ROOT y STATIC_URL, y la página de deploy es How to deploy static files.

Gunicorn no sirve los archivos recolectados. Elegí una estrategia. WhiteNoise, en MIDDLEWARE justo después del SecurityMiddleware de Django, los sirve desde el proceso de Django. Corré collectstatic en la etapa que pida esa estrategia. Si el comando corre mientras se construye la imagen, usá settings que sean seguros en el build. Los pasos de WhiteNoise están en Using WhiteNoise with Django. Un host externo de estáticos es la otra opción que nombra la guía de Unbroker.

Las subidas de usuarios son otro directorio. MEDIA_ROOT guarda archivos de usuarios, y Django los trata como no confiables. El helper que sirve MEDIA_ROOT en desarrollo no es un servidor de archivos de producción, y la doc lo muestra solo cuando DEBUG está prendido. En Unbroker, esa media va a almacenamiento persistente o a object storage, separada de los estáticos recolectados.

Un volumen persistente es una ruta absoluta en un servicio. Los archivos que solo se escriben en el filesystem del contenedor hay que tratarlos como temporales, porque un deploy, un reinicio o un reschedule pueden reemplazar ese contenedor. Un servicio con volumen corre una réplica. El volumen puede crecer, hasta 50 GB, y no puede achicarse. Borrar el servicio borra el volumen. Los volúmenes requieren Pro. Ese límite está en volúmenes persistentes y en Persistent storage and backups.

Si más de una réplica tiene que ver la misma subida, usá object storage. El volumen no es un disco compartido entre varias réplicas.

Base de datos y migraciones

Configurá el setting DATABASES de Django para la base PostgreSQL que elegiste. Django no parsea DATABASE_URL por su cuenta. Usá la configuración que ya tenés, o un parser que hayas instalado a propósito. Motor, nombre, usuario, contraseña, host y puerto son los campos de conexión que Django documenta para PostgreSQL.

En Unbroker hay dos caminos de PostgreSQL. Un nodo de Apps es un servicio de base privado dentro del proyecto. Un clúster gestionado es un host de base operado aparte. El schema y las migraciones siguen siendo tuyos. Guardá las credenciales en las variables de runtime del servicio. Mostrar un connection string puede imprimir un secreto, así que ese output no va al repo, al chat ni a la página de error. Los pasos de conexión están en Connect your application to PostgreSQL. Operar la base está en Postgres en producción. Las bases gestionadas requieren Pro.

Corré las migraciones una vez, como paso de release controlado, con las credenciales de runtime. No las pongas en el build de la imagen. No las corras desde cada proceso web, porque esos procesos pueden competir. Probalas en una copia descartable antes de producción. En Unbroker el paso de release es el comando pre-deploy, y los comandos de migración requieren Pro. Qué no deshace un rollback de código está en Migraciones de base de datos en el deploy.

Tareas en segundo plano

El mail, el indexado y el resto del trabajo de cola no van en el proceso web. Poné el consumidor en su propio servicio worker, con su comando de arranque y sus logs. Un worker no tiene HTTP de entrada ni URL pública. Los workers requieren Pro, y corren una réplica.

Celery y RQ son ejemplos de ese consumidor. La guía de workers no nombra ninguna de las dos librerías. Dice que el comando de arranque tiene que lanzar el consumidor y quedarse vivo mientras espera trabajos. Un script que procesa un ítem y sale es un job programado o un comando de una vez, no un worker. Los jobs programados requieren Pro. El corte está en Workers en segundo plano y cron, y los pasos en Deploy a background worker.

Cómo funciona en Unbroker

Creá un servicio de repositorio con Dockerfile en Cloud. Incluí Gunicorn y el driver de la base en los requirements fijados. El comando de la guía, para un proyecto cuyo módulo WSGI es config.wsgi, es:

gunicorn config.wsgi:application --bind 0.0.0.0:${PORT:-8000} --workers 1 --access-logfile - --error-logfile -

Cambiá config.wsgi por tu módulo. Escuchá en 0.0.0.0, no en 127.0.0.1. Escuchá el PORT que te dan. El fallback ${PORT:-8000} aplica solo cuando PORT está vacío. Si no elegís un puerto, un servicio de repositorio nuevo usa 3000, y Unbroker pone en PORT el puerto del servicio, salvo que vos definas PORT. Un PORT que definís reemplaza ese valor, así que no lo apuntes a un puerto distinto del puerto del servicio. La guía de fallos lista PORT y 0.0.0.0 en salud y ruteo.

Cargá las variables de producción, confirmá que la base responde, corré el paso de migración y desplegá. Después abrí una página pública, entrá a la cuenta, mandá un formulario, cargá un estático y subí un archivo de media si la app lo tiene.

La guía arranca de un proyecto Django que ya anda, dependencias de Python fijadas, una base de producción y Unbroker Pro. Los builds de Dockerfile no están en Free. Los comandos de migración, los workers, los volúmenes persistentes, las bases gestionadas y los dominios propios también son Pro. Los builds de Dockerfile quedan fuera de Serverless, así que este servicio no está en el camino de dormir y despertar que usan los servicios HTTP de Free. Los tipos de servicio están en Service types.

Pro sale $25 por mes con $25 de crédito de uso. El crédito se reinicia en cada ciclo y no se acumula. Si el uso elegible queda por debajo del crédito, el cargo mensual sigue siendo el precio del plan. Las filas están en precios y en Plans.

Checklist

  1. Dejá runserver fuera del comando de arranque de producción.
  2. Corré Gunicorn si la app es WSGI, o un servidor ASGI si desplegás asgi.py. Escuchá en 0.0.0.0 y en el PORT que te dan.
  3. Poné DEBUG = False. Cargá un SECRET_KEY estable desde el entorno.
  4. Poné en ALLOWED_HOSTS el hostname real. Sumá los orígenes HTTPS a CSRF_TRUSTED_ORIGINS donde la app los necesite.
  5. Corré python manage.py check --deploy con los settings de producción.
  6. Definí STATIC_ROOT, corré collectstatic y serví esos archivos con WhiteNoise u otro host. Gunicorn no lo hace.
  7. Poné las subidas de usuarios en un volumen o en object storage. Un volumen deja el servicio en una réplica.
  8. Corré las migraciones una vez, como paso de release, no en el build de la imagen y no en cada proceso web.
  9. Poné el consumidor de la cola en su propio worker. Usá un job programado para un comando que termina.
  10. Desplegá el servicio Dockerfile en Pro. Revisá una página, un login, un formulario, un estático y una subida de media.

Preguntas frecuentes

¿Puedo usar runserver en producción?

No. El checklist de deploy de Django dice que dejes manage.py runserver. Es un servidor de desarrollo liviano. No pasó auditorías de seguridad ni pruebas de rendimiento, y Django dice que no sirve para producción. Por defecto escucha en 127.0.0.1:8000, recarga el código y sirve estáticos cuando staticfiles está activo. Usá un servidor WSGI o ASGI de producción. La guía de Django de Unbroker dice que runserver no es el comando de arranque.

¿Conviene gunicorn o uvicorn para Django?

Gunicorn, si el proyecto es WSGI. La plataforma de deploy principal de Django es WSGI, y la guía de Unbroker asume una app WSGI y muestra Gunicorn. Usá un servidor ASGI cuando desplegás asgi.py, por ejemplo Uvicorn. La página de Uvicorn de Django también muestra correr Uvicorn debajo de Gunicorn con el worker de Uvicorn. En los dos casos, escuchá en 0.0.0.0 y en el PORT que te dan. Los comandos más simples de Gunicorn y de Uvicorn escuchan en 127.0.0.1:8000, y otras máquinas no llegan a esa dirección.

¿Por qué veo Bad Request (400) después de desplegar Django?

Revisá ALLOWED_HOSTS. Con DEBUG en False, Django no funciona sin un ALLOWED_HOSTS válido. Un host que no está permitido lanza DisallowedHost, que es una SuspiciousOperation. Si nadie más maneja esa excepción, Django trata el request como bad request. La vista de bad request muestra un mensaje Bad Request con estado 400, y solo se usa cuando DEBUG es False. Poné el hostname real del servicio en ALLOWED_HOSTS. No permitas todos los hosts y no vuelvas a prender DEBUG para tapar la página.

¿Cómo sirvo los archivos estáticos de Django en producción?

Definí STATIC_ROOT y corré collectstatic. El servidor de desarrollo sirve los estáticos solo. Gunicorn no. WhiteNoise, configurado en Django, puede servir los archivos recolectados. Un host externo de estáticos es la otra opción que nombra la guía de Unbroker. Los archivos que suben los usuarios no van en ese directorio.

¿Cuándo tienen que correr las migraciones de Django en el deploy?

Una vez, como paso de release, con las credenciales de runtime, antes de que la versión nueva reciba tráfico. La guía de Django dice que evites poner las migraciones en el build de la imagen y que evites correr migraciones que compiten en cada proceso web. En Unbroker ese paso es el comando pre-deploy, y los comandos de migración requieren Pro. Probá la migración en una copia descartable antes.

¿Dónde van los archivos que suben los usuarios?

En almacenamiento persistente o en object storage, no en el filesystem del contenedor. Un deploy, un reinicio o un reschedule pueden reemplazar el contenedor, y los archivos que solo se escribieron ahí hay que tratarlos como temporales. Separá esa media de los estáticos recolectados. Un servicio con volumen en Unbroker tiene una réplica. El volumen puede crecer hasta 50 GB y no puede achicarse.

¿Cómo despliego una app Django en Unbroker?

Creá un servicio de repositorio con Dockerfile, incluí Gunicorn y el driver de la base, y cargá las variables de producción. El comando de la guía hace que Gunicorn escuche en 0.0.0.0 y en PORT, con un worker, y usa 8000 solo cuando PORT está vacío. El camino requiere Pro. Los builds de Dockerfile no están en Free. Los pasos están en Desplegar Django y en la guía de Django.