Docker Compose

Despliega un stack multi-contenedor desde un Compose YAML — Pier hace el resto.

Application #docker#compose#multi-container

Pega un docker-compose.yaml en Pier y envía una aplicación multi-contenedor — web + worker + cache + queue + database, lo que sea. Pier aprovisiona el stack, lo adjunta a Traefik para HTTPS, gestiona volúmenes persistentes y expone los mismos controles de ciclo de vida (logs, env, restart, redeploy) que las plantillas nativas.

Desplegar con Pier

1 Abre el panel de Pier y haz clic en Add service.
2 Elige Docker Compose en la lista de plantillas.
3 Elige la versión, asigna un nombre al servicio y Pier provisionará automáticamente el contenedor, el almacenamiento y los puertos.
4 Vincula un dominio si quieres HTTPS. Traefik genera el certificado de Let's Encrypt automáticamente.

¿Qué es Docker Compose en Pier?

Esta plantilla envuelve Docker Compose para que puedas pegar un YAML de aplicación multi-contenedor directo en la UI Pier y enviarla. Pier aprovisiona el stack, lo adjunta a su red Traefik-fronted para HTTPS, trackea volúmenes nombrados, gestiona env vars, agrega logs por servicio, y ofrece los mismos controles de ciclo de vida (restart, redeploy, view logs, edit env) que las plantillas nativas.

El killer use case son proyectos open-source que envían un docker-compose.yaml canónico como su método de instalación — pega, configura dominio, deploy. Tus propias aplicaciones multi-servicio (web + worker + Redis + Postgres, etc.) también caben naturalmente — sin necesidad de descomponerlas en servicios Pier individuales si pertenecen juntas.

Cómo lo despliega Pier

Pegas un Compose YAML en la UI, opcionalmente configuras overrides env a nivel servicio, y Pier corre docker compose up -d en el host. Volúmenes nombrados se vuelven volúmenes Pier-managed que aparecen en la página de volúmenes. Redes default a un bridge por-stack; agrega la red externa pier-traefik a cualquier servicio que deba estar detrás de HTTPS.

Integración Traefik es vía labels Traefik estándar en el servicio — traefik.enable=true, traefik.http.routers.<name>.rule=Host(...), etc. Pier provee resolvers Let’s Encrypt automáticamente; solo agregas el dominio.

Updates son edit YAML + redeploy; Pier diffs el stack existente y recrea solo lo que cambió.

Cuándo NO usar Docker Compose

Para apps single-container, la plantilla Docker Image es más simple — sin YAML que gestionar. Para un repo de código (no una imagen prebuilt), las plantillas Dockerfile o Railpack construyen por ti. Para servicios Pier nativos con backups gestionados y version upgrades (PostgreSQL, Gitea, Grafana, etc.), elige la plantilla dedicada — obtienes más features de ciclo de vida. Compose es la respuesta correcta para “app multi-contenedor que no es plantilla nativa.”

Características clave

Apps multi-contenedor pega-y-despliega

Drop un `docker-compose.yaml` completo en la UI de Pier; Pier despliega todos los servicios juntos con la red correcta, dependencias y políticas de restart.

Integración Traefik

Agrega labels Traefik a tus servicios y Pier los cablea para HTTPS en tu dominio custom — sin reverse proxy separado que setear.

Volúmenes persistentes

Volúmenes nombrados en tu Compose YAML son trackeados por Pier — respaldados, listados en UI, restaurables.

Gestión env multi-servicio

Override env vars por servicio desde la UI Pier sin editar el YAML. Útil para rotar passwords o togglear features.

Logs agregados por servicio

Ver logs de cualquier contenedor del stack desde la UI Pier. Tail live, search, export.

Redeploy en un clic

Push image updates o cambia YAML — redeploy desde UI; Pier maneja rebuild de contenedor y rollout.

Casos de uso

Aplicaciones multi-servicio

Web + worker + Redis + Postgres + nginx — setup típico Rails / Django / Laravel / Next.js + worker desplegado como una unidad.

Apps desde archivos Compose upstream

Muchos proyectos open-source envían un docker-compose.yaml como su método canónico de instalación. Pégalo en Pier y listo.

