La respuesta corta

Docker Compose en producción, en los términos de Docker, es un solo servidor. La misma documentación dice que escalar ese esquema es Swarm. El archivo compose sigue describiendo el stack. Lo que cambia es el inventario: qué es público, dónde viven los datos y qué pasa cuando se reemplaza un contenedor.

Separá el proceso web, los workers y los datos. Sacá los bind mounts del código. Sumá healthchecks. Dejá los secretos fuera de la imagen. Decidí si cada base sigue siendo un contenedor que operás vos. Para desplegar Docker Compose en una plataforma, creá un servicio por pieza. Un solo contenedor está en Docker en Unbroker. Un frontend y una API en el mismo proyecto están en frontend y API. Si el stack tiene que seguir en una máquina que parcheás, corré Compose en un servidor Linux que operás. Si estás dejando Railway, la alternativa a Railway es la comparación.

Lo que Docker recomienda para producción

La nota de producción de Docker lista los cambios que suelen importar. Quitá los bind mounts del código de la aplicación, para que el código quede dentro de la imagen y no se pueda cambiar desde afuera. Publicá otros puertos en el host. Poné las variables de entorno de otra forma. Definí una política de reinicio como restart: always. Podés sumar un servicio, por ejemplo un agregador de logs.

Las diferencias van en un segundo archivo, compose.production.yaml. Solo tiene que traer los cambios. Se aplica encima del archivo base:

docker compose -f compose.yaml -f compose.production.yaml up -d
services:
  web:
    ports:
      - "80:3000"
    environment:
      LOG_LEVEL: info
    restart: always

Ese archivo tiene la forma de tres cambios que Docker nombra: otro puerto en el host, otras variables de entorno y restart: always. Sacar el bind mount del código es el otro cambio, y tiene que ser cierto en la configuración que corrés. Las reglas de merge de Docker deciden si una clave del segundo archivo reemplaza a la del base o se combina con ella. Leelas antes de depender de un cambio de puerto o de volumen. La fuente es Use Compose in production y varios archivos Compose.

Para volver a desplegar un servicio llamado web, reconstruilo y recreá solo ese servicio:

docker compose build web
docker compose up --no-deps -d web

--no-deps deja quietos los servicios de los que depende web.

Qué es cada servicio del compose

El archivo es una lista. En producción cada línea es una decisión. Esta tabla pasa de un elemento del compose a lo que significa cuando otra cosa lo corre, y al servicio de Unbroker que le corresponde.

Elemento del composeEn producciónEn Unbroker
Servicio HTTP con buildEl código queda en la imagen. Sacá el bind mount del fuente.Servicio de repositorio: Railpack, o un Dockerfile en el repo.
imageCorré un artefacto que después puedas nombrar.Servicio de imagen. Unbroker la baja y no reconstruye el fuente. Preferí un tag de release o un digest. Una réplica.
Proceso sin puertos publicadosNo hay HTTP de entrada.Worker. Sin URL pública. Una réplica.
Postgres, Redis, MySQL, MongoDBAlguien se hace cargo de upgrades, backups y restores.Nodo de base en Apps, o una base gestionada.
nginx u otro proxy reversoEn un host suele publicar la app y terminar TLS.Un servicio público ya tiene URL. Dejá el proxy solo si todavía necesitás su ruteo.
portsEl host publica ese puerto.Solo un servicio público tiene URL. El resto queda privado.
Volumen de códigoSacalo.La imagen tiene el código.
Volumen de datosUna ruta que sobrevive a un contenedor nuevo.Un volumen, una ruta absoluta, hasta 50 GB, no se achica. Una réplica. Borrar el servicio borra el volumen.
environment o env_fileValores distintos por entorno. Los secretos quedan fuera de la imagen.Production, Preview o All. Pegar un .env importa las variables. Los previews nuevos copian All y Preview, nunca Production.
depends_onRunning no es listo. Usá service_healthy y un healthcheck.La app igual reintenta después del primer arranque.
restartrestart: always en un solo servidor.Un servicio caído o un crash-loop dispara una alerta integrada. Las métricas incluyen reinicios.
networksLos contenedores de ese host comparten una red.El mismo entorno: host y puerto privados. Los previews no llegan a producción.

