groales/vaultwarden
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Wiki completa de Vaultwarden con 9 páginas

Gustavo Roales
2025-12-03 12:41:49 +01:00
parent 0f8ddaed93
commit bb6d63755a
9 changed files with 3582 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
Actualización.md Normal file

@@ -0,0 +1,430 @@
# Actualización
Mantener Vaultwarden actualizado es importante para seguridad y nuevas funcionalidades.
## 🔄 Estrategia de Actualización
### Frecuencia Recomendada
- **Actualizaciones de seguridad**: Inmediatamente
- **Versiones estables**: Cada 1-2 meses
- **Versiones beta**: Solo en entornos de testing
### Antes de Actualizar
**SIEMPRE** haz un backup antes de actualizar:
```bash
# Backup rápido
docker compose stop vaultwarden
docker run --rm \
-v vaultwarden_data:/data \
-v ~/backups:/backup \
alpine tar czf /backup/pre-update-$(date +%Y%m%d).tar.gz -C /data .
docker compose start vaultwarden
```
Ver detalles completos en **[Backup y Restauración](Backup-y-Restauración)**.
## 🚀 Actualización desde Portainer (Git Repository)
La forma más sencilla si usaste el método Git Repository.
### 1. Actualizar desde Portainer
1. Ve a **Stacks** → `vaultwarden`
2. Haz clic en **Editor** (o **Git Repository**)
3. Haz clic en **Pull and redeploy**
Portainer automáticamente:
- ✅ Descarga la última imagen Docker
- ✅ Recrea el contenedor
- ✅ Conserva tus datos (volúmenes)
- ✅ Mantiene las variables de entorno
### 2. Verificar la Actualización
```bash
# Ver versión actual
docker inspect vaultwarden | grep -i version
# Ver logs del proceso
docker compose logs -f vaultwarden
# Verificar que funciona
curl -I https://vaultwarden.tudominio.com
```
### 3. Probar Acceso
1. Abre `https://vaultwarden.tudominio.com`
2. Inicia sesión con tu cuenta
3. Verifica que puedes ver tus contraseñas
4. Prueba crear/editar una entrada
5. Verifica sincronización en otro dispositivo
## 🖥️ Actualización desde CLI
### Método Estándar
```bash
cd /ruta/a/vaultwarden
# 1. Backup (crítico)
bash ~/scripts/backup-vaultwarden.sh
# 2. Descargar nueva imagen
docker compose pull
# 3. Recrear contenedor con nueva imagen
docker compose up -d
# 4. Verificar logs
docker compose logs -f vaultwarden
```
### Verificar Nueva Versión
Antes de actualizar, verifica la versión disponible:
```bash
# Ver versión actual
docker inspect vaultwarden --format '{{.Config.Image}}'
# Ver versión disponible
docker pull vaultwarden/server:latest
docker inspect vaultwarden/server:latest | grep -i version
```
## 📌 Actualización a Versión Específica
Por defecto usamos `latest`, pero puedes fijar una versión:
### 1. Modificar docker-compose.yml
```yaml
services:
vaultwarden:
image: vaultwarden/server:1.30.5 # Versión específica
# ...resto de la config
```
### 2. Actualizar
```bash
docker compose pull
docker compose up -d
```
### Ventajas y Desventajas
**Versión específica** (ej: `1.30.5`):
- ✅ Control total sobre cuándo actualizar
- ✅ Evita sorpresas de breaking changes
- ❌ Debes actualizar manualmente
- ❌ Puedes perderte parches de seguridad
**latest**:
- ✅ Siempre la última versión
- ✅ Actualizaciones de seguridad automáticas
- ⚠️ Puede introducir bugs en raras ocasiones
**Recomendación**: Usa `latest` y actualiza periódicamente con backups previos.
## 🔔 Monitorizar Nuevas Versiones
### Opción 1: Watchtower (Automático)
Watchtower actualiza contenedores automáticamente:
```yaml
services:
watchtower:
image: containrrr/watchtower
restart: unless-stopped
environment:
WATCHTOWER_CLEANUP: true
WATCHTOWER_SCHEDULE: "0 0 3 * * *" # 3 AM diario
WATCHTOWER_INCLUDE_STOPPED: false
volumes:
- /var/run/docker.sock:/var/run/docker.sock
```
⚠️ **Advertencia**: Actualiza sin intervención. Solo recomendado si:
- ✅ Tienes backups automáticos
- ✅ Confías en la estabilidad de `latest`
- ✅ Monitoreas logs regularmente
### Opción 2: GitHub Watch (Manual)
1. Ve a https://github.com/dani-garcia/vaultwarden
2. Haz clic en **Watch** → **Custom** → **Releases**
3. Recibirás notificaciones de nuevas versiones
### Opción 3: Script de Verificación
```bash
#!/bin/bash
# check-vaultwarden-updates.sh
CURRENT=$(docker inspect vaultwarden --format '{{.Image}}')
docker pull vaultwarden/server:latest > /dev/null 2>&1
LATEST=$(docker inspect vaultwarden/server:latest --format '{{.Id}}')
if [ "$CURRENT" != "$LATEST" ]; then
echo "🔔 Nueva versión de Vaultwarden disponible"
echo "Actual: $CURRENT"
echo "Nueva: $LATEST"
exit 1
else
echo "✅ Vaultwarden está actualizado"
exit 0
fi
```
Ejecuta semanalmente con cron:
```bash
0 9 * * 1 /home/usuario/scripts/check-vaultwarden-updates.sh | mail -s "Vaultwarden Update Check" tu@email.com
```
## 📝 Changelog y Notas de Versión
Antes de actualizar, revisa el changelog:
- **GitHub Releases**: https://github.com/dani-garcia/vaultwarden/releases
- **Wiki de cambios**: https://github.com/dani-garcia/vaultwarden/wiki
Busca:
- 🔒 **Security fixes**: Actualiza inmediatamente
- ⚠️ **Breaking changes**: Requieren cambios en configuración
- ✨ **New features**: Funcionalidades nuevas
- 🐛 **Bug fixes**: Correcciones de errores
## 🔧 Actualización del Stack Completo
Si también usas Traefik o NPM, actualízalos periódicamente:
### Actualizar Todo
```bash
# Traefik
docker compose -f /ruta/a/traefik/docker-compose.yml pull
docker compose -f /ruta/a/traefik/docker-compose.yml up -d
# Nginx Proxy Manager
docker compose -f /ruta/a/npm/docker-compose.yml pull
docker compose -f /ruta/a/npm/docker-compose.yml up -d
# Vaultwarden
docker compose -f /ruta/a/vaultwarden/docker-compose.yml pull
docker compose -f /ruta/a/vaultwarden/docker-compose.yml up -d
```
### Orden Recomendado
1. **Primero**: Actualiza el proxy (Traefik/NPM)
2. **Espera**: Verifica que el proxy funciona
3. **Segundo**: Actualiza Vaultwarden
4. **Prueba**: Verifica acceso completo
## 🛠️ Migración de Versiones Antiguas
### Desde Bitwarden_RS (Nombre Antiguo)
Si tienes el proyecto con su nombre antiguo `bitwarden_rs`:
1. Es el mismo proyecto, solo cambió de nombre
2. Actualiza la imagen:
```yaml
# Antiguo
image: bitwardenrs/server:latest
# Nuevo
image: vaultwarden/server:latest
```
3. Actualiza normalmente: `docker compose pull && docker compose up -d`
4. Los datos se conservan automáticamente
### Desde Versiones Muy Antiguas (<1.0)
Si llevas años sin actualizar:
1. **NO actualices directamente a latest**
2. Actualiza incrementalmente:
- 0.x → 1.0
- 1.0 → 1.20
- 1.20 → latest
3. Lee el changelog de cada versión mayor
4. Haz backups entre cada actualización
## ⚠️ Rollback (Revertir Actualización)
Si algo sale mal después de actualizar:
### Método 1: Volver a Versión Anterior
```bash
# 1. Detener versión nueva
docker compose down
# 2. Cambiar a versión anterior
docker compose pull vaultwarden/server:1.29.0 # Versión que funcionaba
# 3. Modificar docker-compose.yml
# image: vaultwarden/server:1.29.0
# 4. Iniciar con versión antigua
docker compose up -d
```
### Método 2: Restaurar desde Backup
Si los datos se corrompieron:
```bash
# 1. Detener Vaultwarden
docker compose stop vaultwarden
# 2. Restaurar backup pre-actualización
docker run --rm \
-v vaultwarden_data:/data \
-v ~/backups:/backup \
alpine sh -c "cd /data && rm -rf * && tar xzf /backup/pre-update-YYYYMMDD.tar.gz"
# 3. Volver a versión anterior (ver Método 1)
# 4. Reiniciar
docker compose start vaultwarden
```
## 📊 Post-Actualización
### Checklist de Verificación
Después de cada actualización, verifica:
- [ ] El contenedor está corriendo: `docker compose ps`
- [ ] No hay errores en logs: `docker compose logs vaultwarden`
- [ ] Acceso web funciona: https://vaultwarden.tudominio.com
- [ ] Puedes hacer login
- [ ] Puedes ver tus contraseñas
- [ ] WebSocket funciona (sincronización en tiempo real)
- [ ] Panel de administración accesible: `/admin`
- [ ] Extensión del navegador sigue conectada
- [ ] App móvil sincroniza correctamente
### Ver Logs Post-Actualización
```bash
# Logs en tiempo real
docker compose logs -f vaultwarden
# Solo errores
docker compose logs vaultwarden | grep -i error
# Últimas 50 líneas
docker compose logs --tail=50 vaultwarden
```
### Verificar Versión Instalada
```bash
# Inspeccionar contenedor
docker inspect vaultwarden | grep -i image
# Ver en el log de inicio
docker compose logs vaultwarden | grep -i "vaultwarden"
```
## 🔐 Actualización de Clientes
No olvides actualizar también los clientes de Bitwarden:
### Extensiones de Navegador
Se actualizan automáticamente desde las stores:
- Chrome Web Store
- Firefox Add-ons
- Edge Add-ons
Verifica manualmente: **Extensiones** → **Administrar extensiones** → **Actualizar**
### Aplicaciones de Escritorio
Descarga la última versión de: https://bitwarden.com/download/
Recomendado actualizar cada 3-6 meses.
### Aplicaciones Móviles
Se actualizan desde:
- **iOS**: App Store
- **Android**: Google Play Store
Habilita actualizaciones automáticas en la configuración de la store.
### CLI de Bitwarden
```bash
# Ver versión actual
bw --version
# Actualizar (con npm)
npm update -g @bitwarden/cli
# Verificar nueva versión
bw --version
```
## 📅 Calendario de Actualización Recomendado
| Componente | Frecuencia | Método |
|------------|------------|--------|
| **Vaultwarden** | Mensual | Manual con backup |
| **Proxy (Traefik/NPM)** | Trimestral | Manual |
| **Clientes (extensión, apps)** | Automático | Auto-update |
| **Sistema Operativo** | Mensual | `apt update && apt upgrade` |
| **Docker** | Semestral | Según distro |
## 🆘 Problemas Comunes Post-Actualización
### No arranca después de actualizar
**Solución**:
```bash
# Ver error exacto
docker compose logs vaultwarden
# Probar versión anterior
docker compose down
# Cambiar imagen a versión anterior
docker compose up -d
```
### Database migration failed
**Síntoma**: Error sobre migración de base de datos
**Solución**:
1. Restaurar backup pre-actualización
2. Revisar changelog de breaking changes
3. Actualizar incrementalmente
### WebSocket deja de funcionar
**Síntoma**: Sincronización lenta después de actualizar
**Solución**:
```bash
# Verificar puerto 3012
docker compose logs vaultwarden | grep websocket
# Recrear contenedor
docker compose down && docker compose up -d
```
---
**Última actualización**: Diciembre 2025
💡 **Buena práctica**: Actualiza en viernes por la tarde, así tienes el fin de semana para resolver problemas si aparecen.

499
Backup-y-Restauración.md Normal file

