Wiki completa de Uptime Kuma: 9 páginas en español

Actualización.md

@@ -0,0 +1,318 @@
+# Actualización
+
+Guía para mantener Uptime Kuma actualizada de forma segura.
+
+---
+
+## Estrategia de Versionado
+
+Uptime Kuma usa **versionado semántico**: `MAJOR.MINOR.PATCH`
+
+**Tags Docker**:
+- `latest`: Última versión (no recomendado en producción)
+- `1`: Última versión 1.x (recomendado)
+- `1.23`: Última versión 1.23.x
+- `1.23.11`: Versión específica
+
+**Recomendación**: Usar tag `1` para recibir actualizaciones automáticas dentro de v1.x (compatibles).
+
+---
+
+## Actualización Manual
+
+### 1. Backup Previo (CRÍTICO)
+
+```bash
+# Backup base de datos
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".backup /app/data/kuma-pre-update.db"
+
+# Copiar al host
+docker compose cp uptime-kuma:/app/data/kuma-pre-update.db ./backup/kuma-$(date +%Y%m%d)-pre-update.db
+```
+
+### 2. Pull Nueva Imagen
+
+```bash
+cd /path/to/uptime-kuma
+docker compose pull uptime-kuma
+```
+
+**Salida esperada**:
+```
+Pulling uptime-kuma ... done
+```
+
+### 3. Recrear Contenedor
+
+```bash
+docker compose up -d uptime-kuma
+```
+
+Docker Compose:
+- Detiene contenedor actual
+- Crea nuevo contenedor con imagen actualizada
+- Mantiene volumen de datos (no se pierde nada)
+
+### 4. Verificar
+
+```bash
+# Ver logs
+docker compose logs -f uptime-kuma
+
+# Verificar versión
+docker compose exec uptime-kuma cat /app/package.json | grep version
+```
+
+**Logs esperados**:
+```
+✅ Server is ready
+Listening on http://0.0.0.0:3001
+```
+
+### 5. Probar Acceso
+
+1. Navegar a `https://uptime.example.com`
+2. Login
+3. Verificar que monitores funcionan
+4. Verificar notificaciones activas
+
+---
+
+## Actualización Automática (Watchtower)
+
+Watchtower monitoriza cambios en imágenes Docker y actualiza contenedores automáticamente.
+
+### Configuración
+
+**Añadir a docker-compose.yml**:
+
+```yaml
+services:
+  uptime-kuma:
+    # ... configuración existente ...
+  
+  watchtower:
+    image: containrrr/watchtower:latest
+    container_name: watchtower-uptime-kuma
+    restart: unless-stopped
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - WATCHTOWER_CLEANUP=true  # Eliminar imágenes antiguas
+      - WATCHTOWER_INCLUDE_STOPPED=false
+      - WATCHTOWER_MONITOR_ONLY=false
+      - WATCHTOWER_SCHEDULE=0 0 4 * * *  # 4 AM diario
+      - WATCHTOWER_NOTIFICATIONS=email
+      - WATCHTOWER_NOTIFICATION_EMAIL_FROM=watchtower@example.com
+      - WATCHTOWER_NOTIFICATION_EMAIL_TO=admin@example.com
+      - WATCHTOWER_NOTIFICATION_EMAIL_SERVER=smtp.gmail.com
+      - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT=587
+      - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_USER=tu_email@gmail.com
+      - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD=app_password
+    command: uptime-kuma  # Solo monitorizar uptime-kuma
+```
+
+**Desplegar**:
+```bash
+docker compose up -d watchtower
+```
+
+### Horario de Actualización
+
+Formato cron: `segundos minutos horas día_mes mes día_semana`
+
+**Ejemplos**:
+```yaml
+# Diario a las 4 AM
+WATCHTOWER_SCHEDULE=0 0 4 * * *
+
+# Cada lunes a las 3 AM
+WATCHTOWER_SCHEDULE=0 0 3 * * MON
+
+# Cada 12 horas
+WATCHTOWER_SCHEDULE=0 0 */12 * * *
+```
+
+---
+
+## Rollback (Volver a Versión Anterior)
+
+Si actualización causa problemas:
+
+### Opción 1: Restaurar desde Backup
+
+```bash
+# Detener
+docker compose stop uptime-kuma
+
+# Restaurar base de datos
+docker compose cp ./backup/kuma-pre-update.db uptime-kuma:/app/data/kuma.db
+
+# Reiniciar
+docker compose start uptime-kuma
+```
+
+### Opción 2: Usar Versión Específica
+
+**Editar docker-compose.yml**:
+```yaml
+services:
+  uptime-kuma:
+    image: louislam/uptime-kuma:1.23.11  # Versión específica anterior
+```
+
+**Desplegar**:
+```bash
+docker compose pull
+docker compose up -d uptime-kuma
+```
+
+---
+
+## Actualización a Nueva Versión Mayor (v1 → v2)
+
+⚠️ **Importante**: Actualizaciones mayores pueden tener cambios incompatibles.
+
+### Antes de Actualizar
+
+1. **Leer Changelog**: [GitHub Releases](https://github.com/louislam/uptime-kuma/releases)
+2. **Backup completo**
+3. **Probar en entorno de desarrollo** primero
+
+### Proceso
+
+```bash
+# Backup
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".backup /tmp/kuma-v1.db"
+docker compose cp uptime-kuma:/tmp/kuma-v1.db ./backup/
+
+# Cambiar a v2
+nano docker-compose.yml
+# image: louislam/uptime-kuma:2
+
+# Actualizar
+docker compose pull
+docker compose up -d uptime-kuma
+
+# Verificar logs para errores de migración
+docker compose logs -f uptime-kuma
+```
+
+---
+
+## Verificación Post-Actualización
+
+### Checklist
+
+- ✅ Uptime Kuma inicia sin errores
+- ✅ Login funciona
+- ✅ Monitores siguen activos
+- ✅ Notificaciones funcionan (enviar test)
+- ✅ Status Pages accesibles
+- ✅ WebSockets funcionan (actualización en tiempo real)
+
+### Verificar Base de Datos
+
+```bash
+# Integridad
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db "PRAGMA integrity_check;"
+
+# Debe devolver: ok
+```
+
+### Verificar Versión
+
+```bash
+# Desde Docker
+docker compose exec uptime-kuma cat /app/package.json | grep version
+
+# O desde UI
+# Settings → About → Version
+```
+
+---
+
+## Problemas Comunes
+
+### Base de datos corrupta tras actualización
+
+**Síntoma**: Error al iniciar, monitores desaparecen.
+
+**Solución**:
+```bash
+# Restaurar desde backup
+docker compose stop uptime-kuma
+docker compose cp ./backup/kuma-pre-update.db uptime-kuma:/app/data/kuma.db
+docker compose start uptime-kuma
+```
+
+### Contenedor no inicia tras actualización
+
+**Ver logs**:
+```bash
+docker compose logs uptime-kuma
+```
+
+**Errores comunes**:
+- `EACCES: permission denied` → Permisos del volumen
+  ```bash
+  docker compose exec uptime-kuma chown -R 1000:1000 /app/data
+  ```
+- `Database locked` → Asegurar que no hay múltiples contenedores
+  ```bash
+  docker ps -a | grep uptime-kuma
+  docker rm -f <container_id_antiguo>
+  ```
+
+### Monitores se marcan como "down" tras actualización
+
+**Causa**: Cambio en lógica de checks (raro).
+
+**Solución**:
+1. Editar monitor problemático
+2. Click en **Test**
+3. Ajustar configuración si necesario
+4. **Save**
+
+---
+
+## Notificaciones de Actualización
+
+Uptime Kuma **NO notifica** automáticamente cuando hay actualizaciones.
+
+**Alternativas**:
+
+### 1. Watchtower con Notificaciones
+
+(Ver sección Actualización Automática)
+
+### 2. Monitorizar GitHub Releases
+
+Usar servicio como:
+- [Newreleases.io](https://newreleases.io/) - Notificaciones de releases GitHub
+- [RSS Feed](https://github.com/louislam/uptime-kuma/releases.atom) - Suscribirse con lector RSS
+
+### 3. Docker Hub Webhooks
+
+Configurar webhook en Docker Hub que envíe notificación cuando `louislam/uptime-kuma:1` se actualiza.
+
+---
+
+## Estrategia Recomendada
+
+**Producción**:
+- Tag: `1` (actualizaciones automáticas de parches/minor)
+- Watchtower: Deshabilitado (actualizaciones manuales programadas)
+- Backup: Automático diario
+- Testing: Probar actualizaciones en entorno dev primero
+
+**Desarrollo/Testing**:
+- Tag: `latest`
+- Watchtower: Habilitado
+- Backup: Antes de actualización manual
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Solución de Problemas](Solución-de-Problemas)** para resolver errores comunes.

Backup-y-Restauración.md

@@ -0,0 +1,302 @@
+# Backup y Restauración
+
+Uptime Kuma usa **SQLite** embebida. Todos los datos están en un solo archivo: `kuma.db`.
+
+---
+
+## Backup Manual
+
+### Método 1: Copia Directa
+
+**Detener contenedor primero** (evitar corrupción):
+
+```bash
+# Detener
+docker compose stop uptime-kuma
+
+# Copiar base de datos
+docker compose cp uptime-kuma:/app/data/kuma.db ./backup/kuma-$(date +%Y%m%d).db
+
+# Reiniciar
+docker compose start uptime-kuma
+```
+
+### Método 2: Backup en Caliente (Recomendado)
+
+Usar comando SQLite `.backup` sin detener servicio:
+
+```bash
+# Backup sin detener contenedor
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".backup /app/data/kuma-backup.db"
+
+# Copiar al host
+docker compose cp uptime-kuma:/app/data/kuma-backup.db ./backup/kuma-$(date +%Y%m%d).db
+
+# Limpiar backup temporal
+docker compose exec uptime-kuma rm /app/data/kuma-backup.db
+```
+
+---
+
+## Backup Automático
+
+### Script Bash
+
+**Crear script** `/usr/local/bin/backup-uptime-kuma.sh`:
+
+```bash
+#!/bin/bash
+
+BACKUP_DIR="/backups/uptime-kuma"
+RETENTION_DAYS=30
+COMPOSE_FILE="/path/to/uptime-kuma/docker-compose.yml"
+
+mkdir -p $BACKUP_DIR
+
+# Backup en caliente
+docker compose -f $COMPOSE_FILE exec -T uptime-kuma \
+  sqlite3 /app/data/kuma.db ".backup /app/data/kuma-backup.db"
+
+# Copiar al host
+docker compose -f $COMPOSE_FILE cp \
+  uptime-kuma:/app/data/kuma-backup.db \
+  $BACKUP_DIR/kuma-$(date +%Y%m%d-%H%M%S).db
+
+# Limpiar temporal
+docker compose -f $COMPOSE_FILE exec -T uptime-kuma \
+  rm /app/data/kuma-backup.db
+
+# Limpiar backups antiguos
+find $BACKUP_DIR -name "kuma-*.db" -mtime +$RETENTION_DAYS -delete
+
+echo "✅ Backup completado: $(date)"
+```
+
+**Permisos**:
+```bash
+chmod +x /usr/local/bin/backup-uptime-kuma.sh
+```
+
+### Cron (Diario a las 2 AM)
+
+```bash
+crontab -e
+```
+
+**Añadir**:
+```cron
+0 2 * * * /usr/local/bin/backup-uptime-kuma.sh >> /var/log/backup-uptime-kuma.log 2>&1
+```
+
+### PowerShell (Windows con Docker Desktop)
+
+**Script** `C:\Scripts\Backup-UptimeKuma.ps1`:
+
+```powershell
+$BackupDir = "C:\Backups\UptimeKuma"
+$RetentionDays = 30
+$ComposeDir = "C:\Users\...\repos\uptime-kuma"
+
+# Crear directorio si no existe
+if (-not (Test-Path $BackupDir)) {
+    New-Item -ItemType Directory -Path $BackupDir
+}
+
+# Backup
+Set-Location $ComposeDir
+docker compose exec -T uptime-kuma sqlite3 /app/data/kuma.db ".backup /app/data/kuma-backup.db"
+
+$Timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
+docker compose cp uptime-kuma:/app/data/kuma-backup.db "$BackupDir\kuma-$Timestamp.db"
+
+docker compose exec -T uptime-kuma rm /app/data/kuma-backup.db
+
+# Limpiar backups antiguos
+Get-ChildItem $BackupDir -Filter "kuma-*.db" | 
+    Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-$RetentionDays) } | 
+    Remove-Item
+
+Write-Host "✅ Backup completado: $(Get-Date)"
+```
+
+**Tarea programada** (Task Scheduler):
+```powershell
+$Action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\Backup-UptimeKuma.ps1"
+$Trigger = New-ScheduledTaskTrigger -Daily -At 2:00AM
+$Principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
+Register-ScheduledTask -TaskName "Backup Uptime Kuma" -Action $Action -Trigger $Trigger -Principal $Principal
+```
+
+---
+
+## Backup a Cloud
+
+### Rclone (S3, Google Drive, OneDrive, etc.)
+
+**Instalar rclone**:
+```bash
+curl https://rclone.org/install.sh | sudo bash
+```
+
+**Configurar remoto**:
+```bash
+rclone config
+# Seguir wizard para configurar S3/GDrive/etc
+```
+
+**Script de backup a S3**:
+```bash
+#!/bin/bash
+
+BACKUP_FILE="/tmp/kuma-$(date +%Y%m%d).db"
+RCLONE_REMOTE="s3:mi-bucket/uptime-kuma"
+
+# Backup local
+docker compose -f /path/to/docker-compose.yml exec -T uptime-kuma \
+  sqlite3 /app/data/kuma.db ".backup $BACKUP_FILE"
+
+# Subir a S3
+rclone copy $BACKUP_FILE $RCLONE_REMOTE
+
+# Limpiar
+rm $BACKUP_FILE
+
+echo "✅ Backup subido a S3"
+```
+
+---
+
+## Restauración
+
+### Restaurar desde Backup
+
+```bash
+# 1. Detener contenedor
+docker compose stop uptime-kuma
+
+# 2. Restaurar archivo
+docker compose cp ./backup/kuma-20241205.db uptime-kuma:/app/data/kuma.db
+
+# 3. Verificar permisos (si es necesario)
+docker compose run --rm uptime-kuma chown 1000:1000 /app/data/kuma.db
+
+# 4. Reiniciar
+docker compose start uptime-kuma
+
+# 5. Verificar logs
+docker compose logs -f uptime-kuma
+```
+
+### Restaurar en Nuevo Servidor
+
+```bash
+# 1. Clonar repositorio
+git clone https://git.ictiberia.com/groales/uptime-kuma.git
+cd uptime-kuma
+
+# 2. Configurar
+cp docker-compose.override.traefik.yml.example docker-compose.override.yml
+cp .env.example .env
+nano .env
+
+# 3. Iniciar primera vez (crear volumen)
+docker compose up -d
+
+# 4. Detener
+docker compose stop
+
+# 5. Restaurar backup
+docker compose cp /path/to/kuma-backup.db uptime-kuma:/app/data/kuma.db
+
+# 6. Reiniciar
+docker compose start uptime-kuma
+```
+
+---
+
+## Verificar Integridad
+
+### Verificar base de datos SQLite
+
+```bash
+# Verificar integridad
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db "PRAGMA integrity_check;"
+
+# Debe mostrar: ok
+```
+
+### Reparar base de datos corrupta
+
+Si hay corrupción:
+
+```bash
+# Intentar reparar
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".recover"
+
+# Si falla, restaurar desde backup
+docker compose stop uptime-kuma
+docker compose cp ./backup/kuma-latest.db uptime-kuma:/app/data/kuma.db
+docker compose start uptime-kuma
+```
+
+---
+
+## Migración a Nuevo Servidor
+
+### Exportar Datos
+
+En servidor antiguo:
+
+```bash
+# Backup
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".backup /tmp/kuma-migration.db"
+docker compose cp uptime-kuma:/tmp/kuma-migration.db ./kuma-migration.db
+
+# Transferir a nuevo servidor (ejemplo: SCP)
+scp kuma-migration.db user@new-server:/tmp/
+```
+
+### Importar Datos
+
+En servidor nuevo:
+
+```bash
+# Desplegar Uptime Kuma
+git clone https://git.ictiberia.com/groales/uptime-kuma.git
+cd uptime-kuma
+cp docker-compose.override.traefik.yml.example docker-compose.override.yml
+cp .env.example .env
+nano .env  # Configurar DOMAIN_HOST
+
+# Iniciar primera vez
+docker compose up -d
+
+# Detener y restaurar
+docker compose stop
+docker compose cp /tmp/kuma-migration.db uptime-kuma:/app/data/kuma.db
+docker compose start uptime-kuma
+```
+
+---
+
+## ¿Qué se Respalda?
+
+El archivo `kuma.db` contiene **todo**:
+- ✅ Usuarios y contraseñas
+- ✅ Configuración 2FA
+- ✅ Monitores y configuración
+- ✅ Notificaciones
+- ✅ Status Pages
+- ✅ Historial de uptime (según retención configurada)
+- ✅ Incidentes
+- ✅ Tags y grupos
+
+**NO incluye**:
+- ❌ Configuración de Traefik/NPM (están en docker-compose.yml y .env)
+- ❌ Logs de Docker (usar `docker compose logs > logs.txt` si necesario)
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Actualización](Actualización)** para mantener Uptime Kuma al día.

Configuración-Inicial.md

@@ -0,0 +1,223 @@
+# Configuración Inicial
+
+Esta guía cubre la configuración inicial de Uptime Kuma después del primer despliegue.
+
+---
+
+## 1. Crear Cuenta Administrador
+
+Al acceder por primera vez a `https://uptime.example.com`, verás la pantalla de creación de cuenta.
+
+⚠️ **IMPORTANTE**: No hay usuario por defecto. El **primer usuario que crees será administrador**.
+
+### Pasos
+
+1. **Username**: Nombre de usuario para login (ejemplo: `admin`, `tu_usuario`)
+2. **Password**: Contraseña segura (mínimo 6 caracteres, recomendado: 16+ con símbolos)
+3. Click en **Create**
+
+**Acceso posterior**:
+- URL: `https://uptime.example.com`
+- Usuario: El username que creaste
+- Password: La contraseña que creaste
+
+---
+
+## 2. Configurar Idioma
+
+Por defecto, Uptime Kuma está en inglés. Cambiarlo a español:
+
+1. Click en el icono de **perfil** (esquina superior derecha)
+2. **Settings** → **Appearance**
+3. **Language**: Selecciona **Español** (o tu idioma preferido)
+4. La interfaz se recargará en español
+
+---
+
+## 3. Configurar Notificaciones
+
+Uptime Kuma soporta **90+ canales de notificación**. Configurar al menos uno es **altamente recomendado**.
+
+### Telegram (Recomendado)
+
+**Ventajas**: Gratuito, instantáneo, fácil configuración.
+
+#### Paso 1: Crear bot
+
+1. Abre Telegram y busca [@BotFather](https://t.me/botfather)
+2. Envía `/newbot`
+3. Elige nombre del bot (ejemplo: "Uptime Monitor")
+4. Elige username (ejemplo: `uptime_monitor_bot`)
+5. BotFather te dará un **bot token**:
+   ```
+   123456789:ABCdefGHIjklMNOpqrsTUVwxyz
+   ```
+   ⚠️ **Guardar** este token.
+
+#### Paso 2: Obtener Chat ID
+
+1. Busca [@userinfobot](https://t.me/userinfobot) en Telegram
+2. Envía `/start`
+3. El bot responderá con tu **Chat ID**:
+   ```
+   Id: 123456789
+   ```
+   Si es un **grupo**, el Chat ID comienza con `-` (ejemplo: `-987654321`).
+
+#### Paso 3: Configurar en Uptime Kuma
+
+1. **Settings** → **Notifications**
+2. Click en **Setup Notification**
+3. **Notification Type**: Telegram
+4. Configurar:
+   - **Friendly Name**: `Telegram Principal`
+   - **Bot Token**: Pegar el token de BotFather
+   - **Chat ID**: Pegar tu Chat ID (o del grupo)
+5. Click en **Test** → Deberías recibir mensaje en Telegram
+6. **Save**
+
+### Discord
+
+1. En Discord, ve al canal donde quieres recibir notificaciones
+2. **Configuración del canal** → **Integraciones** → **Webhooks**
+3. **Crear Webhook**
+4. Copiar **URL del Webhook**:
+   ```
+   https://discord.com/api/webhooks/123456789/abcdefg...
+   ```
+
+**En Uptime Kuma**:
+1. **Settings** → **Notifications** → **Setup Notification**
+2. **Notification Type**: Discord
+3. **Webhook URL**: Pegar URL
+4. **Test** → Deberías ver mensaje en Discord
+5. **Save**
+
+### Email (SMTP)
+
+**Ejemplo con Gmail**:
+
+1. **Settings** → **Notifications** → **Setup Notification**
+2. **Notification Type**: Email (SMTP)
+3. Configurar:
+   - **Friendly Name**: `Email Alerts`
+   - **Hostname**: `smtp.gmail.com`
+   - **Port**: `587`
+   - **Security**: `TLS`
+   - **Username**: `tu_email@gmail.com`
+   - **Password**: **App Password** (no contraseña de cuenta)
+   - **From Email**: `tu_email@gmail.com`
+   - **To Email**: `destino@example.com`
+
+4. **Test** → Verificar que llega email
+5. **Save**
+
+#### Generar App Password en Gmail
+
+1. Ve a [https://myaccount.google.com/security](https://myaccount.google.com/security)
+2. **2-Step Verification** debe estar habilitada
+3. **App passwords** → Generar nueva
+4. Selecciona **Mail** y dispositivo **Other**
+5. Copiar password generado (16 caracteres)
+6. Usar ese password en Uptime Kuma
+
+### Otros Canales
+
+Uptime Kuma soporta:
+- **Slack**: Requiere Incoming Webhook
+- **Microsoft Teams**: Requiere Incoming Webhook
+- **PagerDuty**: Para equipos de guardia 24/7
+- **Gotify**: Notificaciones push self-hosted
+- **Webhooks**: Integración personalizada (envía JSON a tu API)
+
+---
+
+## 4. Configurar 2FA (Autenticación de Dos Factores)
+
+⚠️ **Altamente recomendado** para seguridad.
+
+### Pasos
+
+1. **Settings** → **Security**
+2. **Two Factor Authentication** → **Setup**
+3. Escanear código QR con app:
+   - **Google Authenticator** (Android/iOS)
+   - **Authy** (Android/iOS/Desktop)
+   - **Microsoft Authenticator** (Android/iOS)
+4. Ingresar código de 6 dígitos generado por la app
+5. **Enable**
+
+**Próximo login**:
+- Ingresar usuario y password
+- Ingresar código 2FA de la app
+
+⚠️ **Guardar códigos de recuperación** en lugar seguro.
+
+---
+
+## 5. Configurar Zona Horaria
+
+Para que los logs y gráficos muestren hora correcta:
+
+1. **Settings** → **General**
+2. **Timezone**: Selecciona tu zona horaria (ejemplo: `Europe/Madrid`, `America/Mexico_City`)
+3. **Save**
+
+---
+
+## 6. Configurar Retención de Datos
+
+Uptime Kuma guarda historial de checks. Configurar cuánto tiempo mantener:
+
+1. **Settings** → **General**
+2. **Data Retention**:
+   - **Keep Data**: `180` días (6 meses recomendado)
+   - Si tienes muchos monitores: reducir a `90` o `60` días
+3. **Save**
+
+Base de datos SQLite crece con el tiempo. Retención baja = menor tamaño.
+
+---
+
+## 7. Agregar Usuarios Adicionales (Opcional)
+
+Si trabajas en equipo, puedes crear usuarios adicionales:
+
+1. **Settings** → **Users**
+2. Click en **Add User**
+3. Configurar:
+   - **Username**: Nombre de usuario
+   - **Password**: Contraseña temporal (el usuario la puede cambiar)
+   - **Role**: 
+     - **Admin**: Acceso completo
+     - **User**: Solo ver monitores (no editar configuración)
+4. **Save**
+
+El nuevo usuario puede:
+- Login en `https://uptime.example.com`
+- Cambiar su password en **Settings** → **Security**
+
+---
+
+## 8. Configurar Status Page (Opcional)
+
+Si quieres página pública para mostrar estado de servicios:
+
+Consulta **[Status Pages](Status-Pages)** para guía completa.
+
+---
+
+## Configuración Completa ✅
+
+Ya tienes Uptime Kuma configurada:
+- ✅ Cuenta administrador creada
+- ✅ Idioma configurado
+- ✅ Notificaciones configuradas
+- ✅ 2FA habilitada (recomendado)
+- ✅ Zona horaria correcta
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Monitorización](Monitorización)** para añadir tus primeros monitores.

Home.md

@@ -1 +1,108 @@
-¡Bienvenidos a la Wiki!
+# Wiki de Uptime Kuma
+
+¡Bienvenido a la documentación completa de **Uptime Kuma**! Esta wiki te guiará en la instalación, configuración y uso de tu sistema de monitorización self-hosted.
+
+---
+
+## 📋 Índice
+
+1. **[Home](Home)** - Esta página
+2. **[Despliegue con Traefik](Traefik)** - Configuración con Traefik como proxy inverso
+3. **[Despliegue con NPM](NPM)** - Configuración con Nginx Proxy Manager
+4. **[Configuración Inicial](Configuración-Inicial)** - Primer acceso, usuarios, notificaciones
+5. **[Monitorización](Monitorización)** - Añadir monitores (HTTP, TCP, Ping, DNS, Docker)
+6. **[Status Pages](Status-Pages)** - Crear páginas de estado públicas
+7. **[Backup y Restauración](Backup-y-Restauración)** - Proteger tus datos
+8. **[Actualización](Actualización)** - Mantener Uptime Kuma actualizada
+9. **[Solución de Problemas](Solución-de-Problemas)** - Resolver errores comunes
+
+---
+
+## 🚀 Quick Start
+
+### Despliegue rápido con CLI
+
+```bash
+# Clonar repositorio
+git clone https://git.ictiberia.com/groales/uptime-kuma.git
+cd uptime-kuma
+
+# Configurar Traefik
+cp docker-compose.override.traefik.yml.example docker-compose.override.yml
+cp .env.example .env
+nano .env  # Editar DOMAIN_HOST=uptime.example.com
+
+# Desplegar
+docker compose up -d
+
+# Ver logs
+docker compose logs -f uptime-kuma
+```
+
+**Acceso**: `https://uptime.example.com`
+
+---
+
+## 📦 ¿Qué es Uptime Kuma?
+
+Uptime Kuma es una herramienta de monitorización self-hosted moderna y elegante, alternativa a servicios como UptimeRobot o StatusCake.
+
+### Características principales
+
+- ✅ **Monitorización multi-protocolo**: HTTP(s), TCP, Ping, DNS, Docker, Steam Game Server, etc.
+- ✅ **90+ canales de notificación**: Telegram, Discord, Slack, Email, Gotify, PagerDuty, Webhooks, y más
+- ✅ **Status Pages públicas**: Comparte el estado de tus servicios con usuarios/clientes
+- ✅ **Mapeo de dependencias**: Visualiza relaciones entre servicios
+- ✅ **Monitorización de certificados SSL**: Alertas de expiración
+- ✅ **Multi-idioma**: Interfaz en español y otros idiomas
+- ✅ **2FA**: Autenticación de dos factores
+- ✅ **Sin base de datos externa**: SQLite embebida (sin PostgreSQL/MySQL necesarios)
+
+---
+
+## 🏗️ Arquitectura del Stack
+
+```
+┌─────────────────────────────────────────────────┐
+│  Internet                                       │
+│  (https://uptime.example.com)                   │
+└────────────────┬────────────────────────────────┘
+                 │
+        ┌────────▼─────────┐
+        │  Traefik / NPM   │  ← Proxy inverso con SSL
+        │  (Puerto 443)    │
+        └────────┬─────────┘
+                 │
+        ┌────────▼─────────┐
+        │  Uptime Kuma     │  ← Aplicación
+        │  (Puerto 3001)   │
+        └────────┬─────────┘
+                 │
+        ┌────────▼─────────┐
+        │  SQLite          │  ← Base de datos embebida
+        │  (kuma.db)       │
+        └──────────────────┘
+```
+
+**Componentes**:
+- **Uptime Kuma**: Aplicación principal (imagen `louislam/uptime-kuma:1`)
+- **SQLite**: Base de datos embebida en `/app/data/kuma.db`
+- **Traefik/NPM**: Proxy inverso para SSL y acceso público
+
+---
+
+## 📚 Próximos Pasos
+
+1. **Nuevo usuario**: Comienza con **[Configuración Inicial](Configuración-Inicial)**
+2. **Añadir monitorización**: Ve a **[Monitorización](Monitorización)**
+3. **Crear status page pública**: Consulta **[Status Pages](Status-Pages)**
+4. **Problemas**: Revisa **[Solución de Problemas](Solución-de-Problemas)**
+
+---
+
+## 🔗 Enlaces Útiles
+
+- 📖 [Repositorio principal](https://git.ictiberia.com/groales/uptime-kuma)
+- 🐙 [Uptime Kuma GitHub](https://github.com/louislam/uptime-kuma)
+- 💬 [Comunidad Discord](https://discord.gg/uptime-kuma)
+- 🐳 [Docker Hub](https://hub.docker.com/r/louislam/uptime-kuma)

Monitorización.md

@@ -0,0 +1,316 @@
+# Monitorización
+
+Guía completa para añadir diferentes tipos de monitores en Uptime Kuma.
+
+---
+
+## Conceptos Básicos
+
+**Monitor**: Configuración que verifica disponibilidad/rendimiento de un servicio.
+
+**Tipos soportados**:
+- HTTP(s) / HTTP(s) Keyword / HTTP(s) Json Query
+- TCP Port
+- Ping / ICMP
+- DNS
+- Docker Container
+- MongoDB / PostgreSQL / MySQL / Redis
+- MQTT / gRPC / WebSocket
+- Steam Game Server
+
+---
+
+## Monitor HTTP(s)
+
+Para monitorizar sitios web, APIs REST, etc.
+
+### Configuración Básica
+
+1. Click en **Add New Monitor**
+2. **Monitor Type**: HTTP(s)
+3. Configurar:
+   - **Friendly Name**: `Web Producción`
+   - **URL**: `https://example.com`
+   - **Heartbeat Interval**: `60` segundos
+   - **Retries**: `3`
+4. **Notifications**: Seleccionar canales configurados
+5. **Save**
+
+### Opciones Avanzadas
+
+**Method**: 
+- `GET`: Por defecto, verificar página
+- `POST`: Enviar datos (APIs)
+- `HEAD`: Solo headers (más rápido)
+
+**Expected Status Code**: `200-299` (éxito), `200,301,302` (específicos)
+
+**Request Headers**: JSON personalizado
+```json
+{
+  "Authorization": "Bearer token123",
+  "User-Agent": "UptimeKuma/1.0"
+}
+```
+
+**Request Body**: Para métodos POST/PUT (JSON/XML)
+
+**Timeout**: `48` segundos por defecto (aumentar si respuesta lenta)
+
+### Monitor HTTP(s) Keyword
+
+Verificar que la página contenga texto específico.
+
+**Uso**: Detectar páginas de error que devuelven 200 OK.
+
+**Configuración**:
+1. **Monitor Type**: HTTP(s) Keyword
+2. **Keyword**: `Login successful` (texto que DEBE aparecer)
+3. Si no encuentra el keyword → marca como **down**
+
+### Monitor HTTP(s) Json Query
+
+Verificar respuesta JSON de API.
+
+**Ejemplo**: API que devuelve `{"status": "healthy"}`
+
+**Configuración**:
+1. **Monitor Type**: HTTP(s) Json Query
+2. **Json Query**: `$.status`
+3. **Expected Value**: `healthy`
+4. Si no coincide → marca como **down**
+
+---
+
+## Monitor TCP Port
+
+Para monitorizar puertos abiertos (SSH, bases de datos, etc.).
+
+### Ejemplos
+
+**SSH Server**:
+```
+Monitor Type: TCP Port
+Hostname: 192.168.1.100
+Port: 22
+Heartbeat Interval: 60
+```
+
+**Base de datos PostgreSQL**:
+```
+Monitor Type: TCP Port
+Hostname: db.example.com
+Port: 5432
+Heartbeat Interval: 120
+```
+
+**Redis**:
+```
+Monitor Type: TCP Port
+Hostname: redis
+Port: 6379
+```
+
+---
+
+## Monitor Ping
+
+Verificar disponibilidad de red con ICMP ping.
+
+### Configuración
+
+```
+Monitor Type: Ping
+Hostname: 192.168.1.1
+Heartbeat Interval: 60
+```
+
+**Uso**:
+- Routers / Switches
+- Servidores sin servicios HTTP
+- Verificar conectividad básica
+
+⚠️ **Nota**: Algunos hosts bloquean ICMP → usar TCP Port en su lugar.
+
+---
+
+## Monitor DNS
+
+Verificar resolución DNS correcta.
+
+### Configuración
+
+```
+Monitor Type: DNS
+Hostname: example.com
+Resolver Server: 1.1.1.1
+Resource Record Type: A
+Expected Answer: 93.184.216.34
+```
+
+**Tipos de registro**:
+- `A`: IPv4
+- `AAAA`: IPv6
+- `MX`: Mail servers
+- `TXT`: Registros de texto (SPF, DMARC)
+- `CNAME`: Alias
+
+**Uso**:
+- Monitorizar registros DNS críticos
+- Detectar hijacking de DNS
+- Verificar propagación de cambios
+
+---
+
+## Monitor Docker Container
+
+Monitorizar estado de contenedores Docker.
+
+### Requisitos
+
+Uptime Kuma necesita acceso al socket Docker:
+
+**Editar docker-compose.yml**:
+```yaml
+services:
+  uptime-kuma:
+    volumes:
+      - uptime-kuma_data:/app/data
+      - /var/run/docker.sock:/var/run/docker.sock:ro  # ← Añadir esta línea
+```
+
+**Recrear contenedor**:
+```bash
+docker compose up -d uptime-kuma
+```
+
+### Configuración
+
+```
+Monitor Type: Docker Container
+Docker Daemon: unix:///var/run/docker.sock
+Container Name: netbox
+Heartbeat Interval: 60
+```
+
+**Uso**:
+- Detectar contenedores que se reinician constantemente
+- Verificar que servicios críticos siguen activos
+
+---
+
+## Monitor de Base de Datos
+
+### PostgreSQL
+
+```
+Monitor Type: PostgreSQL
+Connection String: postgres://user:password@host:5432/dbname
+Query: SELECT 1
+Expected Result: 1
+```
+
+### MySQL/MariaDB
+
+```
+Monitor Type: MySQL/MariaDB
+Hostname: db.example.com
+Port: 3306
+Username: monitor
+Password: ********
+Database: mysql
+Query: SELECT 1
+```
+
+### MongoDB
+
+```
+Monitor Type: MongoDB
+Connection String: mongodb://user:password@host:27017/admin
+```
+
+### Redis
+
+```
+Monitor Type: Redis
+Connection String: redis://host:6379
+```
+
+---
+
+## Configuración de Monitores
+
+### Heartbeat Interval
+
+Frecuencia de checks:
+- **30s**: Servicios críticos (producción)
+- **60s**: Servicios normales (recomendado)
+- **120s-300s**: Servicios menos críticos
+
+⚠️ Muchos monitores con interval bajo → alta carga CPU/red.
+
+### Retries
+
+Reintentos antes de marcar como **down**:
+- **1**: Servicios estables (pocos falsos positivos)
+- **3**: Recomendado (balancea detección rápida vs falsos positivos)
+- **5**: Redes inestables
+
+### Tags
+
+Organizar monitores por categorías:
+
+1. **Settings** → **Tags**
+2. Crear tags: `producción`, `desarrollo`, `crítico`, `base-datos`
+3. Al crear monitor, asignar tags
+
+**Filtrado**: Click en tag para ver solo esos monitores.
+
+### Grupos
+
+Agrupar monitores relacionados:
+
+1. Click en **New Group**
+2. Nombre: `Aplicaciones Web`, `Infraestructura`
+3. Arrastrar monitores al grupo
+
+---
+
+## Umbrales y Alertas
+
+### Certificados SSL
+
+Uptime Kuma monitoriza expiración de certificados **automáticamente** en monitores HTTPS.
+
+**Configurar alerta**:
+1. Editar monitor HTTPS
+2. **SSL Certificate Expiry Notification**: `7` días (alerta 7 días antes)
+
+### Tiempo de Respuesta
+
+**Response Time**: Uptime Kuma mide automáticamente.
+
+No hay alertas nativas por tiempo de respuesta lento, pero se ve en gráficos.
+
+---
+
+## Verificación y Testing
+
+### Probar Monitor
+
+Antes de guardar:
+1. Configurar monitor
+2. Click en **Test** (esquina inferior)
+3. Ver resultado: ✅ Up / ❌ Down
+
+### Forzar Check Manual
+
+1. Ir al dashboard
+2. Click en monitor
+3. Click en **Check Now**
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Status Pages](Status-Pages)** para crear páginas públicas de estado.

NPM.md

@@ -0,0 +1,254 @@
+# Despliegue con Nginx Proxy Manager (NPM)
+
+Esta guía explica cómo desplegar Uptime Kuma usando **Nginx Proxy Manager** como proxy inverso.
+
+---
+
+## Requisitos Previos
+
+- ✅ Nginx Proxy Manager desplegado y funcionando
+- ✅ Red Docker `proxy` donde ambos servicios se conectan
+- ✅ DNS configurado apuntando a tu servidor (ejemplo: `uptime.example.com`)
+- ✅ Puertos 80 y 443 accesibles desde Internet
+
+---
+
+## Configuración
+
+### 1. Desplegar Uptime Kuma
+
+```bash
+cd uptime-kuma
+docker compose up -d
+```
+
+⚠️ **No requiere** archivo `.env` ni `docker-compose.override.yml` para NPM.
+
+### 2. Verificar contenedor
+
+```bash
+# Verificar que el contenedor está activo
+docker compose ps
+
+# Verificar que está en la red proxy
+docker network inspect proxy | grep uptime-kuma
+```
+
+### 3. Configurar Proxy Host en NPM
+
+1. Accede a Nginx Proxy Manager (ejemplo: `https://npm.example.com`)
+2. Ve a **Hosts** → **Proxy Hosts**
+3. Click en **Add Proxy Host**
+
+#### Tab: Details
+
+- **Domain Names**: `uptime.example.com`
+- **Scheme**: `http` (⚠️ importante: **http**, no https)
+- **Forward Hostname / IP**: `uptime-kuma` (nombre del contenedor)
+- **Forward Port**: `3001`
+- ✅ **Block Common Exploits**
+- ✅ **Websockets Support** (⚠️ **CRÍTICO**: Uptime Kuma requiere WebSockets)
+
+#### Tab: SSL
+
+- **SSL Certificate**: Selecciona **Request a new SSL Certificate**
+- **Email**: Tu email (para Let's Encrypt)
+- ✅ **Force SSL** (redirigir HTTP → HTTPS)
+- ✅ **HTTP/2 Support**
+- ✅ **HSTS Enabled**
+- ✅ **I Agree to the Let's Encrypt Terms of Service**
+
+4. Click en **Save**
+
+### 4. Verificar acceso
+
+Navega a: **https://uptime.example.com**
+
+En el primer acceso, Uptime Kuma te pedirá crear una cuenta de administrador.
+
+---
+
+## Configuración NPM - Detalles
+
+### Forward Port: 3001
+
+⚠️ **Importante**: Uptime Kuma escucha en puerto **3001**, no 80.
+
+Si configuras puerto `80`, obtendrás error **502 Bad Gateway**.
+
+### WebSockets Support
+
+Uptime Kuma **requiere WebSockets** para:
+- Actualizar monitores en tiempo real
+- Notificaciones push en UI
+- Sincronización de estado
+
+**DEBE** estar habilitado en NPM:
+```
+✅ Websockets Support
+```
+
+Si no está habilitado:
+- La interfaz no se actualizará en tiempo real
+- Verás errores en consola del navegador (F12):
+  ```
+  WebSocket connection failed
+  ```
+
+### Scheme: http
+
+Aunque Uptime Kuma se accede por HTTPS desde Internet, la comunicación **interna** entre NPM y Uptime Kuma es **HTTP**.
+
+NPM maneja la terminación SSL:
+```
+Internet (HTTPS) → NPM (termina SSL) → Uptime Kuma (HTTP interno)
+```
+
+---
+
+## Solución de Problemas
+
+### Error 502 Bad Gateway
+
+**Causa**: Puerto incorrecto o contenedor no accesible.
+
+**Verificar**:
+```bash
+# ¿El contenedor está activo?
+docker compose ps
+
+# ¿Está en la red proxy?
+docker network inspect proxy | grep uptime-kuma
+
+# ¿Puerto correcto en NPM?
+# Debe ser 3001, NO 80
+```
+
+**Solución**:
+1. Editar Proxy Host en NPM
+2. Cambiar **Forward Port** a `3001`
+3. **Save**
+
+### Certificado SSL no se genera
+
+**Causa**: DNS no apunta al servidor o puertos bloqueados.
+
+**Verificar DNS**:
+```bash
+nslookup uptime.example.com
+# Debe devolver la IP de tu servidor NPM
+```
+
+**Verificar puertos**:
+```bash
+# En el host
+ss -tlnp | grep :80
+ss -tlnp | grep :443
+```
+
+**Solución**:
+- Verificar DNS en registrar
+- Verificar firewall permite 80 y 443
+- Revisar logs de NPM
+
+### Uptime Kuma no actualiza en tiempo real
+
+**Causa**: WebSockets no habilitado en NPM.
+
+**Verificar** (consola del navegador F12):
+```
+WebSocket connection to 'wss://uptime.example.com/socket.io/...' failed
+```
+
+**Solución**:
+1. Editar Proxy Host en NPM
+2. ✅ **Websockets Support**
+3. **Save**
+4. Limpiar cache del navegador (Ctrl+F5)
+
+### Error "Unable to connect to the database"
+
+**Causa**: Base de datos SQLite no se creó o tiene permisos incorrectos.
+
+**Verificar**:
+```bash
+# Ver archivos en volumen
+docker compose exec uptime-kuma ls -lh /app/data/
+
+# Debe mostrar kuma.db
+```
+
+**Solución**:
+```bash
+# Recrear contenedor
+docker compose down
+docker compose up -d
+
+# Verificar logs
+docker compose logs -f uptime-kuma
+```
+
+---
+
+## Configuración Avanzada
+
+### Múltiples dominios
+
+En NPM, añade dominios separados por coma en **Domain Names**:
+```
+uptime.example.com, status.example.com
+```
+
+### Restringir acceso por IP
+
+NPM no tiene IP whitelist nativo en UI. Usar **Custom Nginx Configuration**:
+
+1. Editar Proxy Host
+2. Tab **Advanced**
+3. **Custom Nginx Configuration**:
+   ```nginx
+   allow 192.168.1.0/24;
+   allow 10.0.0.0/8;
+   deny all;
+   ```
+
+### Autenticación básica (antes de login de Uptime Kuma)
+
+NPM no tiene auth básica en UI. Usar **Custom Nginx Configuration**:
+
+```nginx
+auth_basic "Restricted";
+auth_basic_user_file /data/nginx/.htpasswd;
+```
+
+Crear archivo `/data/nginx/.htpasswd` en contenedor NPM:
+```bash
+docker exec -it npm bash
+apt update && apt install apache2-utils -y
+htpasswd -c /data/nginx/.htpasswd admin
+# Ingresar contraseña
+```
+
+---
+
+## Comparación: NPM vs Traefik
+
+| Característica | NPM | Traefik |
+|---|---|---|
+| **Configuración** | Interfaz web (fácil) | Archivo `.env` (medio) |
+| **SSL** | Manual (1 click) | Automático |
+| **WebSockets** | Requiere checkbox | Automático |
+| **Renovación SSL** | Automática | Automática |
+| **IP Whitelist** | Custom config | Middleware nativo |
+| **Auth Básica** | Custom config | Middleware nativo |
+| **Complejidad** | Baja | Media |
+
+**Recomendación**:
+- **NPM**: Si prefieres UI gráfica y configuración rápida
+- **Traefik**: Si quieres Infrastructure as Code y automatización total
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Configuración Inicial](Configuración-Inicial)** para crear tu cuenta administrador y configurar notificaciones.

Solución-de-Problemas.md

@@ -0,0 +1,420 @@
+# Solución de Problemas
+
+Guía para resolver problemas comunes en Uptime Kuma.
+
+---
+
+## Contenedor no Inicia
+
+### Verificar Logs
+
+```bash
+docker compose logs uptime-kuma
+```
+
+### Error: "EACCES: permission denied"
+
+**Causa**: Permisos incorrectos en volumen.
+
+**Solución**:
+```bash
+# Opción 1: Cambiar permisos desde host
+sudo chown -R 1000:1000 /var/lib/docker/volumes/uptime-kuma_data
+
+# Opción 2: Desde contenedor
+docker compose run --rm uptime-kuma chown -R 1000:1000 /app/data
+```
+
+### Error: "Database locked"
+
+**Causa**: Múltiples contenedores intentando acceder a kuma.db.
+
+**Solución**:
+```bash
+# Listar todos los contenedores uptime-kuma
+docker ps -a | grep uptime-kuma
+
+# Detener todos
+docker stop $(docker ps -a -q --filter name=uptime-kuma)
+
+# Eliminar duplicados
+docker rm $(docker ps -a -q --filter name=uptime-kuma)
+
+# Reiniciar limpio
+docker compose up -d uptime-kuma
+```
+
+### Error: "Cannot find module..."
+
+**Causa**: Imagen corrupta o actualización fallida.
+
+**Solución**:
+```bash
+# Eliminar imagen y volver a descargar
+docker compose down
+docker rmi louislam/uptime-kuma:1
+docker compose pull
+docker compose up -d
+```
+
+---
+
+## No se Puede Acceder a la Interfaz
+
+### Error 502 Bad Gateway (Traefik)
+
+**Verificar contenedor activo**:
+```bash
+docker compose ps
+# Debe mostrar: Up
+```
+
+**Verificar red proxy**:
+```bash
+docker network inspect proxy | grep uptime-kuma
+# Debe aparecer el contenedor
+```
+
+**Verificar labels de Traefik**:
+```bash
+docker inspect uptime-kuma | grep -A 10 Labels
+# Verificar:
+# - traefik.enable=true
+# - loadbalancer.server.port=3001
+# - rule=Host(`...`)
+```
+
+**Verificar logs de Traefik**:
+```bash
+docker logs traefik | grep uptime-kuma
+```
+
+### Error 502 Bad Gateway (NPM)
+
+**Verificar Forward Port**: Debe ser `3001`, no `80`.
+
+**Verificar hostname**: Debe ser `uptime-kuma` (nombre del contenedor).
+
+**Verificar red**: Ambos contenedores deben estar en red `proxy`.
+
+```bash
+docker network inspect proxy | grep -E "uptime-kuma|nginx-proxy-manager"
+```
+
+### Certificado SSL no se Genera
+
+**Verificar DNS**:
+```bash
+nslookup uptime.example.com
+# Debe devolver la IP de tu servidor
+```
+
+**Verificar puertos abiertos**:
+```bash
+# En el host
+ss -tlnp | grep :80
+ss -tlnp | grep :443
+```
+
+**Verificar logs de Let's Encrypt** (Traefik):
+```bash
+docker logs traefik 2>&1 | grep -i "letsencrypt\|acme"
+```
+
+---
+
+## Monitores Reportan "Down" Incorrectamente
+
+### Falsos Positivos
+
+**Ajustar configuración**:
+1. Editar monitor
+2. Aumentar **Retries**: de 3 a 5
+3. Aumentar **Heartbeat Interval**: de 60 a 120 segundos
+4. Aumentar **Timeout**: de 48 a 60 segundos
+5. **Save**
+
+### Verificar desde Contenedor
+
+Probar conectividad desde dentro del contenedor Uptime Kuma:
+
+```bash
+# HTTP
+docker compose exec uptime-kuma wget -O- https://example.com
+
+# Ping
+docker compose exec uptime-kuma ping -c 4 example.com
+
+# DNS
+docker compose exec uptime-kuma nslookup example.com
+
+# TCP Port
+docker compose exec uptime-kuma nc -zv example.com 443
+```
+
+### Error: "Invalid URL"
+
+**Causa**: URL mal formada.
+
+**Correcto**:
+- `https://example.com` ✅
+- `https://example.com:443` ✅
+- `https://example.com/path` ✅
+
+**Incorrecto**:
+- `example.com` ❌ (falta protocolo)
+- `https://` ❌ (falta dominio)
+
+### Error: "Keyword not found"
+
+**Causa**: La página no contiene el keyword esperado.
+
+**Verificar**:
+```bash
+# Descargar página y buscar keyword
+docker compose exec uptime-kuma wget -qO- https://example.com | grep "keyword"
+```
+
+Si no aparece:
+- El keyword es incorrecto
+- La página cambió
+- La página requiere autenticación
+
+---
+
+## Notificaciones no Funcionan
+
+### Telegram
+
+**Error: "Bad Request: chat not found"**
+
+**Causa**: Chat ID incorrecto.
+
+**Solución**:
+1. Obtener Chat ID correcto:
+   - Usuario: Número positivo (123456789)
+   - Grupo: Número negativo (-987654321)
+2. Usar [@userinfobot](https://t.me/userinfobot) para verificar ID
+
+**Error: "Unauthorized"**
+
+**Causa**: Bot token inválido.
+
+**Solución**:
+1. Verificar token con [@BotFather](https://t.me/botfather)
+2. Enviar `/mybots` → Seleccionar bot → API Token
+
+### Discord
+
+**Error: "Unknown Webhook"**
+
+**Causa**: Webhook eliminado o URL incorrecta.
+
+**Solución**:
+1. Verificar webhook existe en Discord
+2. Regenerar webhook si es necesario
+
+### Email (SMTP)
+
+**Error: "EAUTH: authentication failed"**
+
+**Causa**: Usuario/password incorrecto.
+
+**Gmail**:
+- Usar **App Password**, no contraseña de cuenta
+- Generar en: [https://myaccount.google.com/apppasswords](https://myaccount.google.com/apppasswords)
+
+**Outlook/Office365**:
+- Usar autenticación moderna (OAuth2) no soportada
+- Alternativa: Usar SMTP relay externo (SendGrid, Mailgun)
+
+**Error: "ETIMEDOUT"**
+
+**Causa**: Firewall bloquea puerto SMTP.
+
+**Solución**:
+```bash
+# Verificar conectividad
+docker compose exec uptime-kuma nc -zv smtp.gmail.com 587
+```
+
+---
+
+## WebSockets no Funcionan
+
+### Síntomas
+
+- Interfaz no se actualiza en tiempo real
+- Necesitas refrescar página (F5) para ver cambios
+- Consola del navegador (F12) muestra: `WebSocket connection failed`
+
+### Traefik
+
+Traefik soporta WebSockets **automáticamente**. Si hay problemas:
+
+**Añadir headers explícitos** (raro):
+```yaml
+labels:
+  - traefik.http.middlewares.uptime-ws.headers.customrequestheaders.Connection=Upgrade
+  - traefik.http.middlewares.uptime-ws.headers.customrequestheaders.Upgrade=websocket
+  - traefik.http.routers.uptime-kuma.middlewares=uptime-ws
+```
+
+### NPM
+
+**Verificar checkbox**:
+- ✅ **Websockets Support** DEBE estar habilitado
+
+Si está habilitado y no funciona:
+1. Editar Proxy Host
+2. **Advanced** → **Custom Nginx Configuration**:
+   ```nginx
+   proxy_set_header Upgrade $http_upgrade;
+   proxy_set_header Connection "upgrade";
+   ```
+
+---
+
+## Base de Datos Corrupta
+
+### Síntomas
+
+- Error al iniciar: `SQLITE_CORRUPT`
+- Monitores desaparecen
+- Datos inconsistentes
+
+### Verificar Integridad
+
+```bash
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db "PRAGMA integrity_check;"
+```
+
+**Si devuelve algo diferente a "ok"**, la base de datos está corrupta.
+
+### Intentar Reparar
+
+```bash
+# Dump y recrear
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db ".dump" > kuma-dump.sql
+docker compose exec uptime-kuma sqlite3 /app/data/kuma-new.db < kuma-dump.sql
+
+# Reemplazar
+docker compose stop uptime-kuma
+docker compose cp kuma-new.db uptime-kuma:/app/data/kuma.db
+docker compose start uptime-kuma
+```
+
+### Restaurar desde Backup
+
+Si reparación falla:
+
+```bash
+docker compose stop uptime-kuma
+docker compose cp ./backup/kuma-latest.db uptime-kuma:/app/data/kuma.db
+docker compose start uptime-kuma
+```
+
+---
+
+## Status Page no Carga
+
+### Error 404
+
+**Causa**: Slug incorrecto en URL.
+
+**Verificar**:
+1. **Status Pages** → Ver slug configurado
+2. URL debe ser: `https://uptime.example.com/status/{slug}`
+
+### Status Page Pública no Accesible
+
+**Verificar configuración**:
+1. Editar Status Page
+2. ✅ **Public** debe estar habilitado
+3. **Save**
+
+### CSS Personalizado no Aplica
+
+**Limpiar cache**:
+- Chrome/Edge: `Ctrl + Shift + R`
+- Firefox: `Ctrl + F5`
+
+---
+
+## Logs de Depuración
+
+### Habilitar Logs Detallados
+
+Uptime Kuma no tiene modo verbose nativo, pero puedes:
+
+```bash
+# Ver logs en tiempo real con timestamps
+docker compose logs -f --timestamps uptime-kuma
+
+# Ver logs de Docker daemon
+journalctl -u docker -f | grep uptime-kuma
+```
+
+### Exportar Logs
+
+```bash
+# Últimas 1000 líneas
+docker compose logs --tail=1000 uptime-kuma > uptime-kuma-logs.txt
+
+# Todos los logs
+docker compose logs uptime-kuma > uptime-kuma-full-logs.txt
+```
+
+---
+
+## Performance y Recursos
+
+### Alto Uso de CPU
+
+**Causa**: Demasiados monitores con interval muy bajo.
+
+**Solución**:
+1. Aumentar **Heartbeat Interval** de monitores no críticos
+2. Reducir número de monitores
+3. Usar monitor DNS o Ping en lugar de HTTP para checks simples
+
+### Alto Uso de RAM
+
+**Causa**: Retención de datos muy larga + muchos monitores.
+
+**Solución**:
+1. **Settings** → **General** → **Keep Data**: Reducir de 180 a 90 días
+2. Vacuumar base de datos:
+   ```bash
+   docker compose exec uptime-kuma sqlite3 /app/data/kuma.db "VACUUM;"
+   ```
+
+### Base de Datos Muy Grande
+
+**Verificar tamaño**:
+```bash
+docker compose exec uptime-kuma ls -lh /app/data/kuma.db
+```
+
+**Reducir tamaño**:
+```bash
+# Reducir retención en Settings
+# Luego vacuumar
+docker compose exec uptime-kuma sqlite3 /app/data/kuma.db "VACUUM;"
+```
+
+---
+
+## Soporte
+
+Si ninguna solución funciona:
+
+1. **GitHub Issues**: [https://github.com/louislam/uptime-kuma/issues](https://github.com/louislam/uptime-kuma/issues)
+2. **Discord**: [https://discord.gg/uptime-kuma](https://discord.gg/uptime-kuma)
+3. **Reddit**: [r/UptimeKuma](https://reddit.com/r/UptimeKuma)
+
+**Al reportar**:
+- Versión de Uptime Kuma
+- Logs completos (`docker compose logs uptime-kuma`)
+- Configuración relevante (sin contraseñas)
+- Pasos para reproducir el problema

Status-Pages.md

@@ -0,0 +1,292 @@
+# Status Pages
+
+Las **Status Pages** permiten compartir el estado de tus servicios públicamente sin dar acceso al panel de administración.
+
+---
+
+## ¿Qué es una Status Page?
+
+Página web **pública** que muestra:
+- Estado actual de servicios (Up/Down)
+- Historial de uptime (últimos 24h, 7d, 30d, 90d)
+- Incidentes actuales y pasados
+- Métricas de tiempo de respuesta
+
+**URL pública**: `https://uptime.example.com/status/nombre-pagina`
+
+**Uso**:
+- Transparencia con clientes
+- Dashboard para equipos internos
+- Cumplimiento de SLA
+
+---
+
+## Crear Status Page
+
+### 1. Crear Página
+
+1. Click en **Status Pages** (menú lateral)
+2. Click en **Add New Status Page**
+3. Configurar:
+   - **Title**: `Estado de Servicios ICT Iberia`
+   - **Slug**: `servicios` (parte de la URL)
+   - **Description**: `Monitorización en tiempo real de nuestros servicios`
+   - **Theme**: `Auto` (sigue tema del sistema), `Light`, `Dark`
+   - **Show Tags**: ✅ (mostrar tags de monitores)
+   - **Show Powered By**: ✅/❌ (enlace a Uptime Kuma)
+
+### 2. Añadir Grupos
+
+Organizar monitores por categorías:
+
+1. Click en **Add Group**
+2. **Group Name**: `Aplicaciones Web`
+3. Arrastrar monitores desde la lista izquierda al grupo
+4. Repetir para otros grupos:
+   - `Infraestructura`
+   - `Bases de Datos`
+   - `APIs`
+
+### 3. Configurar Visualización
+
+**Opciones de visualización por monitor**:
+- **Default**: Muestra uptime % y estado actual
+- **List**: Lista compacta sin gráficos
+- **None**: Ocultar de la página pública
+
+**Mostrar/Ocultar**:
+- Arrastra monitor fuera del grupo para ocultarlo
+- Arrastra de vuelta para mostrarlo
+
+### 4. Publicar
+
+1. **Public**: ✅ (hacer página accesible sin login)
+2. **Save**
+
+**URL pública**: `https://uptime.example.com/status/servicios`
+
+---
+
+## Personalización
+
+### Custom CSS
+
+**Settings** → **Custom CSS**:
+
+```css
+/* Cambiar color de fondo */
+body {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+}
+
+/* Personalizar header */
+.status-page-header {
+  background: rgba(255, 255, 255, 0.1);
+  backdrop-filter: blur(10px);
+  border-radius: 12px;
+  padding: 20px;
+}
+
+/* Cambiar fuente */
+* {
+  font-family: 'Inter', -apple-system, sans-serif;
+}
+```
+
+### Custom Domain
+
+Si quieres `status.example.com` en lugar de `uptime.example.com/status/...`:
+
+**Con Traefik**:
+```yaml
+# docker-compose.override.yml
+labels:
+  - traefik.http.routers.uptime-kuma-status.rule=Host(`status.example.com`)
+  - traefik.http.routers.uptime-kuma-status.entrypoints=websecure
+  - traefik.http.routers.uptime-kuma-status.tls.certresolver=letsencrypt
+```
+
+**Con NPM**:
+1. Crear nuevo Proxy Host
+2. **Domain**: `status.example.com`
+3. **Forward to**: `uptime-kuma:3001`
+
+Uptime Kuma detectará automáticamente el dominio y adaptará URLs.
+
+### Favicon Personalizado
+
+1. **Settings** → **Favicon URL**
+2. URL pública de tu favicon (ejemplo: `https://example.com/favicon.ico`)
+3. **Save**
+
+### Footer Personalizado
+
+1. **Settings** → **Footer Text**
+2. Texto o HTML:
+   ```html
+   © 2024 ICT Iberia | <a href="/contact">Contacto</a>
+   ```
+3. **Save**
+
+---
+
+## Incidentes
+
+Publicar incidentes programados o no planificados.
+
+### Crear Incidente
+
+1. En la Status Page, click en **Create Incident**
+2. Configurar:
+   - **Title**: `Mantenimiento Programado - Base de Datos`
+   - **Content**: 
+     ```
+     Realizaremos actualización de PostgreSQL.
+     Duración estimada: 30 minutos
+     Inicio: 02:00 AM - 02:30 AM (UTC+1)
+     ```
+   - **Style**: 
+     - `info` (azul): Información general
+     - `warning` (amarillo): Degradación de servicio
+     - `danger` (rojo): Servicio caído
+     - `primary` (verde): Resuelto
+   - **Pin**: ✅ (mostrar arriba de la página)
+
+3. **Publish**
+
+### Actualizar Incidente
+
+1. Click en incidente existente
+2. **Edit**
+3. Añadir actualización:
+   ```
+   [14:30] Mantenimiento completado. Servicios restaurados.
+   ```
+4. Cambiar **Style** a `primary` (resuelto)
+5. **Save**
+
+### Historial
+
+Uptime Kuma mantiene historial de incidentes. Usuarios pueden ver:
+- Incidentes activos (arriba)
+- Incidentes resueltos (abajo, colapsados)
+
+---
+
+## Tipos de Status Page
+
+### Public Status Page
+
+- ✅ **Public**: Sí
+- Acceso: Cualquiera con la URL
+- Autenticación: No requerida
+
+**Uso**: Transparencia con clientes, SaaS public status.
+
+### Private Status Page
+
+- ❌ **Public**: No
+- Acceso: Solo usuarios logueados en Uptime Kuma
+- Autenticación: Requerida
+
+**Uso**: Dashboard interno, equipos de operaciones.
+
+### Password-Protected Status Page
+
+1. Crear Status Page
+2. ✅ **Public**
+3. ✅ **Password Protected**
+4. **Password**: Contraseña compartida
+5. **Save**
+
+**Acceso**: URL pública, pero requiere contraseña.
+
+**Uso**: Compartir con clientes específicos, beta testers.
+
+---
+
+## Badges (Insignias)
+
+Generar badges para README, wikis, etc.
+
+### URL del Badge
+
+```
+https://uptime.example.com/api/badge/{monitor_id}/uptime/24
+```
+
+**Parámetros**:
+- `{monitor_id}`: ID del monitor (ver en URL al editar)
+- `uptime`: Tipo (uptime / status / ping / avg-response)
+- `24`: Período (24 / 720 / 1440 / 43200)
+
+**Ejemplo**:
+```markdown
+![Uptime](https://uptime.example.com/api/badge/1/uptime/24)
+```
+
+**Resultado**: ![Uptime 99.9%](https://img.shields.io/badge/uptime-99.9%25-brightgreen)
+
+### Tipos de Badge
+
+**Status Badge**:
+```
+/api/badge/{id}/status
+```
+Muestra: 🟢 Up / 🔴 Down
+
+**Ping Badge**:
+```
+/api/badge/{id}/ping/24
+```
+Muestra: Ping promedio (ms)
+
+**Response Time Badge**:
+```
+/api/badge/{id}/avg-response/24
+```
+Muestra: Tiempo de respuesta promedio (ms)
+
+---
+
+## Integración con APIs
+
+### Webhook de Status Page
+
+Uptime Kuma no tiene webhook nativo de Status Page, pero puedes:
+
+1. Configurar notificación **Webhook** en cada monitor
+2. Enviar JSON a tu API cuando cambia estado
+3. Tu API actualiza status page externa (ejemplo: Statuspage.io)
+
+---
+
+## Ejemplo: Status Page Completa
+
+**Configuración**:
+- **Title**: Estado de Servicios - ICT Iberia
+- **Slug**: `estado`
+- **Public**: ✅
+- **Theme**: Auto
+
+**Grupos**:
+1. **Aplicaciones Web**
+   - Vaultwarden (Password Manager)
+   - BookStack (Wiki Interna)
+   - NetBox (IPAM)
+
+2. **Monitorización**
+   - Uptime Kuma (Self)
+   - CheckMK (Monitoring)
+
+3. **Infraestructura**
+   - Servidor Principal (Ping)
+   - Router Gateway (Ping)
+
+**URL**: `https://uptime.ictiberia.com/status/estado`
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Backup y Restauración](Backup-y-Restauración)** para proteger tus datos.

Traefik.md

@@ -0,0 +1,231 @@
+# Despliegue con Traefik
+
+Esta guía explica cómo desplegar Uptime Kuma usando **Traefik** como proxy inverso con SSL automático mediante Let's Encrypt.
+
+---
+
+## Requisitos Previos
+
+- ✅ Stack de Traefik desplegado y funcionando
+- ✅ Red Docker `proxy` creada externamente
+- ✅ DNS configurado apuntando a tu servidor (ejemplo: `uptime.example.com`)
+- ✅ Puertos 80 y 443 accesibles desde Internet
+
+---
+
+## Configuración
+
+### 1. Preparar archivos
+
+```bash
+cd uptime-kuma
+cp docker-compose.override.traefik.yml.example docker-compose.override.yml
+cp .env.example .env
+```
+
+### 2. Configurar variables de entorno
+
+Edita `.env`:
+
+```bash
+nano .env
+```
+
+**Contenido**:
+```env
+DOMAIN_HOST=uptime.example.com
+```
+
+Reemplaza `uptime.example.com` con tu dominio real.
+
+### 3. Verificar configuración
+
+**docker-compose.override.yml**:
+```yaml
+services:
+  uptime-kuma:
+    labels:
+      - traefik.enable=true
+      - traefik.http.routers.uptime-kuma.rule=Host(`${DOMAIN_HOST}`)
+      - traefik.http.routers.uptime-kuma.entrypoints=websecure
+      - traefik.http.routers.uptime-kuma.tls.certresolver=letsencrypt
+      - traefik.http.services.uptime-kuma.loadbalancer.server.port=3001
+```
+
+**Importante**: Uptime Kuma escucha en puerto **3001** (no 80).
+
+### 4. Desplegar
+
+```bash
+docker compose up -d
+```
+
+### 5. Verificar despliegue
+
+```bash
+# Ver logs
+docker compose logs -f uptime-kuma
+
+# Verificar contenedor activo
+docker compose ps
+
+# Verificar red proxy
+docker network inspect proxy | grep uptime-kuma
+```
+
+**Salida esperada** (logs):
+```
+uptime-kuma  | ✅ Server is ready
+uptime-kuma  | Listening on http://0.0.0.0:3001
+```
+
+### 6. Acceder
+
+Navega a: **https://uptime.example.com**
+
+En el primer acceso, Uptime Kuma te pedirá crear una cuenta de administrador.
+
+---
+
+## Labels de Traefik Explicados
+
+| Label | Descripción |
+|-------|-------------|
+| `traefik.enable=true` | Habilita Traefik para este contenedor |
+| `traefik.http.routers.uptime-kuma.rule=Host(...)` | Regla de enrutamiento por dominio |
+| `traefik.http.routers.uptime-kuma.entrypoints=websecure` | Usa entrypoint HTTPS (443) |
+| `traefik.http.routers.uptime-kuma.tls.certresolver=letsencrypt` | Genera certificado SSL automático |
+| `traefik.http.services.uptime-kuma.loadbalancer.server.port=3001` | Puerto del contenedor (⚠️ **3001**, no 80) |
+
+---
+
+## WebSockets
+
+Uptime Kuma **requiere WebSockets** para actualizar datos en tiempo real.
+
+Traefik soporta WebSockets **automáticamente** sin configuración adicional.
+
+---
+
+## Solución de Problemas
+
+### Error 502 Bad Gateway
+
+**Causa**: Traefik no puede conectar al contenedor.
+
+**Solución**:
+```bash
+# Verificar que el contenedor está en la red proxy
+docker network inspect proxy | grep uptime-kuma
+
+# Verificar puerto correcto en labels
+docker inspect uptime-kuma | grep "loadbalancer.server.port"
+# Debe mostrar: 3001
+```
+
+### Certificado SSL no se genera
+
+**Causa**: DNS no apunta al servidor o puerto 80/443 bloqueado.
+
+**Verificar DNS**:
+```bash
+nslookup uptime.example.com
+# Debe devolver la IP de tu servidor
+```
+
+**Verificar Traefik**:
+```bash
+docker logs traefik | grep uptime-kuma
+```
+
+**Solución**:
+- Asegurar que DNS apunta correctamente
+- Verificar firewall permite puertos 80 y 443
+- Revisar logs de Traefik para errores de Let's Encrypt
+
+### Uptime Kuma no actualiza en tiempo real
+
+**Causa**: WebSockets bloqueados (raro en Traefik).
+
+**Verificar en navegador** (consola F12):
+```
+WebSocket connection to 'wss://uptime.example.com/socket.io/...' failed
+```
+
+**Solución**:
+Traefik soporta WebSockets automáticamente, pero si hay problemas:
+```yaml
+# NO necesario normalmente, pero si hay issues:
+labels:
+  - traefik.http.middlewares.uptime-ws.headers.customrequestheaders.Connection=Upgrade
+  - traefik.http.middlewares.uptime-ws.headers.customrequestheaders.Upgrade=websocket
+  - traefik.http.routers.uptime-kuma.middlewares=uptime-ws
+```
+
+### DOMAIN_HOST no se resuelve
+
+**Causa**: Variable no se exporta correctamente.
+
+**Verificar**:
+```bash
+docker inspect uptime-kuma | grep "traefik.http.routers.uptime-kuma.rule"
+```
+
+**Debe mostrar**:
+```
+Host(`uptime.example.com`)
+```
+
+Si muestra `Host(`${DOMAIN_HOST}`)`, el .env no se cargó.
+
+**Solución**:
+```bash
+# Recrear stack
+docker compose down
+docker compose up -d
+```
+
+---
+
+## Configuración Avanzada
+
+### Múltiples dominios
+
+```yaml
+labels:
+  - traefik.http.routers.uptime-kuma.rule=Host(`uptime.example.com`) || Host(`status.example.com`)
+```
+
+### Forzar HTTPS (redirigir HTTP → HTTPS)
+
+Traefik ya lo hace automáticamente con `websecure` entrypoint.
+
+### Restringir acceso por IP
+
+```yaml
+labels:
+  - traefik.http.middlewares.uptime-whitelist.ipwhitelist.sourcerange=192.168.1.0/24,10.0.0.0/8
+  - traefik.http.routers.uptime-kuma.middlewares=uptime-whitelist
+```
+
+### Autenticación básica (antes de login de Uptime Kuma)
+
+```bash
+# Generar usuario/password
+htpasswd -nb admin password
+# Salida: admin:$apr1$...
+```
+
+```yaml
+labels:
+  - traefik.http.middlewares.uptime-auth.basicauth.users=admin:$$apr1$$...
+  - traefik.http.routers.uptime-kuma.middlewares=uptime-auth
+```
+
+⚠️ **Nota**: Escapa `$` con `$$` en docker-compose.yml.
+
+---
+
+## Siguiente Paso
+
+Continúa con **[Configuración Inicial](Configuración-Inicial)** para crear tu cuenta administrador y configurar notificaciones.

_Sidebar.md

@@ -0,0 +1,17 @@
+# Navegación
+
+## 🏠 [Home](Home)
+
+## 🚀 Despliegue
+- [Traefik](Traefik)
+- [Nginx Proxy Manager](NPM)
+
+## ⚙️ Configuración
+- [Configuración Inicial](Configuración-Inicial)
+- [Monitorización](Monitorización)
+- [Status Pages](Status-Pages)
+
+## 🔧 Mantenimiento
+- [Backup y Restauración](Backup-y-Restauración)
+- [Actualización](Actualización)
+- [Solución de Problemas](Solución-de-Problemas)