# Desplegar Django en producción: qué cambia después de runserver

Desplegá Django en producción con gunicorn o uvicorn, no con runserver. Ajustá DEBUG, ALLOWED_HOSTS, estáticos y migraciones. El Dockerfile pide Pro.

Canonical URL: https://unbroker.cloud/es/blog/django-in-production
Published: 2026-11-10
Reviewed: 2026-11-10
Author: Timoteo Borgobello

## 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](https://unbroker.cloud/deploy/django). Los pasos están en [Deploy a Django application](https://docs.unbroker.cloud/guides/deploy-django).

## 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](https://docs.djangoproject.com/en/stable/howto/deployment/checklist/) dice lo mismo: dejá `manage.py runserver`. La referencia del comando es [`runserver`](https://docs.djangoproject.com/en/stable/ref/django-admin/#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 |
| --- | --- | --- |
| Proceso | El servidor de desarrollo de Django. No es para producción. | Un servidor WSGI como Gunicorn, o un servidor ASGI como Uvicorn. |
| Dirección | `127.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áticos | Los sirve `runserver` cuando staticfiles está activo. | `collectstatic`, y después WhiteNoise u otro host. Gunicorn solo no los sirve. |
| Settings | `DEBUG` suele estar prendido. | `DEBUG = False`, un `SECRET_KEY` secreto y `ALLOWED_HOSTS` con el hostname real. |
| Migraciones | Muchas 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](https://docs.djangoproject.com/en/stable/howto/deployment/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](https://docs.djangoproject.com/en/stable/howto/deployment/wsgi/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](https://docs.djangoproject.com/en/stable/howto/deployment/asgi/uvicorn/) y [How to deploy with ASGI](https://docs.djangoproject.com/en/stable/howto/deployment/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](https://docs.djangoproject.com/en/stable/howto/deployment/checklist/) 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](https://unbroker.cloud/es/blog/environment-variables-and-secrets).

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](https://docs.djangoproject.com/en/stable/ref/views/#the-400-bad-request-view): un mensaje "Bad Request", estado 400, y solo cuando `DEBUG` es `False`. La lista de excepciones está en [SuspiciousOperation](https://docs.djangoproject.com/en/stable/ref/exceptions/#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`](https://docs.djangoproject.com/en/stable/ref/settings/#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`](https://docs.djangoproject.com/en/stable/ref/settings/#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](https://unbroker.cloud/es/blog/custom-domain-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](https://docs.djangoproject.com/en/stable/howto/static-files/deployment/).

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](https://whitenoise.readthedocs.io/en/stable/django.html). 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](https://unbroker.cloud/es/blog/persistent-storage-volumes) y en [Persistent storage and backups](https://docs.unbroker.cloud/apps/storage).

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](https://docs.unbroker.cloud/guides/connect-postgres). Operar la base está en [Postgres en producción](https://unbroker.cloud/es/blog/postgres-in-production). 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](https://unbroker.cloud/es/blog/database-migrations-on-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](https://unbroker.cloud/es/blog/background-workers-cron-jobs), y los pasos en [Deploy a background worker](https://docs.unbroker.cloud/guides/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:

```text
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](https://docs.unbroker.cloud/guides/debug-failed-deployment) 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](https://docs.unbroker.cloud/apps/services).

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](https://unbroker.cloud/es/precios) y en [Plans](https://docs.unbroker.cloud/billing/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](https://unbroker.cloud/deploy/django) y en la [guía de Django](https://docs.unbroker.cloud/guides/deploy-django).

## Related reading

- [Desplegar Django](https://unbroker.cloud/deploy/django)
- [Variables de entorno y secretos](https://unbroker.cloud/es/blog/environment-variables-and-secrets)
- [Postgres en producción](https://unbroker.cloud/es/blog/postgres-in-production)
- [Migraciones de base de datos en el deploy](https://unbroker.cloud/es/blog/database-migrations-on-deploy)
- [Volúmenes persistentes](https://unbroker.cloud/es/blog/persistent-storage-volumes)
- [Workers en segundo plano y cron](https://unbroker.cloud/es/blog/background-workers-cron-jobs)
- [Precios](https://unbroker.cloud/es/precios)
