Dashy convierte la maraña de direcciones IP y puertos de tu homelab en una única página de inicio, con comprobación de estado en vivo, widgets y un editor visual. En esta guía lo levantas con un solo archivo docker-compose.yml, aprendes a estructurar su archivo conf.yml, activas la comprobación de estado de cada servicio y le cambias el tema y los iconos. Al final tendrás un panel propio en el puerto 4000 que sirve de portada a toda tu infraestructura. La misma explicación está disponible en inglés.

Puntos clave

  • Dashy es un panel de inicio self-hosted de código abierto, escrito en Vue, con más de 25 900 estrellas en GitHub y licencia MIT.
  • Se distribuye como imagen oficial lissy93/dashy (también en ghcr.io/lissy93/dashy); la última versión estable es la 4.4.0, de julio de 2026.
  • Toda su configuración vive en un único archivo conf.yml montado en /app/user-data, con cuatro secciones raíz: pageInfo, appConfig, sections y pages.
  • El contenedor sirve la web en el puerto 8080; la imagen incluye un healthcheck propio (node /app/services/healthcheck.js) que Docker comprueba cada 90 segundos.
  • Fija siempre una versión concreta como lissy93/dashy:4.4.0; usar la etiqueta :latest te expone a cambios de comportamiento sin avisar.

¿Qué es Dashy y para qué sirve?

Dashy es una aplicación de código abierto que te ofrece una página de inicio para tu servidor doméstico o tu homelab. En lugar de memorizar que Jellyfin está en el puerto 8096 y Portainer en el 9000, agrupas todos tus servicios en tarjetas ordenadas por secciones, con su icono, su descripción y un enlace directo. Está construido con Vue y se centra en tres cosas que lo distinguen de un panel de enlaces cualquiera: comprobación del estado de cada servicio, un catálogo amplio de widgets y un editor visual que escribe la configuración por ti.

La diferencia de fondo respecto a alternativas más ligeras es que Dashy no es solo una rejilla de accesos directos. Cada elemento puede sondear su servicio y mostrar en verde o en rojo si responde, de modo que el propio panel te avisa de un contenedor caído. Además trae widgets que muestran información en directo (el tiempo, el estado del sistema, RSS, estadísticas de tus propios servicios), un buscador integrado y atajos de teclado. Todo ello lo coloca un peldaño por encima de un simple marcador de favoritos.

Dashy compite en la misma categoría que otros paneles de este itinerario. Si buscas un editor por arrastrar y soltar más moderno, mira Homarr; si prefieres algo minimalista basado en la imagen de LinuxServer, tienes Heimdall. Dashy se sitúa en el punto medio: más potente que Heimdall, más configurable por texto que Homarr.

¿Cómo es el docker-compose.yml de Dashy?

Dashy necesita muy poco: la imagen y un directorio donde guardar su conf.yml. Este es un docker-compose.yml completo, con la versión fijada, un bind mount para la carpeta user-data (donde vive la configuración), el puerto publicado solo en la propia máquina y el healthcheck que trae la imagen:

services:
  dashy:
    image: lissy93/dashy:4.4.0
    container_name: dashy
    restart: unless-stopped
    ports:
      - "127.0.0.1:4000:8080"
    volumes:
      - ./user-data:/app/user-data
    environment:
      NODE_ENV: production
    healthcheck:
      test: ["CMD", "node", "/app/services/healthcheck.js"]
      interval: 90s
      timeout: 10s
      retries: 3
      start_period: 30s

Conviene detenerse en dos detalles. El contenedor sirve la web en el puerto 8080, pero aquí lo publicamos como 127.0.0.1:4000:8080: por fuera queda en el 4000 (la convención histórica de Dashy) y accesible solo desde el propio servidor. El montaje ./user-data:/app/user-data es un bind mount: enlaza una carpeta de tu disco con la del contenedor, así tu conf.yml sobrevive a cualquier recreación del contenedor. Si quieres entender cuándo usar un bind mount y cuándo un volumen con nombre, lo detallamos en la guía sobre volúmenes y bind mounts en Docker.

Crea la carpeta y arranca la pila:

mkdir -p user-data
docker compose up -d
docker compose ps
docker compose logs -f dashy

En el primer arranque, si la carpeta user-data está vacía, Dashy genera un conf.yml de ejemplo. Abre http://127.0.0.1:4000 y verás el panel con la configuración por defecto, listo para que lo hagas tuyo.

¿Cómo se configura el archivo conf.yml?

Todo Dashy se controla desde un único archivo YAML, conf.yml, montado dentro del contenedor en /app/user-data/conf.yml. Tiene cuatro secciones de primer nivel: pageInfo (título, descripción y enlaces de la cabecera), appConfig (ajustes globales como el tema o la comprobación de estado), sections (los grupos de tarjetas, que es donde pasarás la mayor parte del tiempo) y pages (para repartir el panel en varias páginas). Un conf.yml mínimo con dos secciones se ve así:

pageInfo:
  title: Mi homelab
  description: Panel de servicios
appConfig:
  theme: colorful
  statusCheck: true
  statusCheckInterval: 60
sections:
  - name: Multimedia
    icon: fas fa-photo-video
    items:
      - title: Jellyfin
        url: http://192.168.1.10:8096
        icon: hl-jellyfin
        statusCheck: true
  - name: Gestión
    icon: fas fa-cogs
    items:
      - title: Portainer
        url: http://192.168.1.10:9000
        icon: hl-portainer