@@ -0,0 +1,499 @@
# Backup y Restauración
⚠️ **CRÍTICO**: Vaultwarden almacena todas tus contraseñas. **Sin backup, puedes perderlo todo**. Esta es la página más importante de la wiki.
## 🔴 Por Qué son Críticos los Backups
Un gestor de contraseñas sin backup es una bomba de tiempo:
- 💥 **Fallo de hardware**: Disco duro que muere
- 🔥 **Corrupción de datos**: Error del sistema de archivos
- 🚫 **Actualización fallida**: Docker o Vaultwarden se rompe
- 🏢 **Migración de servidor**: Necesitas moverte a otro host
- 👤 **Error humano**: `docker compose down -v` por accidente
**Un solo comando sin backup puede borrar años de contraseñas.**
## 📦 Qué Respaldar
Vaultwarden almacena todo en el volumen Docker `vaultwarden_data`:
```
vaultwarden_data/
├── db.sqlite3 # Base de datos (contraseñas, usuarios)
├── db.sqlite3-wal # Write-Ahead Log (transacciones)
├── db.sqlite3-shm # Shared memory
├── attachments/ # Archivos adjuntos
├── sends/ # Sends temporales
├── config.json # Configuración del servidor
├── rsa_key.pem # Clave privada RSA
├── rsa_key.pub.pem # Clave pública RSA
└── vaultwarden.log # Logs (opcional)
```
**Archivos críticos**:
- ✅ `db.sqlite3*` - Base de datos completa
- ✅ `rsa_key*.pem` - Claves de cifrado
- ✅ `config.json` - Configuración
- ✅ `attachments/` - Adjuntos de los usuarios
**Opcionales**:
- `vaultwarden.log` - Solo para debugging
- `sends/` - Normalmente vacío (envíos temporales)
## 🛠️ Métodos de Backup
### Método 1: Backup Manual Completo (Recomendado)
Copia todo el volumen Docker.
```bash
#!/bin/bash
# Script: backup-vaultwarden.sh
# Configuración
BACKUP_DIR="$HOME/backups/vaultwarden"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="vaultwarden-backup-${TIMESTAMP}.tar.gz"
# Crear directorio si no existe
mkdir -p "$BACKUP_DIR"
# Detener el contenedor (para consistencia)
docker compose -f /ruta/a/vaultwarden/docker-compose.yml stop vaultwarden
# Crear backup del volumen
docker run --rm \
-v vaultwarden_data:/data \
-v "$BACKUP_DIR":/backup \
alpine \
tar czf "/backup/$BACKUP_FILE" -C /data .
# Reiniciar el contenedor
docker compose -f /ruta/a/vaultwarden/docker-compose.yml start vaultwarden
# Verificar backup
if [ -f "$BACKUP_DIR/$BACKUP_FILE" ]; then
echo "✅ Backup creado: $BACKUP_FILE"
ls -lh "$BACKUP_DIR/$BACKUP_FILE"
else
echo "❌ ERROR: Backup falló"
exit 1
fi
# Limpieza: Mantener solo últimos 30 backups
cd "$BACKUP_DIR"
ls -t vaultwarden-backup-*.tar.gz | tail -n +31 | xargs -r rm
echo "✅ Backup completado correctamente"
```
### Método 2: Backup sin Detener el Servicio
Si tu instancia es 24/7 crítica:
```bash
#!/bin/bash
# Backup en caliente con SQLite checkpoint
BACKUP_DIR="$HOME/backups/vaultwarden"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="vaultwarden-backup-${TIMESTAMP}.tar.gz"
mkdir -p "$BACKUP_DIR"
# Forzar checkpoint de SQLite (fusiona WAL)
docker compose exec vaultwarden sqlite3 /data/db.sqlite3 "PRAGMA wal_checkpoint(TRUNCATE);"
# Backup sin detener
docker run --rm \
-v vaultwarden_data:/data:ro \
-v "$BACKUP_DIR":/backup \
alpine \
tar czf "/backup/$BACKUP_FILE" -C /data .
echo "✅ Backup en caliente completado: $BACKUP_FILE"
```
⚠️ **Advertencia**: Los backups en caliente pueden capturar estados inconsistentes. Para máxima seguridad, usa el Método 1.
### Método 3: Backup Automatizado con Cron
Automatiza backups diarios a las 3 AM:
```bash
# Editar crontab
crontab -e
# Añadir esta línea
0 3 * * * /home/usuario/scripts/backup-vaultwarden.sh >> /var/log/vaultwarden-backup.log 2>&1
```
Verifica que funciona:
```bash
# Ver logs del cron
tail -f /var/log/vaultwarden-backup.log
# Probar el script manualmente
bash /home/usuario/scripts/backup-vaultwarden.sh
```
### Método 4: Docker Volume Backup (Contenedor Dedicado)
Usa un contenedor especializado para backups automáticos:
```yaml
services:
# ... tu servicio vaultwarden ...
backup:
image: offen/docker-volume-backup:latest
restart: unless-stopped
environment:
BACKUP_CRON_EXPRESSION: "0 3 * * *" # Diario a las 3 AM
BACKUP_FILENAME: "vaultwarden-backup-%Y%m%d-%H%M%S.tar.gz"
BACKUP_RETENTION_DAYS: 30
BACKUP_PRUNING_PREFIX: "vaultwarden-backup-"
volumes:
- vaultwarden_data:/backup/vaultwarden_data:ro
- /ruta/backups:/archive
```
Ventajas:
- ✅ Completamente automático
- ✅ Rotación de backups integrada
- ✅ Notificaciones opcionales (webhook, email)
## 💾 Dónde Almacenar Backups
### ⚠️ NO Almacenar SOLO en el Mismo Servidor
Si el servidor muere, pierdes datos Y backups.
### ✅ Estrategia 3-2-1
- **3** copias de tus datos
- **2** medios diferentes
- **1** copia offsite (fuera del servidor)
### Opciones de Almacenamiento
#### 1. NAS Local
```bash
# Montar NAS
mount -t nfs nas.local:/backups /mnt/nas
# Modificar script de backup
BACKUP_DIR="/mnt/nas/vaultwarden"
```
#### 2. Cloud Storage (S3, B2, etc.)
```bash
# Instalar rclone
curl https://rclone.org/install.sh | sudo bash
# Configurar remote
rclone config
# Sincronizar backups
rclone sync $HOME/backups/vaultwarden remote:vaultwarden-backups
```
#### 3. Servidor Remoto (SCP/Rsync)
```bash
# Después del backup, envía a servidor remoto
scp "$BACKUP_DIR/$BACKUP_FILE" usuario@servidor-backup:/backups/vaultwarden/
# O con rsync
rsync -avz "$BACKUP_DIR/" usuario@servidor-backup:/backups/vaultwarden/
```
#### 4. Duplicati (GUI)
Duplicati ofrece backups cifrados y automáticos:
```yaml
services:
duplicati:
image: duplicati/duplicati
ports:
- "8200:8200"
environment:
TZ: Europe/Madrid
volumes:
- vaultwarden_data:/source/vaultwarden:ro
- duplicati_config:/data
```
Configura desde http://servidor:8200
## 🔄 Restauración
### Restauración Completa
Recupera todo el volumen desde un backup:
```bash
#!/bin/bash
# Script: restore-vaultwarden.sh
BACKUP_FILE="/ruta/al/backup/vaultwarden-backup-20240101_030000.tar.gz"
# Verificar que el backup existe
if [ ! -f "$BACKUP_FILE" ]; then
echo "❌ ERROR: Backup no encontrado: $BACKUP_FILE"
exit 1
fi
# Detener Vaultwarden
docker compose stop vaultwarden
# ADVERTENCIA: Esto borra los datos actuales
read -p "⚠️ Esto BORRARÁ los datos actuales. ¿Continuar? (yes/no): " -r
if [[ ! $REPLY =~ ^yes$ ]]; then
echo "❌ Restauración cancelada"
exit 1
fi
# Restaurar backup
docker run --rm \
-v vaultwarden_data:/data \
-v "$(dirname $BACKUP_FILE)":/backup \
alpine \
sh -c "cd /data && rm -rf * && tar xzf /backup/$(basename $BACKUP_FILE)"
# Reiniciar Vaultwarden
docker compose start vaultwarden
echo "✅ Restauración completada"
echo "Verifica que puedes acceder: https://vaultwarden.tudominio.com"
```
### Restauración desde Cero
Si estás migrando a un servidor nuevo:
```bash
# 1. Instalar Docker y Docker Compose
# 2. Clonar repositorio
git clone https://git.ictiberia.com/groales/vaultwarden.git
cd vaultwarden
# 3. Configurar override y .env
cp docker-compose.override.traefik.yml.example docker-compose.override.yml
nano .env # Configurar variables
# 4. Crear volumen vacío
docker volume create vaultwarden_data
# 5. Restaurar datos desde backup
docker run --rm \
-v vaultwarden_data:/data \
-v /ruta/al/backup:/backup \
alpine \
tar xzf /backup/vaultwarden-backup-YYYYMMDD.tar.gz -C /data
# 6. Iniciar Vaultwarden
docker compose up -d
# 7. Verificar
docker compose logs -f vaultwarden
```
### Restauración Selectiva (Solo DB)
Si solo necesitas la base de datos:
```bash
# Extraer solo db.sqlite3 del backup
tar xzf vaultwarden-backup-20240101.tar.gz db.sqlite3
# Copiar al volumen
docker cp db.sqlite3 vaultwarden:/data/db.sqlite3
# Reiniciar
docker compose restart vaultwarden
```
## ✅ Verificar Backups
### Probar Restauración
**Una vez al mes**, prueba restaurar un backup en un entorno de testing:
```bash
# Crear volumen temporal
docker volume create vaultwarden_test
# Restaurar backup en volumen test
docker run --rm \
-v vaultwarden_test:/data \
-v /ruta/backups:/backup \
alpine \
tar xzf /backup/vaultwarden-backup-YYYYMMDD.tar.gz -C /data
# Levantar Vaultwarden test
docker run -d --name vaultwarden-test \
-v vaultwarden_test:/data \
-p 8081:80 \
vaultwarden/server:latest
# Probar acceso
curl http://localhost:8081
# Limpiar
docker stop vaultwarden-test
docker rm vaultwarden-test
docker volume rm vaultwarden_test
```
### Verificar Integridad de SQLite
```bash
# Verificar que la DB no está corrupta
docker run --rm \
-v vaultwarden_data:/data:ro \
nouchka/sqlite3 \
sqlite3 /data/db.sqlite3 "PRAGMA integrity_check;"
```
Debería devolver: `ok`
### Listar Backups Disponibles
```bash
# Ver backups y sus tamaños
ls -lh $HOME/backups/vaultwarden/
# Ver el más reciente
ls -lt $HOME/backups/vaultwarden/ | head -n 2
# Verificar que no están vacíos
find $HOME/backups/vaultwarden/ -type f -size 0
```
## 📊 Monitorización de Backups
### Script de Verificación Diaria
```bash
#!/bin/bash
# verify-backup.sh
BACKUP_DIR="$HOME/backups/vaultwarden"
MAX_AGE_HOURS=30 # Alerta si el último backup tiene más de 30 horas
LATEST_BACKUP=$(ls -t "$BACKUP_DIR"/vaultwarden-backup-*.tar.gz | head -n 1)
if [ -z "$LATEST_BACKUP" ]; then
echo "❌ ERROR: No se encontraron backups"
exit 1
fi
# Verificar edad
BACKUP_AGE=$(( ($(date +%s) - $(stat -c %Y "$LATEST_BACKUP")) / 3600 ))
if [ $BACKUP_AGE -gt $MAX_AGE_HOURS ]; then
echo "⚠️ ADVERTENCIA: Último backup tiene ${BACKUP_AGE} horas"
echo "Backup: $LATEST_BACKUP"
exit 1
else
echo "✅ Backup reciente: ${BACKUP_AGE} horas"
echo "Backup: $LATEST_BACKUP"
fi
```
### Notificaciones (Opcional)
Envía alertas si los backups fallan:
```bash
# Al final del script de backup
if [ $? -eq 0 ]; then
curl -X POST https://hooks.slack.com/services/TU_WEBHOOK \
-d '{"text":"✅ Backup de Vaultwarden completado"}'
else
curl -X POST https://hooks.slack.com/services/TU_WEBHOOK \
-d '{"text":"❌ ERROR en backup de Vaultwarden"}'
fi
```
## 🔐 Cifrar Backups
Los backups contienen todas las contraseñas. Cífralos para almacenamiento externo:
### Con GPG
```bash
# Backup y cifrado
tar czf - -C /var/lib/docker/volumes/vaultwarden_data/_data . | \
gpg --symmetric --cipher-algo AES256 > vaultwarden-backup.tar.gz.gpg
# Descifrado
gpg --decrypt vaultwarden-backup.tar.gz.gpg | tar xzf -
```
### Con OpenSSL
```bash
# Cifrar
openssl enc -aes-256-cbc -salt \
-in vaultwarden-backup.tar.gz \
-out vaultwarden-backup.tar.gz.enc
# Descifrar
openssl enc -aes-256-cbc -d \
-in vaultwarden-backup.tar.gz.enc \
-out vaultwarden-backup.tar.gz
```
## 📖 Checklist de Backup
- [ ] Backups automáticos configurados (diarios mínimo)
- [ ] Backups almacenados en al menos 2 ubicaciones
- [ ] Al menos 1 backup offsite (fuera del servidor)
- [ ] Backups cifrados si se almacenan en cloud
- [ ] Script de restauración probado al menos una vez
- [ ] Monitorización de backups (verificar que se ejecutan)
- [ ] Rotación de backups (no llenar el disco)
- [ ] Documentación de cómo restaurar
## 🆘 Escenarios de Desastre
### Servidor Completamente Muerto
1. Montar nuevo servidor
2. Instalar Docker
3. Clonar repo de Vaultwarden
4. Configurar variables de entorno
5. Restaurar backup en volumen nuevo
6. Iniciar stack
7. Actualizar DNS si cambió la IP
### Base de Datos Corrupta
1. Detener Vaultwarden
2. Renombrar db corrupta: `mv db.sqlite3 db.sqlite3.corrupted`
3. Restaurar desde backup más reciente
4. Verificar integridad: `sqlite3 db.sqlite3 "PRAGMA integrity_check;"`
5. Reiniciar Vaultwarden
### Volumen Docker Borrado Accidentalmente
```bash
# Recrear volumen
docker volume create vaultwarden_data
# Restaurar inmediatamente desde backup
bash restore-vaultwarden.sh
```
---
**Última actualización**: Diciembre 2025
⚠️ **RECUERDA**: Un backup de 6 meses vale más que 10 veces lo que cuesta hacerlo. **Automatiza ahora**.

