Cómo instalar Umami Analytics en Docker (guía 2026)

Umami es una herramienta de analítica web sencilla, rápida y centrada en la privacidad, y una sólida alternativa a Google Analytics. Tiene licencia MIT, más de 37.000 estrellas en GitHub y solo recopila las métricas que necesitas sin rastrear a tus visitantes. Si quieres comparar opciones, Plausible y Matomo son herramientas de analítica autoalojadas similares. También puedes instalar Plausible Analytics con una configuración de Docker parecida.

Con Google Analytics 4 y la aplicación del RGPD en la UE, la analítica web autoalojada se ha convertido en la opción por defecto para quienes quieren la propiedad total de sus datos. Los scripts de Google Analytics son pesados y ralentizan tu sitio. Umami añade menos de 2 KB de sobrecarga.

Esta guía cubre cómo instalar Umami Analytics en Docker con Docker Compose, incluida la configuración del tracker, cómo evitar los bloqueadores de anuncios, las actualizaciones y las copias de seguridad. Umami v3 se lanzó en noviembre de 2025 con una nueva interfaz, mapas de calor, reproducción de sesiones, y ahora es solo compatible con PostgreSQL (se eliminó el soporte de MySQL).

Puedes encontrar más aplicaciones autoalojadas de código abierto y gratuitas en la sección self-hosted de toolhunt.net.

Pasos para instalar Umami Analytics con Docker Compose

Vamos a desplegar Umami en un VPS con Docker Compose y después configuraremos Cloudflare Tunnels para el acceso público con SSL. El vídeo a continuación cubre todo el proceso.

1. Requisitos previos

Los precios de los VPS subieron en todos los proveedores en 2026: si estás reconsiderando un servidor alquilado, mira qué cambió y cuándo gana un mini PC.

2. Archivo Docker Compose para Umami

A continuación tienes dos archivos compose. El primero es una configuración limpia sin copias de seguridad; úsalo si piensas hacer backups con un pg_dump programado por cron (recomendado). El segundo añade un contenedor sidecar tiredofit/db-backup para volcados automáticos programados.

services:
  umami:
    image: docker.umami.is/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@umami-db:5432/${POSTGRES_DB}
      APP_SECRET: ${APP_SECRET}
      DISABLE_TELEMETRY: ${DISABLE_TELEMETRY:-1}
    depends_on:
      umami-db:
        condition: service_healthy
    init: true
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5

  umami-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      TZ: UTC
    volumes:
      - ./umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5

services:
  umami:
    image: docker.umami.is/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@umami-db:5432/${POSTGRES_DB}
      APP_SECRET: ${APP_SECRET}
      DISABLE_TELEMETRY: ${DISABLE_TELEMETRY:-1}
    depends_on:
      umami-db:
        condition: service_healthy
    init: true
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5

  umami-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      TZ: UTC
    volumes:
      - ./umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5

  umami-db-backup:
    container_name: umami-db-backup
    image: tiredofit/db-backup
    volumes:
      - ./backups:/backup
    environment:
      DB_TYPE: postgres
      DB_HOST: umami-db
      DB_NAME: ${POSTGRES_DB}
      DB_USER: ${POSTGRES_USER}
      DB_PASS: ${POSTGRES_PASSWORD}
      DB_BACKUP_INTERVAL: 720
      DB_CLEANUP_TIME: 72000
      CHECKSUM: SHA1
      COMPRESSION: GZ
      CONTAINER_ENABLE_MONITORING: false
    depends_on:
      umami-db:
        condition: service_healthy
    restart: always

Si necesitas ejecutar varias bases de datos PostgreSQL en el mismo host, puedes consolidarlas en un único contenedor de Postgres para ahorrar memoria.

3. Configura el archivo .env

Crea un archivo .env en el mismo directorio que tu archivo compose (o añade las variables en la sección de entorno de Dockge).

POSTGRES_USER=umami
POSTGRES_PASSWORD=your-secure-password
POSTGRES_DB=umami
APP_SECRET=run-openssl-rand-hex-32-to-generate
DISABLE_TELEMETRY=1

4. Despliega Umami

Si usas Dockge, ponle un nombre a tu stack y pulsa deploy. Con Docker Compose directamente:

docker compose up -d

Verifica que ambos contenedores estén saludables:

docker compose ps

Deberías ver tanto umami como umami-db con estado healthy. Revisa los logs de Umami para confirmar que las migraciones se ejecutaron:

docker compose logs -f umami

Una salida correcta muestra All migrations have been successfully applied seguido del servidor escuchando en el puerto 3000.

Accede a Umami en http://tu-ip-del-vps:3000. Inicia sesión con las credenciales por defecto:

• Usuario: admin
• Contraseña: umami

Verificación rápida con curl:

curl http://localhost:3000/api/heartbeat
# Debería devolver: OK

5. Configura Cloudflare Tunnels para Umami

Ve a Access → Tunnels en el panel de Cloudflare, elige tu túnel y añade un hostname que mapee un dominio o subdominio al servicio de Umami en el puerto 3000.

También puedes consultar Configurar CloudPanel como proxy inverso con Docker y Dockge para usar CloudPanel como proxy inverso de tus contenedores Docker, o autoalojar con Docker y Cloudflare Tunnels para otro ejemplo de despliegue.

6. Añade tu primer sitio web a Umami

Una vez configurado el túnel, accede a Umami en tu dominio. Inicia sesión y ve a Settings en la cabecera. Verás un botón para añadir un sitio web:

Después de añadir el sitio web, haz clic en Edit Website (o ve a Settings) para encontrar tu código de seguimiento. Puedes pegarlo en el <head> de tu sitio.