Un frontend que es solo HTML, CSS y JavaScript, sin proceso de servidor, es un upload estático. Es un servicio distinto de un contenedor. Los tipos están en la guía de servicios.

La fila de nginx es un criterio, no una regla. Si el proxy solo existe para publicar la app y terminar TLS, un servicio público ya tiene URL. Los dominios propios y el TLS gestionado requieren Pro. Si el proxy todavía rutea de una forma que necesitás, esa decisión queda aparte.

depends_on no espera a que esté listo

Compose espera a que la dependencia esté corriendo. No espera a que pueda aceptar trabajo. El proceso de la base puede estar arriba y todavía estar arrancando.

depends_on toma una de tres condiciones:

  • service_started significa que el contenedor está corriendo.
  • service_healthy significa que el healthcheck pasa. El servicio necesita un healthcheck.
  • service_completed_successfully significa que una dependencia de un solo uso terminó bien.

La página de orden de arranque de Docker usa Postgres y pg_isready para el caso healthy. $$ es el escape de Compose, así el shell de adentro del contenedor ve $POSTGRES_USER. Esa página también pone restart: true en la dependencia, que reinicia web cuando una operación de Compose reinicia db, y muestra Redis con service_started. El bloque de abajo es ese healthcheck, reducido a la base:

services:
  web:
    build: .
    depends_on:
      db:
        condition: service_healthy
        restart: true
  db:
    image: postgres:18
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 10s
      retries: 5
      start_period: 30s
      timeout: 10s

La fuente es Control startup and shutdown order. postgres:18 es el tag de ese ejemplo. No es un pin de imagen de Unbroker.

Un healthcheck frena el primer arranque. La aplicación igual tiene que reintentar conexiones, porque la base puede irse después.

Puertos y red privada

ports publica un puerto del contenedor en el host. En un servidor, así llega el tráfico al proceso. Los otros contenedores de la red de Compose usan el nombre del servicio.

Publicá solo lo que tiene que tener URL. Un servicio privado no tiene URL pública, ni Ingress, ni certificado. Otro servicio del mismo entorno se conecta con el host y el puerto privados:

${{services.api.host}}:${{services.api.port}}

Un entorno de preview no llega a producción. Un worker ya no tiene URL pública, y encima no se puede marcar como privado. No crees un servicio web público solo para que un proceso sin listener pase un health check HTTP. El comando de arranque tiene que lanzar el consumidor. Los workers con Dockerfile corren sin URL pública, sin servicio de entrada y sin sonda de readiness HTTP. Mirá workers en segundo plano y la guía del worker.

Volúmenes: el código afuera, el dato decidido

Un bind mount del árbol de fuente es una comodidad de desarrollo. La nota de producción de Docker dice que lo saques, para que el código que corre sea el de la imagen.

Un volumen de datos es otra decisión. En Unbroker un volumen pertenece a un servicio y se monta en una ruta absoluta. Puede crecer, hasta 50 GB, y no se achica. Crecer no reinicia el servicio. Borrar el servicio borra el volumen y sus datos. Reset y detach también borran esos datos. Los archivos escritos fuera del volumen son temporales: un deploy, un reinicio o un reschedule pueden reemplazar el contenedor.

Un servicio con volumen persistente siempre corre una réplica. Los servicios de imagen y los workers siempre corren una. Los de repositorio y los de upload pueden correr varias, hasta 3 en la celda compartida. Las celdas dedicadas permiten más. Cómo definir el mínimo, el máximo y el disparador está en escala automática de réplicas.

Los backups van a un destino compatible con S3 que controlás. Un volumen no es, por sí mismo, un backup. La ruta está en almacenamiento persistente y en la guía de storage. Cómo confirmar un registro de prueba después de un redespliegue está en Volúmenes persistentes.

Variables de entorno y secretos