350
Configuración-Inicial.md Normal file

@@ -0,0 +1,350 @@
# Configuración Inicial
Una vez desplegado Vaultwarden, sigue estos pasos para configurarlo correctamente.
## 📋 Lista de Verificación
Antes de empezar, asegúrate de haber completado:
- ✅ Vaultwarden desplegado con [Traefik](Traefik), [NPM](NPM) o [Standalone](Standalone)
- ✅ Acceso a `https://vaultwarden.tudominio.com` (o HTTP en standalone)
- ✅ ADMIN_TOKEN generado y configurado
- ✅ Certificado SSL válido (si usas Traefik o NPM)
## 🔐 1. Acceder al Panel de Administración
### Acceso Inicial
1. Abre tu navegador
2. Ve a: `https://vaultwarden.tudominio.com/admin`
3. Introduce tu `ADMIN_TOKEN`
4. Haz clic en **Enter**
⚠️ **Importante**: Si no puedes acceder, verifica que `ADMIN_TOKEN` está correctamente configurado en las variables de entorno.
### Recuperar ADMIN_TOKEN
Si olvidaste tu token:
```bash
# Ver el token actual
docker compose exec vaultwarden env | grep ADMIN_TOKEN
# O revisa el archivo .env
cat .env | grep ADMIN_TOKEN
```
### Cambiar ADMIN_TOKEN
Si quieres cambiar el token:
1. Genera uno nuevo: `openssl rand -base64 48`
2. Actualiza la variable de entorno:
- **Portainer**: Stack → Environment variables → Editar
- **CLI**: Editar `.env` y ejecutar `docker compose up -d`
3. Accede a `/admin` con el nuevo token
## ⚙️ 2. Configuración General
En el panel de administración, ve a **General Settings**.
### Domain URL
**Campo**: `Domain URL`
**Valor**: `https://vaultwarden.tudominio.com` (tu dominio completo con protocolo)
Este valor **debe coincidir** con la variable `DOMAIN` del docker-compose.
⚠️ **Crítico**: Un valor incorrecto causará problemas con:
- Links de verificación de email
- Redirecciones después del login
- Funcionalidades de la API
### Iconos de Servicios
**Campo**: `Icon Download Timeout`
**Valor recomendado**: `10` (segundos)
Vaultwarden puede descargar iconos de servicios (Google, GitHub, etc.) para mostrarlos en la interfaz.
**Opciones**:
- ✅ Dejar activado: Mejor experiencia visual
- ❌ Desactivar: Añadir `ICON_SERVICE=none` en variables de entorno (más privacidad)
### Permitir Invitaciones
**Campo**: `Invitation Organization Name`
**Valor**: Nombre de tu organización (ej: "Mi Empresa IT")
Aparecerá en los emails de invitación cuando añadas usuarios.
## 👥 3. Configuración de Usuarios
En **User Settings**, configura el registro y gestión de usuarios.
### Permitir Nuevos Registros
**Campo**: `Allow new signups`
**Valor recomendado**: **❌ Desactivado** (false)
**Razones**:
- 🔒 Evita registros no autorizados
- 🔒 Control total sobre quién accede
- 🔒 Previene abuso del servidor
**Métodos alternativos para añadir usuarios**:
1. **Invitaciones** (recomendado): Desde `/admin` → Users → Invite User
2. **Registro temporal**: Activa `SIGNUPS_ALLOWED=true` temporalmente, crea las cuentas, desactívalo
### Verificación de Email
**Campo**: `Require Email Verification`
**Recomendado**: ✅ Activar (requiere SMTP configurado)
Beneficios:
- Verifica que el email es válido
- Previene cuentas con emails falsos
- Mejora la recuperación de cuenta
### Mostrar Pistas de Contraseña
**Campo**: `Show password hints`
**Valor recomendado**: **❌ Desactivado**
Las pistas de contraseña son un riesgo de seguridad. Mejor usar:
- Contraseñas generadas aleatoriamente
- Notas cifradas en Vaultwarden
- Organizaciones para compartir
## 🔐 4. Configuración de Seguridad
### Activar 2FA (Autenticación de Dos Factores)
Vaultwarden soporta varios métodos de 2FA:
#### Para Usuarios
1. Cada usuario debe configurarlo desde su cuenta:
- Login → Configuración → Seguridad → Two-step Login
2. Métodos disponibles:
- **Authenticator App** (TOTP): Google Authenticator, Authy, etc.
- **Email**: Código enviado por email (requiere SMTP)
- **Yubikey**: Llaves de seguridad hardware
#### Para el Admin Panel
Considera proteger `/admin` adicionalmente:
**Con Traefik** (middleware de autenticación):
```yaml
labels:
- "traefik.http.routers.vaultwarden-admin.rule=Host(`${DOMAIN_HOST}`) && PathPrefix(`/admin`)"
- "traefik.http.routers.vaultwarden-admin.middlewares=admin-auth"
- "traefik.http.middlewares.admin-auth.basicauth.users=admin:$$apr1$$hashedpassword"
```
**Con NPM** (Access List en la interfaz)
### Desactivar el Admin Panel (Producción)
En entornos de alta seguridad, una vez configurado todo:
```env
# Añadir a variables de entorno
ADMIN_INTERFACE_ENABLED=false
```
Esto **desactiva completamente** el panel de administración. Solo hazlo si:
- ✅ Has completado toda la configuración
- ✅ Tienes backups
- ✅ No necesitas hacer cambios frecuentes
Para reactivarlo, cambia a `true` y redesplega.
## 🔄 5. WebSocket y Notificaciones
### Verificar WebSocket
WebSocket permite sincronización en tiempo real entre dispositivos.
```bash
docker compose logs vaultwarden | grep -i websocket
```
Deberías ver:
```
[INFO] WebSocket server listening on 0.0.0.0:3012
```
### Probar desde Cliente
1. Abre Vaultwarden en un navegador
2. Abre la app móvil en otro dispositivo
3. Añade una contraseña en uno
4. Debería aparecer **inmediatamente** en el otro
Si tarda minutos:
- **Con Traefik**: Debería funcionar automáticamente
- **Con NPM**: Verifica que **WebSocket Support** está activado en el Proxy Host
## 📊 6. Monitorización y Logs
### Configurar Nivel de Logs
En variables de entorno:
```env
LOG_LEVEL=warn # Valores: error, warn, info, debug, trace
```
**Recomendaciones**:
- **Producción**: `warn` (por defecto)
- **Debugging**: `debug` o `trace`
### Ver Logs en Tiempo Real
```bash
# Logs generales
docker compose logs -f vaultwarden
# Logs de acceso
docker compose exec vaultwarden cat /data/vaultwarden.log
# Filtrar por nivel
docker compose logs vaultwarden | grep ERROR
```
### Rotación de Logs
Vaultwarden no rota logs automáticamente. Para evitar que crezcan infinitamente:
**Opción 1: Límite de Docker**
Edita `/etc/docker/daemon.json`:
```json
{
"log-driver": "json-file",
"log-opts": {
"max-size": "10m",
"max-file": "3"
}
}
```
Reinicia Docker: `sudo systemctl restart docker`
**Opción 2: Logrotate**
Crea `/etc/logrotate.d/vaultwarden`:
```
/var/lib/docker/volumes/vaultwarden_data/_data/vaultwarden.log {
daily
rotate 7
compress
missingok
notifempty
}
```
## 🌐 7. Usuarios y Organizaciones
### Invitar Primer Usuario
Si `SIGNUPS_ALLOWED=false`:
1. Ve a `/admin`
2. **Users** → **Invite User**
3. Introduce el email
4. El usuario recibirá un email de invitación (requiere SMTP)
5. Sin SMTP, muestra un link que puedes copiar y enviar manualmente
### Crear una Organización
Las organizaciones permiten compartir contraseñas de forma segura:
1. Login como usuario normal (no admin)
2. **New** → **Organization**
3. Nombre de la organización
4. Invita miembros
5. Crea colecciones (categorías de contraseñas)
6. Comparte ítems con la organización
**Casos de uso**:
- 🏢 Contraseñas del equipo de IT
- 💼 Accesos compartidos de clientes
- 👨‍👩‍👧‍👦 Contraseñas familiares
## 📧 8. SMTP (Opcional pero Recomendado)
Configurar SMTP permite:
- ✅ Verificación de emails
- ✅ Invitaciones automáticas
- ✅ Notificaciones de seguridad
- ✅ Recuperación de cuenta (emergencias)
Ver detalles completos en **[Personalización - Configurar SMTP](Personalización#configurar-smtp)**.
## ✅ 9. Verificación Final
Completa esta checklist antes de dar por finalizada la configuración:
### Checklist de Seguridad
- [ ] ADMIN_TOKEN es fuerte (mín. 32 caracteres)
- [ ] `SIGNUPS_ALLOWED=false` configurado
- [ ] HTTPS funcionando (certificado válido)
- [ ] WebSocket funcionando (sincronización instantánea)
- [ ] Panel `/admin` accesible solo por ti
- [ ] SMTP configurado (o método alternativo para invitaciones)
- [ ] Primer usuario creado y puede hacer login
- [ ] 2FA activado en cuenta de admin
- [ ] Backup inicial realizado
### Checklist de Funcionalidad
- [ ] Puedes crear una nueva entrada de contraseña
- [ ] La entrada se sincroniza a otro dispositivo inmediatamente
- [ ] Puedes instalar la extensión del navegador
- [ ] La extensión auto-rellena formularios correctamente
- [ ] Puedes crear una organización
- [ ] Puedes invitar a otro usuario
- [ ] El generador de contraseñas funciona
## 📖 Siguientes Pasos
- **[Personalización](Personalización)**: SMTP, temas, límites, etc.
- **[Backup y Restauración](Backup-y-Restauración)**: **CRÍTICO** - configura backups inmediatamente
- **[Solución de Problemas](Solución-de-Problemas)**: Si algo no funciona
## 🆘 Problemas Comunes
### No puedo acceder a /admin
**Causa**: ADMIN_TOKEN incorrecto o no configurado
**Solución**:
```bash
# Ver token actual
docker compose exec vaultwarden env | grep ADMIN_TOKEN
# Verificar que coincide con el que introduces
```
### Los emails no se envían
**Causa**: SMTP no configurado o configurado incorrectamente
**Solución**: Ver **[Personalización - SMTP](Personalización#configurar-smtp)**
### WebSocket no funciona
**Causa**: Configuración del proxy
**Solución**:
- **Traefik**: Debería funcionar automáticamente, revisa logs
- **NPM**: Activa **WebSocket Support** en el Proxy Host
- Ver **[Solución de Problemas - WebSocket](Solución-de-Problemas#websocket-no-funciona)**
---
**Última actualización**: Diciembre 2025

91
Home.md

@@ -1 +1,90 @@
¡Bienvenidos a la Wiki! # Wiki de Vaultwarden
Bienvenido a la wiki de **Vaultwarden**, un gestor de contraseñas autoalojado compatible con Bitwarden.
## 📋 Índice de Contenidos
### Despliegue
- **[Traefik](Traefik)**: Despliegue con Traefik como reverse proxy (recomendado)
- **[Nginx Proxy Manager](NPM)**: Despliegue con Nginx Proxy Manager
- **[Standalone](Standalone)**: Despliegue sin proxy (solo testing)
### Configuración y Mantenimiento
- **[Configuración Inicial](Configuración-Inicial)**: Primeros pasos tras el despliegue
- **[Personalización](Personalización)**: Configurar SMTP, usuarios, organizaciones
- **[Backup y Restauración](Backup-y-Restauración)**: Protege tus contraseñas
- **[Actualización](Actualización)**: Mantener Vaultwarden actualizado
- **[Solución de Problemas](Solución-de-Problemas)**: Resolver errores comunes
## 🔐 ¿Qué es Vaultwarden?
Vaultwarden es una implementación alternativa del servidor Bitwarden escrita en Rust. Ofrece las mismas funcionalidades que Bitwarden oficial pero con:
- 🚀 **Menor consumo de recursos**: Ideal para self-hosting
- 💰 **Todas las características gratuitas**: Incluye organizaciones, 2FA, etc.
- 🔒 **Mismo nivel de seguridad**: Cifrado de extremo a extremo
- 📱 **Compatible 100%**: Usa los clientes oficiales de Bitwarden
## ⚠️ Consideraciones de Seguridad
Antes de desplegar Vaultwarden:
1. **HTTPS es obligatorio**: Los clientes de Bitwarden requieren conexión segura
2. **ADMIN_TOKEN fuerte**: Genera un token de al menos 32 caracteres
3. **Backups regulares**: Un gestor de contraseñas sin backup es un riesgo crítico
4. **Desactiva registros públicos**: Establece `SIGNUPS_ALLOWED=false`
5. **Contraseña maestra única**: No la reutilices en otros servicios
6. **Habilita 2FA**: Protege tu cuenta con autenticación de dos factores
## 🚀 Inicio Rápido
### Generar ADMIN_TOKEN
Antes de cualquier despliegue, genera un token seguro:
```bash
openssl rand -base64 48
```
### Elección del Modo de Despliegue
| Modo | Recomendado | Requisitos | Características |
|------|-------------|------------|-----------------|
| **Traefik** | ✅ Sí | Red `proxy`, Traefik con Let's Encrypt | SSL automático, WebSocket integrado |
| **NPM** | ⚠️ Aceptable | Red `proxy`, NPM configurado | Requiere activar WebSocket manualmente |
| **Standalone** | ❌ No | Solo Docker | Solo para testing local, sin HTTPS |
### Variables de Entorno Comunes
Todas las configuraciones requieren estas variables:
```env
DOMAIN=https://vaultwarden.tudominio.com # Con protocolo en Traefik/NPM
ADMIN_TOKEN=tu_token_generado_con_openssl
SIGNUPS_ALLOWED=false # Desactiva registros públicos
```
**Para Traefik** necesitas también:
```env
DOMAIN_HOST=vaultwarden.tudominio.com # Sin protocolo
```
## 📚 Recursos Adicionales
- [README del repositorio](https://git.ictiberia.com/groales/vaultwarden)
- [Documentación oficial de Vaultwarden](https://github.com/dani-garcia/vaultwarden/wiki)
- [Clientes de Bitwarden](https://bitwarden.com/download/)
- [Comunidad de Vaultwarden](https://github.com/dani-garcia/vaultwarden/discussions)
## 🆘 Soporte
Si encuentras problemas:
1. Consulta la página **[Solución de Problemas](Solución-de-Problemas)**
2. Revisa los logs: `docker compose logs vaultwarden`
3. Verifica la configuración en `/admin`
4. Consulta la documentación oficial de Vaultwarden
---
**Última actualización**: Diciembre 2025

365
NPM.md Normal file

@@ -0,0 +1,365 @@
# Despliegue con Nginx Proxy Manager
Esta guía explica cómo desplegar Vaultwarden usando **Nginx Proxy Manager (NPM)** como reverse proxy.
## ⚠️ Consideración Importante
A diferencia de Traefik, con NPM necesitas **configurar WebSocket manualmente** desde la interfaz web. Este paso es crítico para que la sincronización en tiempo real funcione correctamente.
## 📋 Requisitos Previos
Antes de comenzar, asegúrate de tener:
- ✅ Nginx Proxy Manager funcionando y accesible
- ✅ Red Docker `proxy` creada y NPM conectado a ella
- ✅ Dominio configurado apuntando a tu servidor
- ✅ Puertos 80 y 443 abiertos y dirigidos a NPM
- ✅ ADMIN_TOKEN generado
### Verificar Red Proxy
```bash
docker network ls | grep proxy
```
Si no existe, créala:
```bash
docker network create proxy
```
### Generar ADMIN_TOKEN
```bash
openssl rand -base64 48
```
Guarda el resultado, lo necesitarás para las variables de entorno.
## 🚀 Despliegue desde Portainer
### Opción A: Git Repository (Recomendada)
Esta opción mantiene tu stack actualizado con el repositorio Git.
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Git Repository**
4. Configura el repositorio:
- **Repository URL**: `https://git.ictiberia.com/groales/vaultwarden`
- **Repository reference**: `refs/heads/main`
- **Compose path**: `docker-compose.yml`
- **Additional paths**: `docker-compose.override.npm.yml.example`
5. En **Environment variables**, añade:
```env
DOMAIN=https://vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
⚠️ **Nota**: A diferencia de Traefik, aquí NO necesitas `DOMAIN_HOST` separado.
6. Haz clic en **Deploy the stack**
### Opción B: Web Editor
Si prefieres tener el compose completo en Portainer:
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Web editor**
4. Copia y pega este contenido:
```yaml
services:
vaultwarden:
container_name: vaultwarden
image: vaultwarden/server:latest
restart: unless-stopped
environment:
DOMAIN: ${DOMAIN}
SIGNUPS_ALLOWED: ${SIGNUPS_ALLOWED:-false}
ADMIN_TOKEN: ${ADMIN_TOKEN}
WEBSOCKET_ENABLED: true
LOG_FILE: /data/vaultwarden.log
LOG_LEVEL: warn
TZ: Europe/Madrid
volumes:
- vaultwarden_data:/data
networks:
- proxy
networks:
proxy:
external: true
volumes:
vaultwarden_data:
driver: local
```
5. En **Environment variables**, añade las mismas variables que en la Opción A
6. Haz clic en **Deploy the stack**
## 🖥️ Despliegue desde CLI
### 1. Clonar el repositorio
```bash
git clone https://git.ictiberia.com/groales/vaultwarden.git
cd vaultwarden
```
### 2. Copiar el archivo override
```bash
cp docker-compose.override.npm.yml.example docker-compose.override.yml
```
### 3. Crear archivo .env
Crea un archivo `.env` con el siguiente contenido:
```env
DOMAIN=https://vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
### 4. Iniciar el servicio
```bash
docker compose up -d
```
### 5. Verificar el despliegue
```bash
# Ver logs
docker compose logs -f vaultwarden
# Verificar que el contenedor está corriendo
docker compose ps
```
## 🔧 Configuración en Nginx Proxy Manager
Una vez el contenedor está corriendo, debes configurar el Proxy Host en NPM.
### 1. Acceder a NPM
Ve a la interfaz web de Nginx Proxy Manager (normalmente `http://tu-servidor:81`).
### 2. Crear Proxy Host
1. Ve a **Proxy Hosts** → **Add Proxy Host**
2. En la pestaña **Details**:
- **Domain Names**: `vaultwarden.tudominio.com`
- **Scheme**: `http` (sí, HTTP, porque es interno)
- **Forward Hostname / IP**: `vaultwarden` (nombre del contenedor)
- **Forward Port**: `80`
- ✅ **Cache Assets**: Activar
- ✅ **Block Common Exploits**: Activar
- ✅ **Websockets Support**: **⚠️ CRÍTICO - ACTIVAR**
3. En la pestaña **SSL**:
- ✅ **Force SSL**: Activar
- **SSL Certificate**: Selecciona "Request a new SSL Certificate"
- ✅ **Force SSL**: Activar
- ✅ **HTTP/2 Support**: Activar
- ✅ **HSTS Enabled**: Activar (recomendado)
- Email: Tu email para Let's Encrypt
- ✅ **I Agree to the Let's Encrypt Terms of Service**
4. Haz clic en **Save**
### 3. Configuración Avanzada (Opcional)
Si quieres añadir headers de seguridad adicionales:
1. Edita el Proxy Host creado
2. Ve a la pestaña **Advanced**
3. Añade en **Custom Nginx Configuration**:
```nginx
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
# WebSocket headers
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
```
4. Guarda los cambios
## ⚠️ WebSocket Support - CRÍTICO
El **WebSocket Support** es **imprescindible** para Vaultwarden. Sin él:
- ❌ No habrá sincronización en tiempo real
- ❌ Los cambios tardarán minutos en aparecer en otros dispositivos
- ❌ La experiencia de usuario será deficiente
### Verificar WebSocket
1. En NPM, edita el Proxy Host de Vaultwarden
2. En la pestaña **Details**, verifica que **Websockets Support** está ✅ activado
3. Si no lo está, actívalo y guarda
### Probar WebSocket desde CLI
```bash
# Instalar wscat si no lo tienes
npm install -g wscat
# Probar conexión WebSocket
wscat -c wss://vaultwarden.tudominio.com/notifications/hub
```
Si funciona, verás una conexión establecida. Si falla, revisa la configuración de NPM.
## ✅ Verificación del Despliegue
### 1. Verificar Acceso Web
Abre tu navegador y ve a: `https://vaultwarden.tudominio.com`
Deberías ver la página de login/registro de Vaultwarden con certificado SSL válido (candado verde).
### 2. Verificar Certificado SSL
Haz clic en el candado del navegador y verifica:
- ✅ Certificado emitido por Let's Encrypt
- ✅ Válido y no caducado
- ✅ Sin errores de nombre de dominio
### 3. Verificar WebSocket en Logs
```bash
docker compose logs vaultwarden | grep -i websocket
```
Deberías ver:
```
[INFO] WebSocket server listening on 0.0.0.0:3012
```
### 4. Verificar Panel de Administración
Ve a: `https://vaultwarden.tudominio.com/admin`
Introduce tu `ADMIN_TOKEN`. Si puedes acceder, la configuración es correcta.
### 5. Prueba de Sincronización
1. Crea una cuenta en Vaultwarden
2. Añade una contraseña desde la interfaz web
3. Instala la app móvil de Bitwarden
4. Configura el servidor: `https://vaultwarden.tudominio.com`
5. Inicia sesión
6. La contraseña debería aparecer **inmediatamente** (si WebSocket funciona)
Si la sincronización tarda minutos, **WebSocket NO está funcionando**.
## 🔒 Seguridad Adicional
### Restringir Acceso por IP al Admin Panel
Puedes limitar el acceso al panel `/admin` desde la configuración avanzada de NPM:
1. Edita el Proxy Host de Vaultwarden
2. Ve a **Advanced**
3. Añade:
```nginx
# Permitir solo desde tu IP
location /admin {
allow 192.168.1.100; # Tu IP
deny all;
proxy_pass http://vaultwarden:80;
}
```
### Headers de Seguridad
Ya añadidos en la configuración opcional anterior, incluyen:
- `X-Frame-Options`: Previene clickjacking
- `X-Content-Type-Options`: Previene MIME sniffing
- `X-XSS-Protection`: Protección XSS
- `Referrer-Policy`: Control de referrer
## 🔄 Actualización
Desde Portainer (Git Repository):
1. Ve al stack `vaultwarden`
2. Clic en **Pull and redeploy**
Desde CLI:
```bash
docker compose pull
docker compose up -d
```
**Nota**: No necesitas cambiar nada en NPM al actualizar, el Proxy Host seguirá funcionando.
## 📖 Siguientes Pasos
- **[Configuración Inicial](Configuración-Inicial)**: Configura el panel de administración
- **[Personalización](Personalización)**: Ajusta SMTP, usuarios y organizaciones
- **[Backup y Restauración](Backup-y-Restauración)**: Protege tus datos
## 🆘 Solución de Problemas
### Error 502 Bad Gateway
**Síntoma**: NPM muestra error 502
**Solución**:
1. Verifica que el contenedor está corriendo: `docker compose ps`
2. Comprueba que ambos están en la red `proxy`:
```bash
docker network inspect proxy
```
3. Verifica el nombre del contenedor es exactamente `vaultwarden`
4. Revisa logs de NPM y Vaultwarden
### WebSocket no funciona
**Síntoma**: Sincronización muy lenta
**Solución**:
1. ✅ Activa **Websockets Support** en el Proxy Host de NPM
2. Verifica en logs: `docker compose logs vaultwarden | grep websocket`
3. Limpia caché del navegador
4. Prueba con `wscat` como se indicó arriba
### Certificado SSL no se renueva
**Síntoma**: Advertencia de certificado caducado
**Solución**:
1. En NPM, edita el Proxy Host
2. Pestaña **SSL** → Click en **Force Renew**
3. Verifica que el puerto 80 está abierto (Let's Encrypt lo necesita)
4. Revisa logs de NPM para errores de renovación
### No puedo acceder al admin panel
**Síntoma**: Error al acceder a `/admin`
**Solución**:
1. Verifica que `ADMIN_TOKEN` está configurado correctamente
2. Prueba regenerar el token: `openssl rand -base64 48`
3. Actualiza las variables de entorno en Portainer
4. Redesplegar el stack
---
**Última actualización**: Diciembre 2025

458
Personalización.md Normal file

@@ -0,0 +1,458 @@
# Personalización
Esta guía cubre opciones avanzadas de personalización para adaptar Vaultwarden a tus necesidades específicas.
## 📧 Configurar SMTP
SMTP permite a Vaultwarden enviar emails para:
- Verificación de cuentas nuevas
- Invitaciones a usuarios
- Códigos 2FA por email
- Notificaciones de seguridad
### Variables SMTP
Añade estas variables de entorno a tu configuración:
```env
# Servidor SMTP
SMTP_HOST=smtp.tudominio.com
SMTP_FROM=vaultwarden@tudominio.com
SMTP_PORT=587
SMTP_SECURITY=starttls
# Autenticación
SMTP_USERNAME=vaultwarden@tudominio.com
SMTP_PASSWORD=tu_password_smtp
# Opcional
SMTP_TIMEOUT=15
```
### Configuración según Proveedor
<details>
<summary>📮 Gmail</summary>
⚠️ Requiere "App Password" (contraseña de aplicación):
1. Ve a https://myaccount.google.com/security
2. Activa verificación en 2 pasos
3. Genera una App Password
4. Usa estos valores:
```env
SMTP_HOST=smtp.gmail.com
SMTP_FROM=tucuenta@gmail.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_USERNAME=tucuenta@gmail.com
SMTP_PASSWORD=app_password_generada
```
</details>
<details>
<summary>📮 Outlook / Microsoft 365</summary>
```env
SMTP_HOST=smtp.office365.com
SMTP_FROM=tucuenta@outlook.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_USERNAME=tucuenta@outlook.com
SMTP_PASSWORD=tu_password
```
Para cuentas corporativas M365, usa:
```env
SMTP_HOST=smtp.office365.com
SMTP_FROM=tucuenta@tuempresa.com
```
</details>
<details>
<summary>📮 Servidor SMTP Propio</summary>
```env
SMTP_HOST=mail.tudominio.com
SMTP_FROM=noreply@tudominio.com
SMTP_PORT=587 # O 465 para SSL directo
SMTP_SECURITY=starttls # O 'ssl' para puerto 465
SMTP_USERNAME=usuario_smtp
SMTP_PASSWORD=password_smtp
```
</details>
### Aplicar Configuración SMTP
**Desde Portainer**:
1. Ve a tu stack `vaultwarden`
2. **Environment variables** → Añade las variables SMTP
3. **Update the stack**
**Desde CLI**:
1. Edita `.env` y añade las variables
2. Ejecuta: `docker compose up -d`
### Probar SMTP
1. Ve a `/admin`
2. **General Settings** → Scroll down
3. **Test SMTP** → Introduce un email
4. Haz clic en **Send test email**
5. Verifica que recibiste el email
Si falla, revisa los logs:
```bash
docker compose logs vaultwarden | grep -i smtp
```
## 👤 Configuración de Usuarios
### Límite de Usuarios
Para limitar el número de cuentas:
```env
USER_LIMIT=50 # Máximo 50 usuarios
```
Cuando se alcance el límite:
- ❌ No se permiten más registros
- ❌ No se pueden enviar más invitaciones
- ✅ Los usuarios existentes siguen funcionando
### Dominio Permitido para Emails
Restringir registros solo a ciertos dominios:
```env
SIGNUPS_DOMAINS_WHITELIST=tuempresa.com,otrodominio.com
```
Solo emails con `@tuempresa.com` o `@otrodominio.com` podrán registrarse.
### Verificación de Email Obligatoria
```env
SIGNUPS_VERIFY=true
```
Los usuarios no podrán usar Vaultwarden hasta verificar su email (requiere SMTP).
### Desactivar Registros pero Permitir Invitaciones
```env
SIGNUPS_ALLOWED=false
INVITATIONS_ALLOWED=true
```
- ❌ No hay registro público
- ✅ Los admins pueden enviar invitaciones desde `/admin`
## 🎨 Personalización Visual
### Cambiar el Nombre
Por defecto muestra "Bitwarden". Para personalizarlo:
```env
ORG_NAME=Mi Empresa IT
```
Aparecerá en:
- Título de la página
- Emails enviados
- Invitaciones
### Favicon Personalizado
Vaultwarden usa el favicon de Bitwarden por defecto. Para cambiarlo:
1. Monta un volumen con tu favicon:
```yaml
volumes:
- vaultwarden_data:/data
- ./custom/favicon.ico:/web-vault/favicon.ico:ro
```
2. Crea `./custom/favicon.ico` con tu icono
### Deshabilitar Iconos de Servicios
Por privacidad, puedes deshabilitar la descarga de iconos:
```env
ICON_SERVICE=none
```
Ventajas:
- 🔒 No se hacen requests externos
- 🚀 Ligeramente más rápido
- 🔐 Más privacidad
Desventaja:
- No verás iconos bonitos de Google, GitHub, etc.
## 🔒 Seguridad Avanzada
### Session Timeout
Controla cuánto tiempo permanecen activas las sesiones:
```env
# Segundos antes de pedir re-autenticación
SESSION_TIMEOUT=3600 # 1 hora
# Segundos antes de cerrar sesión completamente
IDLE_TIMEOUT=7200 # 2 horas
```
### Restringir Creación de Organizaciones
```env
ORG_CREATION_USERS=admin@tudominio.com,manager@tudominio.com
```
Solo estos usuarios podrán crear organizaciones. Otros pueden unirse pero no crear.
### Limitar Adjuntos
Los usuarios pueden adjuntar archivos a las contraseñas (ej: certificados, llaves SSH):
```env
# Tamaño máximo por adjunto (en KB)
ATTACHMENT_LIMIT=10240 # 10 MB
# Tamaño total máximo para un usuario (en KB)
USER_ATTACHMENT_LIMIT=102400 # 100 MB
```
### Deshabilitar Completamente el Registro
Incluso para admins:
```env
SIGNUPS_ALLOWED=false
INVITATIONS_ALLOWED=false
```
Útil cuando ya tienes todas las cuentas creadas y quieres cerrar completamente el acceso.
## 📊 Base de Datos
### SQLite (Por Defecto)
Vaultwarden usa SQLite, que es perfecto para la mayoría de casos:
- ✅ Sin configuración adicional
- ✅ Backups sencillos
- ✅ Eficiente para <1000 usuarios
- ✅ Todo en el volumen `/data`
No requiere cambios, funciona out-of-the-box.
### Migrar a PostgreSQL (Avanzado)
Para instalaciones muy grandes (>500 usuarios):
```env
DATABASE_URL=postgresql://usuario:password@postgres:5432/vaultwarden
```
⚠️ **Requiere**:
1. Contenedor PostgreSQL adicional
2. Migración manual de datos
3. Backups más complejos
No es necesario para la mayoría de despliegues.
### Migrar a MySQL/MariaDB (Avanzado)
```env
DATABASE_URL=mysql://usuario:password@mysql:3306/vaultwarden
```
Similar a PostgreSQL, solo para casos muy específicos.
## 🔔 Notificaciones Push
Vaultwarden puede enviar notificaciones push a dispositivos móviles:
```env
PUSH_ENABLED=true
PUSH_INSTALLATION_ID=tu_id
PUSH_INSTALLATION_KEY=tu_key
```
⚠️ **Limitaciones**:
- Requiere registro en el servicio de Bitwarden
- Solo funciona con apps móviles oficiales
- La mayoría de usuarios no lo necesitan (WebSocket es suficiente)
Para la mayoría: **déjalo desactivado** y usa WebSocket.
## 🌍 Localización
### Zona Horaria
```env
TZ=Europe/Madrid # Ya configurado en el docker-compose
```
Otras opciones:
- `America/New_York`
- `Asia/Tokyo`
- `UTC`
Lista completa: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
### Formato de Logs
```env
LOG_TIMESTAMP_FORMAT=%Y-%m-%d %H:%M:%S
```
Personaliza cómo aparecen las fechas en los logs.
## 🔧 Rendimiento
### Workers
Vaultwarden usa Rocket (framework web). Para mayor rendimiento:
```env
ROCKET_WORKERS=10 # Por defecto: número de CPUs
```
Aumenta si tienes muchos usuarios concurrentes.
### Database Pool
```env
DATABASE_MAX_CONNS=10 # Conexiones simultáneas a la DB
```
Aumenta si ves errores de "database locked" con muchos usuarios.
### Cache
Iconos de servicios se cachean automáticamente:
```env
ICON_CACHE_TTL=2592000 # Segundos (30 días por defecto)
ICON_CACHE_NEGTTL=259200 # Cache para iconos no encontrados (3 días)
```
## 🔐 Yubico OTP (Yubikey)
Soporte para llaves de hardware Yubikey:
```env
YUBICO_CLIENT_ID=tu_client_id
YUBICO_SECRET_KEY=tu_secret_key
```
Obtén credenciales en: https://upgrade.yubico.com/getapikey/
Los usuarios podrán usar sus Yubikeys para 2FA.
## 🌐 Configuración de Red
### IP y Puerto Interno
Por defecto Vaultwarden escucha en `0.0.0.0:80`:
```env
ROCKET_ADDRESS=0.0.0.0
ROCKET_PORT=80
```
Generalmente no necesitas cambiar esto (el proxy se encarga del resto).
### WebSocket en Puerto Diferente
Por defecto WebSocket usa el puerto 3012. Para cambiarlo:
```env
WEBSOCKET_PORT=3012
```
Si cambias esto, actualiza también:
- Labels de Traefik
- Configuración de NPM
- Puerto publicado en Standalone
## 📝 Ejemplo de Configuración Completa
Un archivo `.env` típico para producción:
```env
# Dominio
DOMAIN=https://vaultwarden.empresa.com
DOMAIN_HOST=vaultwarden.empresa.com
# Seguridad
ADMIN_TOKEN=token_generado_con_openssl_rand_base64_48
SIGNUPS_ALLOWED=false
INVITATIONS_ALLOWED=true
SIGNUPS_VERIFY=true
# SMTP
SMTP_HOST=smtp.office365.com
SMTP_FROM=noreply@empresa.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_USERNAME=noreply@empresa.com
SMTP_PASSWORD=password_seguro
# Límites
USER_LIMIT=100
ATTACHMENT_LIMIT=10240
USER_ATTACHMENT_LIMIT=102400
# Restricciones
SIGNUPS_DOMAINS_WHITELIST=empresa.com
ORG_CREATION_USERS=admin@empresa.com
# Personalización
ORG_NAME=Empresa S.L.
# Sistema
TZ=Europe/Madrid
LOG_LEVEL=warn
# WebSocket
WEBSOCKET_ENABLED=true
```
## 🔄 Aplicar Cambios
Después de cambiar variables de entorno:
**Portainer**:
1. Stack → Environment variables → Editar
2. Update the stack
**CLI**:
```bash
# Edita .env
nano .env
# Recrea el contenedor
docker compose up -d
```
Los cambios se aplican automáticamente al recrear el contenedor.
## 📖 Referencias
- [Variables de entorno oficiales](https://github.com/dani-garcia/vaultwarden/wiki/Configuration-overview)
- [Guía de seguridad](https://github.com/dani-garcia/vaultwarden/wiki/Hardening-Guide)
---
**Última actualización**: Diciembre 2025

644
Solución-de-Problemas.md Normal file

@@ -0,0 +1,644 @@
# Solución de Problemas
Guía completa para diagnosticar y resolver problemas comunes de Vaultwarden.
## 🔍 Diagnóstico General
Antes de buscar problemas específicos, recopila información básica:
```bash
# 1. Verificar que el contenedor está corriendo
docker compose ps
# 2. Ver logs recientes
docker compose logs --tail=100 vaultwarden
# 3. Verificar salud del contenedor
docker inspect vaultwarden | grep -A 10 State
# 4. Comprobar recursos
docker stats vaultwarden --no-stream
# 5. Verificar red
docker network inspect proxy
```
## 🚫 Contenedor No Inicia
### Síntoma
`docker compose up -d` falla o el contenedor se detiene inmediatamente.
### Diagnóstico
```bash
# Ver error exacto
docker compose logs vaultwarden
# Ver eventos de Docker
docker events --filter container=vaultwarden
```
### Causas Comunes
#### 1. Variable de Entorno Faltante
**Error**: `Missing ADMIN_TOKEN` o similar
**Solución**:
```bash
# Verificar variables
docker compose config
# Añadir variable faltante en .env o Portainer
ADMIN_TOKEN=tu_token_aqui
```
#### 2. Puerto Ya en Uso
**Error**: `address already in use` o `bind: address already in use`
**Solución**:
```bash
# Identificar qué usa el puerto (ej: 8080)
netstat -tuln | grep 8080
# Cambiar puerto en override standalone
ports:
- "8081:80" # Usa 8081 en lugar de 8080
```
#### 3. Volumen Corrupto
**Error**: `database disk image is malformed`
**Solución**:
```bash
# Verificar integridad
docker run --rm -v vaultwarden_data:/data \
nouchka/sqlite3 sqlite3 /data/db.sqlite3 "PRAGMA integrity_check;"
# Si falla, restaurar desde backup (ver Backup y Restauración)
```
#### 4. Permisos Incorrectos
**Error**: `Permission denied` en logs
**Solución**:
```bash
# Dar permisos correctos al volumen
docker run --rm -v vaultwarden_data:/data alpine chown -R 1000:1000 /data
```
## 🌐 No Puedo Acceder a la Web
### Síntoma
`https://vaultwarden.tudominio.com` no responde o da timeout.
### Diagnóstico Paso a Paso
#### 1. Verificar Contenedor
```bash
# ¿Está corriendo?
docker compose ps
# Si está "unhealthy" o "exited"
docker compose logs vaultwarden
```
#### 2. Verificar Red
```bash
# ¿Está en la red proxy?
docker network inspect proxy | grep vaultwarden
# Si no está, recrear
docker compose down && docker compose up -d
```
#### 3. Verificar Proxy
**Con Traefik**:
```bash
# Ver logs de Traefik
docker logs traefik | grep vaultwarden
# Verificar routers en el dashboard (http://traefik:8080)
```
**Con NPM**:
1. Accede a NPM (http://npm:81)
2. **Proxy Hosts** → Verifica que existe entrada para Vaultwarden
3. Status debe ser "Online"
#### 4. Verificar DNS
```bash
# ¿El dominio resuelve a tu IP?
nslookup vaultwarden.tudominio.com
# Prueba desde otra máquina
ping vaultwarden.tudominio.com
```
#### 5. Verificar Firewall
```bash
# ¿Puertos 80/443 abiertos?
sudo ufw status | grep -E '80|443'
# Si están bloqueados
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
```
### Soluciones Específicas
#### Error 502 Bad Gateway
**Causa**: El proxy no puede conectar con Vaultwarden
**Solución**:
```bash
# 1. Verificar que ambos están en la misma red
docker network inspect proxy
# 2. Verificar nombre del contenedor
docker compose ps # Debe ser exactamente "vaultwarden"
# 3. Probar conectividad interna
docker exec -it traefik ping vaultwarden # O desde NPM
```
#### Error 503 Service Unavailable
**Causa**: Contenedor caído o reiniciando constantemente
**Solución**:
```bash
# Ver por qué se reinicia
docker compose logs vaultwarden
# Recrear contenedor
docker compose down && docker compose up -d
```
#### Error 404 Not Found (con Traefik)
**Causa**: Router no configurado o regla incorrecta
**Solución**:
```bash
# Verificar labels
docker inspect vaultwarden | grep -A 20 Labels
# Debe incluir: traefik.http.routers.vaultwarden.rule=Host(`...`)
# Si falta, verificar override de Traefik
cat docker-compose.override.yml
```
## 🔐 Problemas de Login
### No Puedo Iniciar Sesión
#### Causa 1: Contraseña Maestra Incorrecta
**Síntoma**: "Invalid username or password"
**Solución**:
- ⚠️ **La contraseña maestra NO se puede recuperar**
- Si la olvidaste, no hay solución sin backup
- Crear cuenta nueva como último recurso
#### Causa 2: Email No Verificado
**Síntoma**: "Email not verified"
**Solución**:
```bash
# Opción 1: Reenviar email de verificación (requiere SMTP)
# Desde /admin → Users → Resend invitation
# Opción 2: Verificar manualmente en la DB (avanzado)
docker exec -it vaultwarden sqlite3 /data/db.sqlite3 \
"UPDATE users SET email_verified = 1 WHERE email = 'usuario@email.com';"
```
#### Causa 3: 2FA Perdido
**Síntoma**: No tienes acceso al código 2FA
**Solución**:
```bash
# Desactivar 2FA para un usuario (desde DB)
docker exec -it vaultwarden sqlite3 /data/db.sqlite3 \
"DELETE FROM twofactor WHERE user_uuid = (SELECT uuid FROM users WHERE email = 'usuario@email.com');"
```
### Session Expirada Constantemente
**Causa**: Cookies bloqueadas o DOMAIN incorrecto
**Solución**:
```bash
# Verificar variable DOMAIN
docker compose exec vaultwarden env | grep DOMAIN
# Debe coincidir EXACTAMENTE con la URL de acceso
# Correcto: DOMAIN=https://vaultwarden.tudominio.com
# Incorrecto: DOMAIN=https://vaultwarden.tudominio.com/ (barra final)
```
## 🔌 WebSocket No Funciona
### Síntoma
Sincronización muy lenta (minutos en lugar de segundos).
### Diagnóstico
```bash
# 1. Verificar que WebSocket está habilitado
docker compose exec vaultwarden env | grep WEBSOCKET
# 2. Ver puerto en logs
docker compose logs vaultwarden | grep -i websocket
# Debería mostrar: "WebSocket server listening on 0.0.0.0:3012"
```
### Soluciones por Configuración
#### Con Traefik
```bash
# Verificar router de WebSocket
docker inspect vaultwarden | grep -i "vaultwarden-ws"
# Debe existir router para /notifications/hub en puerto 3012
```
Si falta:
1. Verifica que usas `docker-compose.override.traefik.yml.example`
2. Recrear: `docker compose down && docker compose up -d`
#### Con NPM
**Problema más común**: WebSocket Support no activado
**Solución**:
1. NPM → **Proxy Hosts**
2. Editar proxy de Vaultwarden
3. **Advanced** → ✅ Activar **Websockets Support**
4. Save
#### Con Standalone
```bash
# Verificar que puerto 3012 está expuesto
docker compose port vaultwarden 3012
# Si no responde, verificar override
cat docker-compose.override.yml
# Debe incluir: "3012:3012"
```
### Probar WebSocket
```bash
# Instalar wscat (si no lo tienes)
npm install -g wscat
# Probar conexión
wscat -c wss://vaultwarden.tudominio.com/notifications/hub
# Si funciona, verás: "Connected"
# Si falla, problema de configuración del proxy
```
## 📧 Problemas con Email (SMTP)
### Emails No Se Envían
#### Diagnóstico
```bash
# Ver errores SMTP en logs
docker compose logs vaultwarden | grep -i smtp
# Errores comunes:
# - "Connection refused": Host/puerto incorrectos
# - "Authentication failed": Usuario/password incorrectos
# - "TLS error": SMTP_SECURITY incorrecto
```
#### Causas Comunes
##### 1. Host o Puerto Incorrectos
**Solución**:
```env
# Gmail
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
# Outlook
SMTP_HOST=smtp.office365.com
SMTP_PORT=587
# Otros: verificar documentación del proveedor
```
##### 2. SMTP_SECURITY Incorrecto
**Solución**:
```env
# Para puerto 587 (común)
SMTP_SECURITY=starttls
# Para puerto 465
SMTP_SECURITY=ssl
# Para puerto 25 (raro, inseguro)
SMTP_SECURITY=off
```
##### 3. Credenciales Incorrectas
**Gmail requiere App Password**:
1. https://myaccount.google.com/security
2. 2-Step Verification → ON
3. App passwords → Generate
4. Usa el password generado (no tu password normal)
##### 4. Firewall Bloqueando Puerto SMTP
**Solución**:
```bash
# Probar conectividad SMTP desde el contenedor
docker compose exec vaultwarden sh
apk add --no-cache openssl
openssl s_client -starttls smtp -connect smtp.gmail.com:587
# Debería conectar
```
### Probar SMTP desde el Panel de Administración
1. Ve a `/admin`
2. Scroll down a **SMTP Settings**
3. Introduce un email de prueba
4. **Send test email**
5. Revisa los logs si falla
## 🔒 Problemas con Certificados SSL
### Certificado Inválido o Autofirmado
#### Con Traefik
**Diagnóstico**:
```bash
# Ver certificados gestionados por Traefik
docker exec traefik ls -la /acme.json
# Ver logs de Let's Encrypt
docker logs traefik | grep -i acme
```
**Causas comunes**:
1. **DNS no apunta al servidor**: Verifica `nslookup vaultwarden.tudominio.com`
2. **Puertos 80/443 cerrados**: Let's Encrypt necesita acceso
3. **Límite de Let's Encrypt**: 5 certificados/dominio/semana
**Solución**:
```bash
# Forzar renovación (si Traefik usa acme.json)
docker exec traefik rm /acme.json
docker restart traefik
```
#### Con NPM
**Solución**:
1. NPM → **SSL Certificates**
2. Encuentra tu certificado
3. Opciones (⋮) → **Renew Certificate**
Si falla:
- Verifica DNS
- Verifica puertos 80/443 abiertos
- Intenta con DNS Challenge en lugar de HTTP Challenge
### Mixed Content (HTTP en HTTPS)
**Síntoma**: Elementos de la página no cargan, errores de seguridad en consola
**Solución**:
```bash
# Verificar que DOMAIN usa https://
docker compose exec vaultwarden env | grep DOMAIN
# Debe ser: DOMAIN=https://vaultwarden.tudominio.com
# NO: DOMAIN=http://vaultwarden.tudominio.com
```
## 💾 Problemas con Base de Datos
### Database is Locked
**Síntoma**: Error al crear/modificar entradas
**Causa**: SQLite bajo mucha carga concurrente
**Solución**:
```bash
# Aumentar timeout de DB
# Añadir a variables de entorno
DATABASE_MAX_CONNS=10
```
Para instalaciones grandes (>200 usuarios), considera migrar a PostgreSQL.
### Database Corruption
**Síntoma**: Errores al leer datos, contenedor que crashea
**Diagnóstico**:
```bash
# Verificar integridad
docker run --rm -v vaultwarden_data:/data \
nouchka/sqlite3 sqlite3 /data/db.sqlite3 "PRAGMA integrity_check;"
```
**Solución**:
```bash
# 1. Detener Vaultwarden
docker compose stop vaultwarden
# 2. Backup de la DB corrupta
docker run --rm -v vaultwarden_data:/data -v ~/:/backup alpine \
cp /data/db.sqlite3 /backup/db.sqlite3.corrupted
# 3. Intentar reparación
docker run --rm -v vaultwarden_data:/data \
nouchka/sqlite3 sqlite3 /data/db.sqlite3 ".recover" | \
sqlite3 /data/db-recovered.sqlite3
# 4. Si la reparación funciona
docker run --rm -v vaultwarden_data:/data alpine \
sh -c "mv /data/db.sqlite3 /data/db.sqlite3.broken && mv /data/db-recovered.sqlite3 /data/db.sqlite3"
# 5. Si todo falla, restaurar desde backup
# Ver: Backup y Restauración
```
## 🧩 Problemas con Clientes
### Extensión del Navegador No Conecta
**Síntomas**: "Unable to connect to server"
**Soluciones**:
1. Verificar URL del servidor: `https://vaultwarden.tudominio.com` (sin /admin, sin barra final)
2. Verificar que HTTPS funciona desde navegador
3. Limpiar caché de la extensión
4. Reinstalar extensión como último recurso
### App Móvil No Sincroniza
**Causas comunes**:
1. WebSocket no funciona (ver sección WebSocket arriba)
2. App en modo offline
3. Cuenta bloqueada o sesión expirada
**Solución**:
1. Cerrar sesión en la app
2. Volver a iniciar sesión
3. Verificar WebSocket: debe sincronizar al instante
### CLI de Bitwarden Falla
**Error**: `Invalid master password`
**Solución**:
```bash
# Verificar configuración del servidor
bw config server https://vaultwarden.tudominio.com
# Ver config actual
bw config server
# Logout y login fresh
bw logout
bw login usuario@email.com
```
## 📊 Problemas de Rendimiento
### Vaultwarden Muy Lento
**Diagnóstico**:
```bash
# Uso de recursos
docker stats vaultwarden --no-stream
# Si CPU >80% o RAM alta, posibles causas:
# 1. Base de datos muy grande
# 2. Muchos usuarios concurrentes
# 3. Iconos descargándose constantemente
```
**Soluciones**:
```bash
# 1. Deshabilitar iconos si no son necesarios
ICON_SERVICE=none
# 2. Aumentar límite de workers
ROCKET_WORKERS=20
# 3. Considerar PostgreSQL para >500 usuarios
```
### Logs Creciendo Mucho
**Síntoma**: Disco lleno por `/var/lib/docker/volumes/vaultwarden_data/_data/vaultwarden.log`
**Solución**:
```bash
# Rotar logs manualmente
docker compose exec vaultwarden sh -c "truncate -s 0 /data/vaultwarden.log"
# O deshabilitar logs completamente
# Eliminar de docker-compose.yml:
# LOG_FILE: /data/vaultwarden.log
```
## 🆘 Comandos de Emergencia
### Reset Completo (PELIGRO)
⚠️ **Esto borra TODOS los datos**:
```bash
docker compose down -v
docker volume rm vaultwarden_data
docker compose up -d
```
### Acceso de Emergencia a la DB
```bash
# Entrar al contenedor
docker compose exec vaultwarden sh
# Abrir DB
sqlite3 /data/db.sqlite3
# Comandos útiles:
.tables # Ver tablas
SELECT * FROM users; # Ver usuarios
.schema users # Ver estructura de tabla
.quit # Salir
```
### Exportar Todas las Contraseñas (Recuperación)
Desde la interfaz web:
1. Login → **Tools**
2. **Export Vault**
3. Master Password → Confirmar
4. **File Format**: JSON o CSV
5. **Download**
⚠️ El archivo descargado está **sin cifrar**. Elimínalo después de la recuperación.
## 📖 Recursos Adicionales
- [Wiki oficial de Vaultwarden](https://github.com/dani-garcia/vaultwarden/wiki)
- [Issues de GitHub](https://github.com/dani-garcia/vaultwarden/issues)
- [Discussions de GitHub](https://github.com/dani-garcia/vaultwarden/discussions)
- [Guía de endurecimiento](https://github.com/dani-garcia/vaultwarden/wiki/Hardening-Guide)
## 🔧 Obtener Ayuda
Si ninguna solución funcionó:
1. **Revisa logs completos**: `docker compose logs vaultwarden > logs.txt`
2. **Documenta el problema**: Qué intentaste, qué error ves
3. **Prepara información del sistema**:
```bash
docker --version
docker compose version
docker compose config
```
4. **Busca en GitHub Issues**: Probablemente alguien ya tuvo el mismo problema
---
**Última actualización**: Diciembre 2025
💡 **Tip**: El 90% de problemas se resuelven con: `docker compose down && docker compose up -d` después de verificar la configuración.

402
Standalone.md Normal file

@@ -0,0 +1,402 @@
# Despliegue Standalone
Esta guía explica cómo desplegar Vaultwarden **sin reverse proxy**, accediendo directamente mediante IP y puerto.
## ⚠️ ADVERTENCIA IMPORTANTE
**NO RECOMENDADO PARA PRODUCCIÓN**
Vaultwarden en modo standalone tiene limitaciones críticas:
- ❌ **Sin HTTPS**: Los clientes de Bitwarden **requieren** HTTPS para funcionar correctamente
- ❌ **Sin certificados SSL**: Conexión no segura
- ❌ **Funcionalidad limitada**: Muchas características de los clientes no funcionarán
- ❌ **Solo para testing**: Usar únicamente para pruebas locales temporales
**Este modo solo es apropiado para**:
- ✅ Testing local en entorno de desarrollo
- ✅ Pruebas de concepto antes de configurar proxy
- ✅ Debugging de problemas
Para producción, usa **[Traefik](Traefik)** o **[NPM](NPM)**.
## 📋 Requisitos Previos
- ✅ Docker Engine instalado
- ✅ Portainer (opcional, recomendado)
- ✅ ADMIN_TOKEN generado
- ✅ Puertos 8080 y 3012 disponibles
### Generar ADMIN_TOKEN
```bash
openssl rand -base64 48
```
## 🚀 Despliegue desde Portainer
### Opción A: Git Repository
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Git Repository**
4. Configura el repositorio:
- **Repository URL**: `https://git.ictiberia.com/groales/vaultwarden`
- **Repository reference**: `refs/heads/main`
- **Compose path**: `docker-compose.yml`
- **Additional paths**: `docker-compose.override.standalone.yml.example`
5. En **Environment variables**, añade:
```env
DOMAIN=http://IP-DEL-SERVIDOR:8080
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
⚠️ **Importante**:
- Reemplaza `IP-DEL-SERVIDOR` con la IP real de tu servidor
- El `DOMAIN` debe incluir `http://` (no https)
- El puerto debe coincidir con el publicado (8080)
6. Haz clic en **Deploy the stack**
### Opción B: Web Editor
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Web editor**
4. Copia y pega este contenido:
```yaml
services:
vaultwarden:
container_name: vaultwarden
image: vaultwarden/server:latest
restart: unless-stopped
environment:
DOMAIN: ${DOMAIN}
SIGNUPS_ALLOWED: ${SIGNUPS_ALLOWED:-false}
ADMIN_TOKEN: ${ADMIN_TOKEN}
WEBSOCKET_ENABLED: true
LOG_FILE: /data/vaultwarden.log
LOG_LEVEL: warn
TZ: Europe/Madrid
volumes:
- vaultwarden_data:/data
ports:
- "8080:80"
- "3012:3012"
volumes:
vaultwarden_data:
driver: local
```
5. En **Environment variables**, añade:
```env
DOMAIN=http://IP-DEL-SERVIDOR:8080
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
6. Haz clic en **Deploy the stack**
## 🖥️ Despliegue desde CLI
### 1. Clonar el repositorio
```bash
git clone https://git.ictiberia.com/groales/vaultwarden.git
cd vaultwarden
```
### 2. Copiar el archivo override
```bash
cp docker-compose.override.standalone.yml.example docker-compose.override.yml
```
### 3. Crear archivo .env
Crea un archivo `.env` con el siguiente contenido:
```env
DOMAIN=http://192.168.1.100:8080 # Cambia por tu IP
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
### 4. Iniciar el servicio
```bash
docker compose up -d
```
### 5. Verificar el despliegue
```bash
# Ver logs
docker compose logs -f vaultwarden
# Verificar que el contenedor está corriendo
docker compose ps
# Verificar puertos expuestos
docker compose port vaultwarden 80
docker compose port vaultwarden 3012
```
## 🔌 Puertos Expuestos
El modo standalone expone dos puertos:
| Puerto Host | Puerto Contenedor | Propósito |
|-------------|-------------------|-----------|
| **8080** | 80 | Interfaz web HTTP principal |
| **3012** | 3012 | WebSocket para sincronización en tiempo real |
### Verificar Puertos
```bash
# Ver puertos en uso
netstat -tuln | grep -E '8080|3012'
# Desde otro equipo en la red
curl http://IP-DEL-SERVIDOR:8080
```
## ✅ Verificación del Despliegue
### 1. Verificar Acceso Web
Abre tu navegador y ve a: `http://IP-DEL-SERVIDOR:8080`
⚠️ **Esperado**: El navegador mostrará advertencia de "conexión no segura". Es normal en modo standalone.
### 2. Verificar WebSocket
```bash
docker compose logs vaultwarden | grep -i websocket
```
Deberías ver:
```
[INFO] WebSocket server listening on 0.0.0.0:3012
```
### 3. Verificar Panel de Administración
Ve a: `http://IP-DEL-SERVIDOR:8080/admin`
Introduce tu `ADMIN_TOKEN`. Si puedes acceder, la configuración básica es correcta.
### 4. Verificar Conectividad de Red
Desde otro dispositivo en la misma red:
```bash
# Ping al servidor
ping IP-DEL-SERVIDOR
# Probar acceso HTTP
curl http://IP-DEL-SERVIDOR:8080
# Verificar puerto WebSocket
nc -zv IP-DEL-SERVIDOR 3012
```
## 🛠️ Configuración de Clientes
### Configurar Cliente de Bitwarden
⚠️ **LIMITACIÓN**: Muchos clientes de Bitwarden **no funcionarán** correctamente sin HTTPS.
#### Extensión de Navegador (Limitado)
Algunas versiones antiguas pueden funcionar:
1. Abre la extensión de Bitwarden
2. Haz clic en ⚙️ (configuración)
3. En **Server URL** introduce: `http://IP-DEL-SERVIDOR:8080`
4. Intenta iniciar sesión
**Resultado esperado**: Muchas versiones modernas **rechazarán** la conexión HTTP.
#### CLI de Bitwarden
La CLI es más permisiva con HTTP:
```bash
# Instalar CLI
npm install -g @bitwarden/cli
# Configurar servidor
bw config server http://IP-DEL-SERVIDOR:8080
# Login (puede requerir --nointeraction)
bw login usuario@email.com
```
#### App Móvil
⚠️ Las apps móviles de Bitwarden **requieren HTTPS**. No funcionarán en modo standalone.
## 🔧 Configuración Avanzada
### Cambiar Puerto HTTP
Si el puerto 8080 está ocupado, cámbialo en el override:
```yaml
ports:
- "9090:80" # Cambia 9090 por el puerto que prefieras
- "3012:3012"
```
Y actualiza la variable `DOMAIN`:
```env
DOMAIN=http://IP-DEL-SERVIDOR:9090
```
### Acceso desde Internet (NO RECOMENDADO)
Si **absolutamente** necesitas exponer Vaultwarden sin proxy:
1. **NO LO HAGAS** en producción
2. Si insistes, abre los puertos en el router:
- Puerto 8080 → IP-DEL-SERVIDOR:8080
- Puerto 3012 → IP-DEL-SERVIDOR:3012
3. Usa tu IP pública en `DOMAIN`
4. **Ten en cuenta**: Tus contraseñas viajarán sin cifrar por internet
**Mejor solución**: Configura [Traefik](Traefik) o [NPM](NPM) con Let's Encrypt.
### Logs Detallados para Debugging
Si necesitas logs más verbosos:
```yaml
environment:
LOG_LEVEL: debug # Cambia de 'warn' a 'debug'
```
Luego:
```bash
docker compose up -d
docker compose logs -f vaultwarden
```
## 🔄 Migración a Modo Proxy
Cuando estés listo para producción, migra fácilmente:
### 1. Detener el Stack
```bash
docker compose down
# NO uses -v, queremos conservar los datos
```
### 2. Cambiar al Override de Traefik o NPM
```bash
# Para Traefik
cp docker-compose.override.traefik.yml.example docker-compose.override.yml
# Para NPM
cp docker-compose.override.npm.yml.example docker-compose.override.yml
```
### 3. Actualizar Variables de Entorno
Edita `.env`:
**Para Traefik**:
```env
DOMAIN=https://vaultwarden.tudominio.com
DOMAIN_HOST=vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_existente
SIGNUPS_ALLOWED=false
```
**Para NPM**:
```env
DOMAIN=https://vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_existente
SIGNUPS_ALLOWED=false
```
### 4. Redesplegar
```bash
docker compose up -d
```
**Resultado**: Tus datos (contraseñas, usuarios, configuración) se conservan automáticamente gracias al volumen `vaultwarden_data`.
## 📖 Siguientes Pasos
Una vez que has probado Vaultwarden en modo standalone:
1. **Migra a un proxy**: [Traefik](Traefik) o [NPM](NPM)
2. Configura tu dominio con DNS
3. Habilita HTTPS con Let's Encrypt
4. Lee **[Configuración Inicial](Configuración-Inicial)** para el setup del admin
5. Configura **[Backup y Restauración](Backup-y-Restauración)** (crítico)
## 🆘 Solución de Problemas
### No puedo acceder desde otro equipo
**Síntoma**: `http://IP:8080` no responde desde otro PC
**Solución**:
1. Verifica el firewall del servidor:
```bash
# Windows
netsh advfirewall firewall add rule name="Vaultwarden" dir=in action=allow protocol=TCP localport=8080,3012
# Linux
sudo ufw allow 8080/tcp
sudo ufw allow 3012/tcp
```
2. Comprueba que el contenedor escucha en 0.0.0.0, no en 127.0.0.1
3. Verifica que usas la IP correcta (no localhost)
### Los clientes no se conectan
**Síntoma**: Error en app o extensión de Bitwarden
**Esperado**: Es normal, la mayoría de clientes **requieren HTTPS**.
**Solución**: Migra a [Traefik](Traefik) o [NPM](NPM).
### WebSocket no funciona
**Síntoma**: Sincronización muy lenta
**Solución**:
1. Verifica puerto 3012: `netstat -tuln | grep 3012`
2. Revisa logs: `docker compose logs vaultwarden | grep websocket`
3. Prueba conectividad: `nc -zv IP-DEL-SERVIDOR 3012`
### Puerto 8080 ya en uso
**Síntoma**: Error al iniciar el contenedor
**Solución**:
1. Identifica qué usa el puerto:
```bash
# Windows
netstat -ano | findstr :8080
# Linux
sudo lsof -i :8080
```
2. Cambia el puerto en el override como se explicó arriba
---
**Última actualización**: Diciembre 2025

344
Traefik.md Normal file

@@ -0,0 +1,344 @@
# Despliegue con Traefik
Esta guía explica cómo desplegar Vaultwarden usando **Traefik** como reverse proxy.
## ✅ Ventajas de usar Traefik
- 🔒 **Certificados SSL automáticos** con Let's Encrypt
- 🔄 **Renovación automática** de certificados
- 🌐 **Redirección HTTP → HTTPS** integrada
- 🔌 **WebSocket preconfigurado** para sincronización en tiempo real
- 📝 **Configuración declarativa** mediante labels de Docker
## 📋 Requisitos Previos
Antes de comenzar, asegúrate de tener:
- ✅ Traefik funcionando con soporte para Let's Encrypt
- ✅ Red Docker `proxy` creada y Traefik conectado a ella
- ✅ Dominio configurado apuntando a tu servidor
- ✅ Puertos 80 y 443 abiertos en el firewall
- ✅ ADMIN_TOKEN generado
### Verificar Red Proxy
```bash
docker network ls | grep proxy
```
Si no existe, créala:
```bash
docker network create proxy
```
### Generar ADMIN_TOKEN
```bash
openssl rand -base64 48
```
Guarda el resultado, lo necesitarás para las variables de entorno.
## 🚀 Despliegue desde Portainer
### Opción A: Git Repository (Recomendada)
Esta opción mantiene tu stack actualizado con el repositorio Git.
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Git Repository**
4. Configura el repositorio:
- **Repository URL**: `https://git.ictiberia.com/groales/vaultwarden`
- **Repository reference**: `refs/heads/main`
- **Compose path**: `docker-compose.yml`
- **Additional paths**: `docker-compose.override.traefik.yml.example`
5. En **Environment variables**, añade:
```env
DOMAIN=https://vaultwarden.tudominio.com
DOMAIN_HOST=vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
⚠️ **Importante**:
- `DOMAIN` incluye el protocolo (`https://`)
- `DOMAIN_HOST` es solo el dominio sin protocolo
- Reemplaza `vaultwarden.tudominio.com` con tu dominio real
6. Haz clic en **Deploy the stack**
### Opción B: Web Editor
Si prefieres tener el compose completo en Portainer:
1. En Portainer, ve a **Stacks** → **Add stack**
2. Nombre del stack: `vaultwarden`
3. Selecciona **Web editor**
4. Copia y pega este contenido:
```yaml
services:
vaultwarden:
container_name: vaultwarden
image: vaultwarden/server:latest
restart: unless-stopped
environment:
DOMAIN: ${DOMAIN}
SIGNUPS_ALLOWED: ${SIGNUPS_ALLOWED:-false}
ADMIN_TOKEN: ${ADMIN_TOKEN}
WEBSOCKET_ENABLED: true
LOG_FILE: /data/vaultwarden.log
LOG_LEVEL: warn
TZ: Europe/Madrid
volumes:
- vaultwarden_data:/data
networks:
- proxy
labels:
# HTTP → HTTPS redirect
- "traefik.enable=true"
- "traefik.http.routers.vaultwarden-http.rule=Host(`${DOMAIN_HOST}`)"
- "traefik.http.routers.vaultwarden-http.entrypoints=web"
- "traefik.http.routers.vaultwarden-http.middlewares=redirect-to-https@docker"
# HTTPS router for main service
- "traefik.http.routers.vaultwarden.rule=Host(`${DOMAIN_HOST}`)"
- "traefik.http.routers.vaultwarden.entrypoints=websecure"
- "traefik.http.routers.vaultwarden.tls=true"
- "traefik.http.routers.vaultwarden.tls.certresolver=letsencrypt"
- "traefik.http.routers.vaultwarden.service=vaultwarden-svc"
- "traefik.http.services.vaultwarden-svc.loadbalancer.server.port=80"
# WebSocket support for /notifications/hub
- "traefik.http.routers.vaultwarden-ws.rule=Host(`${DOMAIN_HOST}`) && Path(`/notifications/hub`)"
- "traefik.http.routers.vaultwarden-ws.entrypoints=websecure"
- "traefik.http.routers.vaultwarden-ws.tls=true"
- "traefik.http.routers.vaultwarden-ws.tls.certresolver=letsencrypt"
- "traefik.http.routers.vaultwarden-ws.service=vaultwarden-ws-svc"
- "traefik.http.services.vaultwarden-ws-svc.loadbalancer.server.port=3012"
# Redirect middleware
- "traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https"
- "traefik.http.middlewares.redirect-to-https.redirectscheme.permanent=true"
networks:
proxy:
external: true
volumes:
vaultwarden_data:
driver: local
```
5. En **Environment variables**, añade las mismas variables que en la Opción A
6. Haz clic en **Deploy the stack**
## 🖥️ Despliegue desde CLI
### 1. Clonar el repositorio
```bash
git clone https://git.ictiberia.com/groales/vaultwarden.git
cd vaultwarden
```
### 2. Copiar el archivo override
```bash
cp docker-compose.override.traefik.yml.example docker-compose.override.yml
```
### 3. Crear archivo .env
Crea un archivo `.env` con el siguiente contenido:
```env
DOMAIN=https://vaultwarden.tudominio.com
DOMAIN_HOST=vaultwarden.tudominio.com
ADMIN_TOKEN=tu_token_generado_anteriormente
SIGNUPS_ALLOWED=false
```
### 4. Iniciar el servicio
```bash
docker compose up -d
```
### 5. Verificar el despliegue
```bash
# Ver logs
docker compose logs -f vaultwarden
# Verificar que el contenedor está corriendo
docker compose ps
```
## 🔧 Configuración de Traefik
### Labels Explicados
El archivo override de Traefik incluye varios routers y servicios:
#### Router HTTP (Redirección)
```yaml
- "traefik.http.routers.vaultwarden-http.rule=Host(`${DOMAIN_HOST}`)"
- "traefik.http.routers.vaultwarden-http.entrypoints=web"
- "traefik.http.routers.vaultwarden-http.middlewares=redirect-to-https@docker"
```
Captura tráfico HTTP y lo redirige a HTTPS.
#### Router HTTPS Principal
```yaml
- "traefik.http.routers.vaultwarden.rule=Host(`${DOMAIN_HOST}`)"
- "traefik.http.routers.vaultwarden.entrypoints=websecure"
- "traefik.http.routers.vaultwarden.tls=true"
- "traefik.http.routers.vaultwarden.tls.certresolver=letsencrypt"
```
Maneja tráfico HTTPS con certificado Let's Encrypt.
#### Router WebSocket
```yaml
- "traefik.http.routers.vaultwarden-ws.rule=Host(`${DOMAIN_HOST}`) && Path(`/notifications/hub`)"
- "traefik.http.services.vaultwarden-ws-svc.loadbalancer.server.port=3012"
```
Ruta específica para WebSocket en el puerto 3012, necesario para sincronización en tiempo real.
### Verificar Configuración en Traefik
Si tienes el dashboard de Traefik habilitado, verifica:
1. Ve a `http://tu-servidor:8080` (o el puerto de tu dashboard)
2. En **HTTP Routers**, deberías ver:
- `vaultwarden-http` (redirección)
- `vaultwarden` (servicio principal)
- `vaultwarden-ws` (WebSocket)
3. En **HTTP Services**, verifica:
- `vaultwarden-svc@docker` (puerto 80)
- `vaultwarden-ws-svc@docker` (puerto 3012)
## ✅ Verificación del Despliegue
### 1. Verificar Acceso Web
Abre tu navegador y ve a: `https://vaultwarden.tudominio.com`
Deberías ver la página de login/registro de Vaultwarden con certificado SSL válido.
### 2. Verificar WebSocket
Los WebSockets son esenciales para la sincronización en tiempo real. Verifica en los logs:
```bash
docker compose logs vaultwarden | grep -i websocket
```
Deberías ver:
```
[INFO] WebSocket server listening on 0.0.0.0:3012
```
### 3. Verificar Panel de Administración
Ve a: `https://vaultwarden.tudominio.com/admin`
Introduce tu `ADMIN_TOKEN`. Si puedes acceder, la configuración es correcta.
### 4. Prueba de Sincronización
1. Crea una cuenta en Vaultwarden
2. Añade una contraseña desde la web
3. Instala la extensión de navegador Bitwarden
4. Configura el servidor: `https://vaultwarden.tudominio.com`
5. Inicia sesión
6. Verifica que la contraseña aparece inmediatamente (WebSocket funcionando)
## 🔒 Seguridad Adicional
### Restringir Acceso al Admin Panel
Puedes añadir autenticación básica de Traefik para el panel de administración:
```yaml
labels:
# Admin panel con autenticación extra
- "traefik.http.routers.vaultwarden-admin.rule=Host(`${DOMAIN_HOST}`) && PathPrefix(`/admin`)"
- "traefik.http.routers.vaultwarden-admin.middlewares=admin-auth"
- "traefik.http.middlewares.admin-auth.basicauth.users=admin:$$apr1$$hash$$generado"
```
Genera el hash:
```bash
htpasswd -nb admin tu_password
```
### Headers de Seguridad
Considera añadir headers de seguridad adicionales:
```yaml
labels:
- "traefik.http.middlewares.security-headers.headers.stsSeconds=31536000"
- "traefik.http.middlewares.security-headers.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.security-headers.headers.stsPreload=true"
- "traefik.http.routers.vaultwarden.middlewares=security-headers"
```
## 🔄 Actualización
Desde Portainer (Git Repository):
1. Ve al stack `vaultwarden`
2. Clic en **Pull and redeploy**
Desde CLI:
```bash
docker compose pull
docker compose up -d
```
## 📖 Siguientes Pasos
- **[Configuración Inicial](Configuración-Inicial)**: Configura el panel de administración
- **[Personalización](Personalización)**: Ajusta SMTP, usuarios y organizaciones
- **[Backup y Restauración](Backup-y-Restauración)**: Protege tus datos
## 🆘 Solución de Problemas
### Error de certificado SSL
**Síntoma**: Certificado inválido o autofirmado
**Solución**:
1. Verifica que el dominio apunta a tu servidor
2. Comprueba que Traefik tiene acceso a Let's Encrypt
3. Revisa logs de Traefik: `docker logs traefik`
4. Verifica el certresolver en la configuración de Traefik
### WebSocket no funciona
**Síntoma**: Sincronización lenta, no en tiempo real
**Solución**:
1. Verifica logs: `docker compose logs vaultwarden | grep websocket`
2. Comprueba que el router WebSocket existe en Traefik
3. Prueba manualmente: `wscat -c wss://vaultwarden.tudominio.com/notifications/hub`
### No puedo acceder al servicio
**Síntoma**: Timeout o conexión rechazada
**Solución**:
1. Verifica que el contenedor está corriendo: `docker compose ps`
2. Comprueba que está en la red proxy: `docker network inspect proxy`
3. Revisa logs de Traefik para errores de routing
4. Verifica que los puertos 80/443 están abiertos
---
**Última actualización**: Diciembre 2025