Cada elemento de items acepta un title, la url de destino, un icon y campos opcionales como description, target (para abrir en una pestaña nueva) o tags (para el buscador). No hace falta reiniciar el contenedor tras cada cambio: al guardar el fichero, Dashy detecta la modificación y recarga la configuración. Y si prefieres no tocar YAML, la propia interfaz trae un editor visual (el icono del lápiz) que escribe los cambios en conf.yml por ti. Para servir Dashy con un dominio y HTTPS, colócalo detrás de un proxy inverso como Traefik.

¿Cómo funcionan la comprobación de estado y los widgets?

La función estrella de Dashy es la comprobación de estado (statusCheck). Cuando la activas, Dashy lanza una petición HTTP a cada servicio y pinta un indicador verde si responde y rojo si no. La activas de forma global poniendo statusCheck: true en appConfig, o servicio a servicio en cada elemento. El intervalo lo controla statusCheckInterval, en segundos (si vale 0, solo se comprueba al cargar la página). Para casos concretos puedes afinar con statusCheckUrl, statusCheckAcceptCodes o statusCheckAllowInsecure.

La segunda pata son los widgets. Además de las tarjetas de enlace, una sección puede contener widgets que muestran datos en vivo: el tiempo, el uso de CPU y RAM del propio servidor, un feed RSS, el estado de contenedores o métricas de servicios que ya tengas montados. Se declaran igual que los items, dentro de una sección:

sections:
  - name: Sistema
    widgets:
      - type: cpu-usage
      - type: memory-usage
      - type: weather
        options:
          apiKey: TU_CLAVE
          city: Sevilla

Con estas dos piezas, Dashy deja de ser una lista de marcadores y se convierte en un tablero real: de un vistazo sabes qué servicios están arriba y cómo anda el servidor. Para una monitorización más profunda de métricas históricas, combínalo con una pila dedicada como Prometheus y Grafana; Dashy es la portada, no el sistema de observabilidad completo.

¿Cómo cambiar temas e iconos?

Dashy trae más de una docena de temas integrados que cambias en caliente desde el propio panel (menú de configuración, arriba a la derecha) o fijas en conf.yml con la clave theme. Puedes definir un tema para el día y otro para la noche con dayTheme y nightTheme, y ajustar colores concretos con customColors. Si quieres ir más allá, customCss te deja inyectar tus propias reglas CSS.

Los iconos son el otro gran punto de personalización, y Dashy admite varias fuentes en el campo icon de cada elemento:

  • Favicons: escribe favicon y Dashy descarga el icono real del sitio a partir de su URL.
  • Logos de homelab: prefijo hl- seguido del nombre del servicio (por ejemplo hl-jellyfin), del enorme catálogo de selfh.st/icons.
  • Font Awesome: fas fa-nombre o fab fa-nombre, activando enableFontAwesome.
  • Material Design Icons: mdi-nombre, activando enableMaterialDesignIcons.
  • Emojis o URLs: pega directamente un emoji o el enlace a una imagen.

Entre temas, iconos y widgets, dos instalaciones de Dashy pueden parecer aplicaciones distintas. Ese es su punto fuerte frente a paneles más rígidos como Heimdall: partes de una plantilla y acabas con una portada a tu medida.

Preguntas frecuentes

¿En qué se diferencia Dashy de Homarr o Heimdall?

Los tres son paneles de inicio self-hosted, pero con filosofías distintas. Heimdall es el más sencillo: una rejilla de accesos con la imagen de LinuxServer. Homarr apuesta por un editor visual por arrastrar y soltar y una configuración guardada en base de datos. Dashy se sitúa en medio: su configuración vive en un archivo conf.yml versionable, pero también ofrece editor visual, y aventaja a ambos en comprobación de estado y variedad de widgets.

¿Necesita Dashy una base de datos?

No. A diferencia de otros paneles, Dashy no requiere ninguna base de datos externa: todo su estado cabe en el archivo conf.yml y en la carpeta user-data. Eso simplifica muchísimo las copias de seguridad, porque basta con guardar esa carpeta, y lo hace ideal para versionarlo en Git. Es también la razón de que su huella de recursos sea modesta para lo que ofrece.

¿Cómo hago copia de seguridad de mi configuración de Dashy?

Copia la carpeta user-data, que es donde reside el conf.yml y cualquier icono local que hayas añadido. Como es texto plano, muchos usuarios la guardan en un repositorio Git privado, con lo que consiguen historial de cambios además de respaldo. Si editas desde la interfaz visual, recuerda pulsar en guardar los cambios en disco para que se escriban en conf.yml y no se queden solo en el navegador.

Conclusión

Con un único docker-compose.yml y un archivo conf.yml, Dashy te da una portada para todo tu homelab en el puerto 4000: tarjetas ordenadas por secciones, comprobación de estado en vivo, widgets con datos reales y una personalización casi ilimitada de temas e iconos. Al no depender de ninguna base de datos, la copia de seguridad se reduce a guardar una carpeta de texto plano. Empieza con la configuración de ejemplo, añade tus servicios uno a uno y, cuando quieras servirlo con dominio propio, colócalo detrás de un proxy inverso. Si prefieres un editor totalmente visual, compáralo antes con Homarr.

Fuentes

  1. Documentación oficial de Dashy
  2. Repositorio de Dashy en GitHub
  3. Guía de configuración de conf.yml
  4. Imagen oficial lissy93/dashy en Docker Hub

Ruta: Paneles y notificaciones self-hosted con Docker