env_file y un .env en la laptop no son el almacén de producción. Poné los valores de runtime en el servicio. Un secreto copiado a una capa de la imagen queda en el artefacto aunque una capa posterior borre el archivo. Sumá .env, credenciales locales y otros archivos que no querés en el build a .dockerignore cuando el Dockerfile copia una ruta amplia. En un servicio de imagen, preferí un tag de release o un digest, para poder nombrar el artefacto que bajaste. Los dos puntos están en la guía de Docker.

En Unbroker una variable es Production, Preview o All. Pegar un archivo .env importa esas variables en el entorno que elegiste. Un preview nuevo copia All y Preview, y nunca recibe Production. Poné la contraseña de la base de producción en Production, salvo que quieras que los previews la vean. La nota larga es entornos de preview por pull request. Las reglas están en la guía de variables de entorno.

Bases: el contenedor o una gestionada

Un servicio de base en el archivo compose es un motor que operás: la imagen, el volumen, los upgrades, los backups y los restores. Declarar un contenedor no incluye alta disponibilidad.

Unbroker tiene dos modelos. Elegir una base es la fuente de este reparto.

Base gestionadaNodo de base en Apps
Corre comoClúster operado por el proveedorServicio privado desde una imagen de base
OperaciónEl proveedor se ocupa del host y del ciclo del clústerActualizás la imagen, probás backups y restaurás
BackupsDependen del motor y del planBackups del volumen a un destino compatible con S3 que controlás
EncajaDatos importantes de producciónLa imagen, la versión y el volumen quedan en el proyecto

Usá una base gestionada para datos importantes de producción, salvo que tengas un motivo para operar el motor como servicio de la aplicación. “Gestionada” no significa que todas las funciones de recuperación estén en el plan. Confirmá el motor y el plan. Seguís dueño del schema, las queries, las credenciales y un restore que ya probaste. Operar Postgres es la nota aparte Postgres en producción.

Los nodos de base en Apps son PostgreSQL, Redis, MongoDB y MySQL. Cada uno es privado por defecto, con la imagen oficial, un volumen y una contraseña generada. Vos elegís cuándo actualizar, probás los backups y hacés los restores. La alta disponibilidad no está implícita. El detalle está en nodos de base.

La API de bases gestionadas soporta PostgreSQL, MySQL, Redis, Valkey, MongoDB, Kafka y OpenSearch. La disponibilidad cambia según el proveedor y la región. El flujo de creación muestra las combinaciones que ofrecen ese proveedor y esa región. PostgreSQL y MySQL gestionados arrancan en $21.21 por mes en precios. El plan más chico de Postgres gestionado en el catálogo actual es 1 vCPU, 1 GB de RAM y 10 GB de almacenamiento. Ese precio es aparte de Pro. Pro sale $25 por mes con $25 de crédito de uso. Las bases gestionadas no están en Free. Las páginas de planes son bases gestionadas, Postgres gestionado y precios.

Reinicios, salud y logs

En un solo servidor, restart: always es la forma en que Docker vuelve a levantar un contenedor detenido. La política no te avisa si el proceso entra en crash-loop.

En Unbroker, un servicio que se cae o entra en crash-loop dispara una alerta integrada. No agregás una regla para eso. Está activa mientras las alertas están habilitadas en la organización. Las métricas incluyen CPU, memoria, reinicios y réplicas ready. Las métricas de recursos son parte de Pro. La lista está en la guía de monitoreo.

La nota de producción de Docker también incluye sumar un servicio como un agregador de logs. Los logs de runtime en Unbroker son lo que el servicio escribe en stdout y stderr, y se guardan 7 días. Ese es el log que leés en el servicio. Es otra cosa que un contenedor agregador de logs en el archivo compose.

Checklist para pasar a producción

Recorré el archivo una vez. Cada línea es una decisión.

  1. Listá cada servicio y marcalo: app HTTP, worker, base o archivos.
  2. Sacá los bind mounts del código. Dejá los datos en un volumen o en una base.
  3. Agregá un healthcheck y condition: service_healthy donde importe el orden de arranque. Dejá los reintentos en la app.
  4. Publicá solo los servicios que tienen que tener URL. Apuntá el resto a un host y un puerto privados.
  5. Poné los secretos en variables de entorno. Dejá los valores de Production fuera de Preview.
  6. Elegí cada base: un nodo que operás, o un clúster gestionado. Restaurá un backup una vez.
  7. En un solo servidor, definí una política de reinicio como restart: always. Donde la plataforma corre el proceso, mirá reinicios y crash-loops.
  8. Fijá cada servicio de imagen a un tag de release o a un digest.
  9. Creá un servicio por pieza en un proyecto. Si pegás el archivo compose, revisá cada servicio que creó contra esta lista.
  10. Revisá el plan. Dockerfile, imágenes de contenedor, workers, volúmenes persistentes y bases gestionadas requieren Pro.