Paridad local-dev → prod

Tu archivo Compose local puede ser el mismo que envías a Pier (menos diferencias de path de volúmenes). Reduce drift dev/prod.

Patrones sidecar

Servicio + sidecar (log shipper, metric exporter, init container) bundleados en un stack Compose.

Bundles pre-cableados

Construye tu propio bundle "servicio A + compañero B + compañero C" reusable y re-deploy entre proyectos.

Ejemplos de código

App simple de dos servicios (web + Postgres) yaml

services:
  web:
    image: my-org/myapp:1.4.0
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/myapp
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
    volumes:
      - db-data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  db-data:

Agregar labels Traefik para HTTPS yaml

services:
  web:
    image: my-org/myapp:1.4.0
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.myapp.rule=Host(`app.example.com`)"
      - "traefik.http.routers.myapp.entrypoints=websecure"
      - "traefik.http.routers.myapp.tls.certresolver=letsencrypt"
      - "traefik.http.services.myapp.loadbalancer.server.port=3000"
    networks:
      - pier-traefik

networks:
  pier-traefik:
    external: true

Web + worker + Redis + Postgres yaml

services:
  web:
    image: my-org/myapp:1.4.0
    environment: &app-env
      REDIS_URL: redis://redis:6379
      DATABASE_URL: postgres://app:secret@db:5432/myapp
  worker:
    image: my-org/myapp:1.4.0
    command: ["bundle", "exec", "sidekiq"]
    environment: *app-env
  redis:
    image: redis:7-alpine
    volumes: ["redis-data:/data"]
  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
    volumes: ["db-data:/var/lib/postgresql/data"]
volumes:
  redis-data:
  db-data:

Flow override env-var (en UI Pier) text

Página servicio → Environment → agregar fila
  Key - API_KEY
  Value - sk-xxxxxxxxxxxx
  Apply → restart contenedor
El override queda en Pier, nunca editado en tu YAML

Comparativa

vs Dockerfile (este catálogo)	Dockerfile construye y corre UN contenedor. Compose orquesta MÚLTIPLES contenedores juntos. Elige por scope.
vs Plantillas Pier nativas (postgresql, gitea, ...)	Plantillas nativas son pre-cableadas y gestionadas por Pier (backups, version upgrades, features de scaling). Compose es el escape hatch "tengo una app multi-contenedor de mi propio diseño".
vs Kubernetes	K8s es para orquestación multi-host fleet-wide con autoscaling, rolling updates, service mesh. Compose es single-host. Usa K8s cuando necesites ese scope; Compose cuando no.
vs Docker Image (este catálogo)	Docker Image corre una imagen prebuilt. Compose corre muchos contenedores cableados. Usa Image para el caso single-service más simple; Compose para cualquier multi-contenedor.

Preguntas frecuentes

¿Qué versión Compose es soportada?

Pier soporta Compose spec v3+ (la versión unificada moderna). Archivos YAML usando `version: '3.8'` o sin version field funcionan bien.

¿Puedo usar interpolación ${VAR}?

Sí — Pier inyecta env vars en el Compose YAML en deploy time. Defínelas en el tab env del servicio.

¿Cómo funcionan los volúmenes?

Volúmenes nombrados en tu YAML (e.g. db-data) se vuelven volúmenes Pier-managed. Bind mounts a paths host también funcionan pero son menos portables.

¿Healthchecks?

Compose healthchecks funcionan — Pier los respeta cuando reporta status. Configúralos en YAML.

¿Cómo conecto servicios Compose a Traefik?

Adjunta el servicio a la red externa `pier-traefik` y agrega labels `traefik.*` según los docs Traefik. Pier cablea el resto.

¿Límites de recursos?

Configura `deploy.resources.limits.cpus` y `memory` en Compose YAML. Pier los respeta.

¿Cómo actualizo?

Edita el YAML en la UI Pier (o estilo `docker-compose pull` — apunta a nuevo image tag), click Redeploy. Pier recrea solo servicios cambiados.

Servicios relacionados

Desplegar en tu VPS

Desplegar este servicio →