Código de seguimiento de Umami y configuración del tracker

Una vez añadido tu sitio web, Umami te proporciona un script de seguimiento. Así se usa y estas son las opciones disponibles.

Script de seguimiento básico

El embed estándar tiene este aspecto:

<script
  defer
  src="https://your-umami-domain.com/script.js"
  data-website-id="your-website-id"
></script>

• data-website-id (el UUID del sitio web que añadiste en Umami, visible en el fragmento del código de seguimiento)
• data-host-url (configúralo si el dominio del tracker difiere del dominio del panel, por ejemplo si sirves el script desde una CDN)

Eventos personalizados y opciones avanzadas

Umami admite el seguimiento de eventos tanto programático como declarativo.

Programático (llamada desde JavaScript):

// Registra un evento personalizado con propiedades
umami.track("signup", { plan: "pro", source: "header" });

Declarativo (añade atributos HTML a cualquier elemento):

<button data-umami-event="click-download" data-umami-file="whitepaper.pdf">
  Download
</button>

Otros atributos data útiles:

Si usas un sitio Astro, consulta Plausible Analytics para Astro con Cloudflare Workers para ver un enfoque de integración de analítica relacionado.

Evitar los bloqueadores de anuncios

Los bloqueadores de anuncios atacan dos rutas por defecto: /script.js y /api/send. Puedes renombrar ambas con variables de entorno:

TRACKER_SCRIPT_NAME=custom-tracker
COLLECT_API_ENDPOINT=/api/collect

Añádelas al entorno del servicio umami en tu archivo compose y reinicia. Actualiza el src de tu script de seguimiento para que coincida:

<script
  defer
  src="https://your-domain.com/custom-tracker.js"
  data-website-id="your-website-id"
></script>

environment:
  DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@umami-db:5432/${POSTGRES_DB}
  APP_SECRET: ${APP_SECRET}
  DISABLE_TELEMETRY: ${DISABLE_TELEMETRY:-1}
  TRACKER_SCRIPT_NAME: my-stats
  COLLECT_API_ENDPOINT: /api/c
  CLIENT_IP_HEADER: cf-connecting-ip

<script
  defer
  src="https://stats.yourdomain.com/my-stats.js"
  data-website-id="your-website-id"
></script>

Cómo actualizar Umami Analytics en Docker

Actualizaciones estándar (misma versión mayor)

Para actualizaciones menores dentro de v3.x:

# 1. Haz primero una copia de seguridad de la base de datos
docker compose exec -T umami-db pg_dump -U umami umami | gzip > backups/umami-$(date +%F-%H%M).sql.gz

# 2. Descarga la última imagen
docker compose pull

# 3. Recrea los contenedores
docker compose up -d --force-recreate

# 4. Verifica: busca "All migrations have been successfully applied"
docker compose logs -f umami

Actualizar de Umami v2 a v3

Pasos:

# 1. Copia de seguridad
docker compose exec -T umami-db pg_dump -U umami umami > umami-backup-$(date +%F-%H%M).sql

# 2. Descarga y recrea
docker compose pull
docker compose up -d --force-recreate umami

# 3. Revisa los logs para ver la salida de las migraciones
docker compose logs -f umami

# 4. Ejecuta ANALYZE en PostgreSQL (crítico tras actualizaciones mayores)
docker compose exec -T umami-db psql -U umami umami -c "ANALYZE;"

El comando ANALYZE actualiza las estadísticas del planificador de consultas de PostgreSQL tras las migraciones de esquema. La documentación oficial de Umami lo recomienda. Sin él, las consultas del panel pueden volverse lentas después de una actualización mayor.

Tras actualizar, las imágenes Docker antiguas se acumulan en el disco. Puedes limpiar el espacio en disco de Docker para recuperar almacenamiento.

Copia de seguridad y restauración de la base de datos

docker compose exec -T umami-db pg_dump -U umami umami | gzip > backups/umami-$(date +%F).sql.gz

0 3 * * * cd /path/to/umami && docker compose exec -T umami-db pg_dump -U umami umami | gzip > backups/umami-$(date +\%F).sql.gz

gunzip < backups/umami-YYYY-MM-DD.sql.gz | docker compose exec -T umami-db psql -U umami umami

# Encuentra el último backup
ls -lt backups/

# Restáuralo
zcat backups/umami-db-*.sql.gz | docker compose exec -T umami-db psql -U umami umami

Verifica y soluciona problemas de tu instalación de Umami

Si quieres monitorizar los recursos de tu servidor junto a Umami, monta un stack de monitorización ligero.

docker compose exec -T umami-db psql -U umami umami -c "ANALYZE;"

CLIENT_IP_HEADER=cf-connecting-ip

deploy:
  resources:
    limits:
      memory: 256M

Umami v3: novedades

PostgreSQL v12.14+ es obligatorio para v3. La imagen postgres:15-alpine usada en esta guía lo cumple.

Conclusión

Ya tienes Umami Analytics instalado en Docker, con una configuración de tracker funcional, opciones para evitar los bloqueadores de anuncios y un flujo sólido de actualizaciones y copias de seguridad. Umami es gratuito, usa unos 300 MB de RAM en total y te da la propiedad completa de tus datos de analítica. Sin acceso de terceros, sin dolores de cabeza con el RGPD.

Puntos clave a recordar: haz copia de seguridad antes de cada actualización mayor, fija la versión de la imagen para reproducibilidad y cambia la contraseña por defecto inmediatamente después del primer inicio de sesión. Si quieres explorar otras opciones, también puedes instalar Plausible Analytics con un enfoque de Docker similar, o monitorizar los recursos de tu servidor para vigilar tu VPS.