Cómo queda en Unbroker

Creá un proyecto y sumá un servicio por cada pieza. Un servicio de repositorio construye la app HTTP con Railpack o un Dockerfile. Un servicio FastAPI construido con ese Dockerfile es un contenedor que corre Uvicorn. Qué cambia después de fastapi dev está en FastAPI en producción. Un servicio de imagen baja una imagen OCI y no se reconstruye. Un worker corre un proceso sin HTTP de entrada. Una base es un nodo de Apps o una base gestionada. Un volumen es solo para archivos que tienen que sobrevivir a un contenedor nuevo.

Los servicios del mismo entorno llegan a un servicio privado en ${{services.api.host}}:${{services.api.port}}. Los previews no llegan a producción.

El archivo compose es el inventario. Al crear un proyecto podés pegarlo, y Unbroker crea un servicio por cada entrada para imágenes, builds de repositorio, environment, depends_on, puertos, comandos y un volumen persistente por servicio. Eso está en la nota de importación de Compose. Después revisá cada servicio: pegar el archivo no decide qué es público, dónde viven los datos ni si la base es un clúster gestionado. Un archivo de otra plataforma, como render.yaml, no es un formato de importación de Unbroker. La guía para migrar desde Render lo dice para ese archivo.

Free no incluye volúmenes persistentes, bases gestionadas, Dockerfiles ni imágenes de contenedor. Pro sale $25 por mes con $25 de crédito de uso. El crédito se reinicia en cada ciclo y no se acumula. El uso por encima del crédito se factura aparte. Un solo contenedor empieza en Docker en Unbroker. Los límites del plan están en precios.

Preguntas frecuentes

¿Puedo correr Docker Compose en producción?

Sí, en un solo servidor. Docker lo documenta como el deploy más simple, y dice que escalar ese esquema es correr Compose en Swarm. El límite es ese host. En una plataforma el esquema es otro: un servicio por cada pieza del archivo.

¿depends_on espera a que la base esté lista?

No. Compose espera a que la dependencia esté running, no lista. condition: service_healthy espera un healthcheck. Las otras condiciones son service_started y service_completed_successfully. La app igual tiene que reintentar conexiones, porque la base puede reiniciarse después. El ejemplo de Docker revisa Postgres con pg_isready.

¿La base tiene que correr en Compose en producción?

Depende de quién la opera. Un contenedor de base es un motor que actualizás, respaldás y restaurás. Una base gestionada es un clúster que opera el proveedor. Igual seguís dueño del schema, las queries, las credenciales y un restore que ya probaste. Usá una base gestionada para datos importantes de producción, salvo que tengas un motivo para operar el motor. Esto no es una comparación de precio.

¿Puedo subir mi docker-compose.yml a Unbroker?

Podés pegar un archivo compose al crear un proyecto. Unbroker crea un servicio por cada entrada. Ese camino soporta imágenes, builds de repositorio, environment, depends_on, puertos, comandos y un volumen persistente por servicio. No decide qué es público, dónde viven los datos ni si la base tiene que ser un clúster gestionado. Un archivo de otra plataforma, como render.yaml, no es un formato de importación de Unbroker.

¿Qué pasa con mis volúmenes?

En Unbroker un volumen pertenece a un servicio y se monta en una ruta absoluta. Puede crecer hasta 50 GB y no se achica. Borrar el servicio borra el volumen. Los archivos fuera del volumen son temporales, porque un deploy, un reinicio o un reschedule pueden reemplazar el contenedor. Los backups van a un destino compatible con S3 que controlás. Free no incluye volúmenes persistentes.