Tutoriales de VPS
Chatwoot en VPS (2026): Docker, HTTPS, correo y recuperación
Instale Chatwoot Community Edition en Ubuntu con Docker, PostgreSQL, Redis y Caddy. Configure chat web, SMTP, adjuntos, copias seguras, recuperación y actualizaciones controladas.

Alojar un sistema de atención al cliente en una VPS exige más que abrir la página de acceso. El widget web, las notificaciones, las tareas en segundo plano, los adjuntos, HTTPS y la recuperación deben funcionar juntos de forma estable. Chatwoot depende de Rails, Sidekiq, PostgreSQL y Redis; una orden de instalación antigua puede dejar imágenes sin fijar, bases de datos expuestas o copias imposibles de restaurar.
Esta guía completa utiliza Ubuntu 24.04, Chatwoot Community Edition v4.17.1, Docker Compose oficial y Caddy. Permite preparar una plataforma para equipos pequeños o medianos con panel HTTPS, chat web, avisos SMTP, almacenamiento S3 compatible opcional, copias externas, pruebas de recuperación y actualizaciones controladas.
Contexto de versión: el ejemplo original del 8 de septiembre de 2026 identificaba v4.17.1 como versión estable. Aquí se fija
chatwoot/chatwoot:v4.17.1-ceen lugar delatest. Esa referencia histórica no afirma cuál es la versión más reciente hoy. Compruebe Chatwoot Releases y las etiquetas oficiales de Docker Hub al desplegar; elija una versión estable con soporte y las correcciones de seguridad pertinentes.
Chatwoot reúne chat web, correo y mensajes sociales conectados mediante integraciones oficiales en un mismo espacio de atención. Su finalidad se parece a Intercom o Zendesk; no es una herramienta de conversación interna del equipo.
El alojamiento propio resulta adecuado cuando:
- Las conversaciones y los contactos deben permanecer en infraestructura que usted controla.
- Varios agentes necesitan asignación, etiquetas, notas privadas y respuestas guardadas.
- El chat, correo, webhooks o API deben integrarse en una bandeja común.
- Hay una persona responsable de Linux, Docker, entrega de correo, copias y actualizaciones de seguridad.
- El coste por agente del SaaS supera claramente el de infraestructura y operación.
Para un sitio personal o un equipo sin responsable de supervisión y recuperación, un servicio gestionado suele ser más sencillo. Community Edition es gratuita, pero la VPS, el dominio, el correo, el almacenamiento de objetos, las copias externas y el tiempo de mantenimiento tienen coste.
| Opción | Necesidades adecuadas | Ventajas | Costes y responsabilidades |
|---|---|---|---|
| Chatwoot propio | Control de datos, varios agentes, integración API | Infraestructura propia, canales reunidos, personalización | VPS, correo, copias, actualizaciones e incidencias |
| Intercom / Zendesk | Servicio gestionado y soporte del proveedor | Funciones consolidadas, infraestructura gestionada | Tarifas por plan o agente y condiciones SaaS sobre los datos |
| Complemento de chat sencillo | Sitio pequeño, un operador, solo chat web | Instalación rápida, poco mantenimiento | Canales, automatización y colaboración limitados |
Community Edition no incluye todas las funciones comerciales. La comparación oficial actual excluye de CE Captain AI, llamadas de voz, marca personalizada, capacidad de agentes, roles y permisos avanzados, SSO/SAML, políticas SLA y soporte prioritario. Contraste sus necesidades con los planes de alojamiento propio; no incluya funciones de pago en el presupuesto de la edición gratuita.
Para canales internos, mensajes privados entre compañeros y ChatOps, consulte la guía de Mattermost.
Los requisitos oficiales establecen al menos 4 GB de RAM. Sus referencias relacionan 4 núcleos/4 GB con unas 10.000 conversaciones diarias y 8 núcleos/8 GB con unas 20.000. Son orientaciones del proveedor, no resultados medidos ni una garantía para su carga. Influyen agentes simultáneos, canales, adjuntos, webhooks y trabajos; Sidekiq puede consumir por sí solo más de 1 GB en una instalación activa.
| Carga | Punto de partida recomendado | Almacenamiento | Observaciones |
|---|---|---|---|
| Prueba o poco volumen | 2–4 vCPU, 4 GB RAM | 50 GB NVMe | Pocos agentes y chat web; vigilar memoria |
| Equipo pequeño o mediano en producción | 4 vCPU, 8 GB RAM | 80–160 GB NVMe | Margen para Rails, Sidekiq, PostgreSQL y archivos |
| Mucho volumen o varios canales | 8 vCPU, 16 GB+ RAM | Planificar base de datos y objetos aparte | Separar web, workers y base de datos, y medir carga |
La guía oficial también aconseja al menos 1 GB de swap para picos de memoria durante actualizaciones. Es un colchón, no un sustituto de RAM; el intercambio continuo exige ampliar memoria o separar servicios. Compruebe si ya existe un archivo swap antes del ejemplo y evite entradas duplicadas en fstab:
sudo fallocate -l 1G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
free -h
El diagrama original representa clientes HTTPS que llegan a Caddy en el host; este reenvía a Rails en el puerto local 3000. Rails y Sidekiq utilizan PostgreSQL y Redis, mientras que los adjuntos residen en un volumen Docker o almacenamiento S3 compatible:
访客网站 / 客服浏览器
│ HTTPS 443
▼
Caddy(宿主机)
│ 127.0.0.1:3000
▼
Chatwoot Rails 容器 ───── PostgreSQL
│
└──── Sidekiq ─── Redis
附件:本地 Docker volume,或 S3 兼容对象存储
Solo 22/tcp, 80/tcp y 443/tcp necesitan acceso público. El Compose fijado vincula Rails 3000, PostgreSQL 5432 y Redis 6379 a 127.0.0.1. Mantenga esos enlaces; cambiar base de datos o Redis a 0.0.0.0 no soluciona problemas internos.
Elija un subdominio como support.example.com y apunte el registro A a la IPv4 pública. Añada AAAA únicamente si IPv6 llega correctamente al servidor; una ruta defectuosa puede provocar fallos intermitentes de certificados o clientes.
export CW_DOMAIN="support.example.com"
getent ahosts "$CW_DOMAIN"
curl -4 https://ifconfig.me
Actualice Ubuntu y configure UFW:
sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install -y ca-certificates curl openssl ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status verbose
Aplique las mismas reglas al grupo de seguridad del proveedor. Limite SSH a direcciones administrativas cuando sea posible y pruebe otra sesión antes de cerrar la actual. Revise por separado los puertos publicados por Docker; el cortafuegos no demuestra por sí solo que sean privados.
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list >/dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo docker version
sudo docker compose version
Incluya rotación de registros, alertas de recursos y observabilidad en producción. Consulte la lista de configuración de Docker Compose.
Descargue los archivos de la etiqueta v4.17.1 para evitar cambios futuros de develop:
sudo install -d -o "$USER" -g "$USER" -m 0750 /opt/chatwoot
cd /opt/chatwoot
curl -fL https://raw.githubusercontent.com/chatwoot/chatwoot/v4.17.1/.env.example -o .env
curl -fL https://raw.githubusercontent.com/chatwoot/chatwoot/v4.17.1/docker-compose.production.yaml -o docker-compose.production.yaml
sed -i 's|image: chatwoot/chatwoot:latest|image: chatwoot/chatwoot:v4.17.1-ce|' docker-compose.production.yaml
grep 'image: chatwoot/chatwoot' docker-compose.production.yaml
La imagen -ce omite el código Enterprise. Fijar la versión permite revisar cada actualización, no conservarla indefinidamente. Revise también las imágenes PostgreSQL/pgvector y Redis, sus extensiones y compatibilidad; no cambie sus versiones principales sin planificación durante una actualización de Chatwoot.
Genere tres secretos diferentes y guárdelos en un gestor de contraseñas:
openssl rand -hex 64
openssl rand -base64 36
openssl rand -base64 36
El primer valor corresponde a SECRET_KEY_BASE; los otros son contraseñas independientes de PostgreSQL y Redis. Base64 puede contener caracteres especiales en URL. Para la contraseña Redis incluida en la URL, codifíquela correctamente o genere una hexadecimal, por ejemplo openssl rand -hex 32, y use exactamente el mismo valor en ambos ajustes de Redis.
Edite /opt/chatwoot/.env y sustituya todos los dominios, contraseñas y remitentes de ejemplo:
SECRET_KEY_BASE=replace-with-the-128-character-hex-secret
FRONTEND_URL=https://support.example.com
FORCE_SSL=true
ENABLE_ACCOUNT_SIGNUP=true
DEFAULT_LOCALE=zh_CN
REDIS_URL=redis://:replace-with-redis-password@redis:6379
REDIS_PASSWORD=replace-with-redis-password
POSTGRES_HOST=postgres
POSTGRES_DATABASE=chatwoot
POSTGRES_USERNAME=postgres
POSTGRES_PASSWORD=replace-with-postgres-password
RAILS_ENV=production
RAILS_LOG_TO_STDOUT=true
LOG_LEVEL=info
MAILER_SENDER_EMAIL=Support <[email protected]>
SMTP_DOMAIN=example.com
SMTP_ADDRESS=smtp.example.com
SMTP_PORT=587
[email protected]
SMTP_PASSWORD=replace-with-smtp-password
SMTP_AUTHENTICATION=login
SMTP_ENABLE_STARTTLS_AUTO=true
SMTP_OPENSSL_VERIFY_MODE=peer
ACTIVE_STORAGE_SERVICE=local
El ejemplo conservado utiliza DEFAULT_LOCALE=zh_CN. Para una organización en español, establezca DEFAULT_LOCALE=es; determina el idioma inicial de las cuentas nuevas, no la ubicación de los clientes.
Corrija la contraseña de PostgreSQL antes de inicializar. El Compose oficial fijado contiene POSTGRES_PASSWORD= vacío dentro del servicio postgres. El dotenv de la aplicación no sustituye ese valor literal. Reemplace dicha entrada de la lista environment por:
- POSTGRES_PASSWORD=${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
Mantenga POSTGRES_DB y POSTGRES_USER coherentes con la aplicación. Si PostgreSQL ya fue inicializado, cambiar una variable no cambia la contraseña del usuario existente; realice un cambio controlado dentro de la base de datos.
El original propone esta comprobación:
cd /opt/chatwoot
chmod 600 .env
sudo docker compose -f docker-compose.production.yaml config >/tmp/chatwoot-compose.yaml
grep -A4 -E '127.0.0.1:3000|127.0.0.1:5432|127.0.0.1:6379' /tmp/chatwoot-compose.yaml
Evite escribir secretos expandidos en un archivo temporal legible por otros. Prefiera este conducto, que solo muestra los enlaces de puertos. Compose moderno los representa con campos estructurados, por lo que el grep literal del ejemplo puede no mostrar nada aunque los enlaces sean correctos:
sudo docker compose -f /opt/chatwoot/docker-compose.production.yaml config --format json | python3 -c '
import json, sys
config = json.load(sys.stdin)
for name in ("rails", "postgres", "redis"):
for port in config["services"][name].get("ports", []):
assert port.get("host_ip") == "127.0.0.1", (name, "non-loopback binding")
print(name, port.get("host_ip"), port.get("published"), port.get("target"))
'
Mantenga el dotenv con permisos 600. No publique la salida completa de docker compose config; puede incluir credenciales de PostgreSQL, Redis y SMTP.
Ejecute la preparación oficial antes del primer arranque de la aplicación:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml pull
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:chatwoot_prepare
sudo docker compose -f docker-compose.production.yaml up -d
sudo docker compose -f docker-compose.production.yaml ps
sudo docker compose -f docker-compose.production.yaml logs --tail=100 rails sidekiq postgres redis
Compruebe el puerto web y las dependencias:
curl -I http://127.0.0.1:3000
ss -lntp | grep -E ':3000|:5432|:6379'
sudo docker compose -f docker-compose.production.yaml exec -T postgres pg_isready -U postgres -d chatwoot
sudo docker compose -f docker-compose.production.yaml exec -T redis sh -lc 'redis-cli -a "$REDIS_PASSWORD" ping'
PostgreSQL debe indicar accepting connections, Redis PONG, y los tres puertos publicados deben usar loopback. Una respuesta de salud no verifica las credenciales reales de la aplicación; revise registros y envíe una conversación de prueba.
sudo apt-get install -y debian-keyring debian-archive-keyring apt-transport-https curl gnupg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list >/dev/null
sudo apt-get update
sudo apt-get install -y caddy
Cree /etc/caddy/Caddyfile con su dominio:
support.example.com {
encode zstd gzip
reverse_proxy 127.0.0.1:3000
log {
output file /var/log/caddy/chatwoot-access.log {
roll_size 100MiB
roll_keep 7
}
}
}
Prepare el directorio del registro de acceso con permisos para el servicio Caddy. reverse_proxy admite WebSocket automáticamente; no es necesario definir manualmente Upgrade. Valide y recargue:
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
sudo systemctl status caddy --no-pager
curl -I https://support.example.com
Para varias aplicaciones en un host, consulte la guía de Caddy y HTTPS automático.
Visite inicialmente:
https://support.example.com/app/auth/signup
Restrinja el acceso al administrador previsto durante la preparación. Tras crear la primera cuenta administrativa y la organización, cambie .env a:
ENABLE_ACCOUNT_SIGNUP=false
Recree los contenedores para aplicar el entorno:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml up -d --force-recreate rails sidekiq
Invite a los siguientes agentes desde la administración. No mantenga abierto el registro público. Active MFA donde la edición lo admita y configure antes las tres claves Active Record Encryption descritas en .env.example:
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:encryption:init
Guarde ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY, ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY y ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT de la salida en .env y en un gestor protegido. Recree Rails y Sidekiq. Conserve las claves en despliegues y restauraciones; regenerarlas o perderlas puede impedir descifrar datos existentes.
Entre en Ajustes → Bandejas de entrada → Añadir bandeja, elija Website e indique nombre del sitio y dominios permitidos. Incorpore el script generado con websiteToken a la plantilla común o al gestor de etiquetas.
Antes de publicar, verifique:
- La burbuja aparece en una ventana privada.
- El primer mensaje llega inmediatamente al panel del agente.
- La respuesta del agente llega sin recargar la página.
- Un dominio de prueba no autorizado no puede abusar del widget; compruebe qué restricciones aplica realmente su versión.
- Tamaños y tipos de adjuntos cumplen las reglas del negocio.
- Las notificaciones por correo llegan aunque se cierre el panel.
Si no aparece la burbuja, revise Console, Network y WebSocket en el navegador. Busque FRONTEND_URL incorrecto, una CSP que bloquee scripts, caché antigua del CDN o redirecciones HTTPS defectuosas antes del proxy.
SMTP interviene en invitaciones, notificaciones, recuperación de contraseña y mensajes de las conversaciones. Envíe una prueba desde el panel y revise:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml logs -f --tail=100 rails sidekiq
Si el correo llega a spam, revise SPF, DKIM y DMARC del dominio remitente; no desactive la validación TLS. El dominio de MAILER_SENDER_EMAIL debe corresponder a una identidad autorizada por el proveedor SMTP. Cuando utiliza un relay, el proveedor administra el DNS inverso del servidor emisor.
Para que la respuesta del cliente continúe la misma conversación hace falta configurar también correo entrante. Prepare una integración compatible de Mailgun, Postmark, SendGrid, SES o reenvío, con RAILS_INBOUND_EMAIL_SERVICE, contraseña de entrada y webhook. Verifique compatibilidad con versión y proveedor: SMTP saliente correcto no demuestra que el correo entrante funcione.
La bandeja unificada no evita las reglas de las plataformas. WhatsApp, Instagram y Facebook normalmente requieren cuenta Business, aplicación de desarrollador, webhooks, revisión y posibles cargos.
En producción:
- Solicite credenciales mediante documentación oficial de Chatwoot y la plataforma.
- Use aplicaciones separadas y tokens con permisos mínimos.
- Mantenga callbacks en HTTPS.
- Asigne responsables de rotación de tokens y revisión del canal.
- Evite cuentas compartidas dudosas y servicios que prometan eludir la revisión.
Valide primero chat web y API Inbox; añada después los canales externos uno por uno.
ACTIVE_STORAGE_SERVICE=local almacena los adjuntos en el volumen Docker storage_data. Es sencillo, pero perder el disco implica perder archivos sin copias externas.
Si los adjuntos crecen, configure:
ACTIVE_STORAGE_SERVICE=s3_compatible
STORAGE_BUCKET_NAME=chatwoot-attachments
STORAGE_ACCESS_KEY_ID=replace-with-access-key
STORAGE_SECRET_ACCESS_KEY=replace-with-secret-key
STORAGE_REGION=auto
STORAGE_ENDPOINT=https://your-s3-compatible-endpoint
STORAGE_FORCE_PATH_STYLE=true
Cada proveedor tiene requisitos de path-style, CORS y URL firmadas. Pruebe carga, vista previa, descarga y eliminación, y migre deliberadamente los archivos antiguos; cambiar la variable no los mueve. Recree las aplicaciones al cambiar la configuración. Active versionado, ciclo de vida y copias también en objetos; S3 no garantiza por sí solo el objetivo de recuperación. Para alojamiento propio compatible, consulte la guía de MinIO.
El alcance oficial incluye PostgreSQL, almacenamiento de adjuntos, variables y personalizaciones del código. Redis conserva colas y caché; no es la única fuente de conversaciones. La base de datos y los archivos necesitan un punto de recuperación coordinado, y los trabajos pendientes requieren una política explícita.
Se conserva el ejemplo original de parada y copia. Para la topología de volúmenes locales utilice la versión revisada que aparece después: el original carece de reinicio fiable, descubrimiento exacto de volúmenes y manifiesto portátil de sumas:
cd /opt/chatwoot
STAMP=$(date +%F-%H%M%S)
BACKUP_DIR="/var/backups/chatwoot/$STAMP"
sudo install -d -m 0700 "$BACKUP_DIR"
sudo docker compose -f docker-compose.production.yaml stop rails sidekiq
sudo sh -c "docker compose -f /opt/chatwoot/docker-compose.production.yaml exec -T postgres pg_dump -U postgres -d chatwoot -Fc > '$BACKUP_DIR/chatwoot.dump'"
sudo docker compose -f docker-compose.production.yaml run --rm --no-deps \
-v "$BACKUP_DIR:/backup" rails \
tar -czf /backup/storage.tar.gz -C /app/storage .
sudo cp .env docker-compose.production.yaml "$BACKUP_DIR/"
sudo sha256sum "$BACKUP_DIR"/* | sudo tee "$BACKUP_DIR/SHA256SUMS"
sudo docker compose -f docker-compose.production.yaml start rails sidekiq
Pause los productores de mensajes o establezca mantenimiento; permita vaciar las colas Sidekiq cuando sea posible. Descargue antes la imagen auxiliar de archivo. Este ejemplo ejecutado como root identifica los volúmenes realmente montados en Rails y Redis, comprueba su existencia, aplica permisos privados, guarda las colas Redis, registra la imagen y utiliza una trampa EXIT para intentar reiniciar servicios:
sudo bash <<'BACKUP'
set -Eeuo pipefail
umask 077
cd /opt/chatwoot
compose=(docker compose -f docker-compose.production.yaml)
rails_id=$("${compose[@]}" ps -q rails)
redis_id=$("${compose[@]}" ps -q redis)
test -n "$rails_id" && test -n "$redis_id"
storage_volume=$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/app/storage"}}{{if eq .Type "volume"}}{{.Name}}{{end}}{{end}}{{end}}' "$rails_id")
redis_volume=$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/data"}}{{if eq .Type "volume"}}{{.Name}}{{end}}{{end}}{{end}}' "$redis_id")
test -n "$storage_volume" && test -n "$redis_volume"
docker volume inspect "$storage_volume" "$redis_volume" >/dev/null
backup_dir="/var/backups/chatwoot/$(date -u +%Y%m%dT%H%M%SZ)"
install -d -m 0700 "$backup_dir"
resume_apps() { "${compose[@]}" start rails sidekiq >/dev/null || true; }
trap resume_apps EXIT
"${compose[@]}" stop rails sidekiq
"${compose[@]}" exec -T postgres pg_dump -U postgres -d chatwoot -Fc > "$backup_dir/chatwoot.dump"
"${compose[@]}" exec -T redis sh -ec 'REDISCLI_AUTH="$REDIS_PASSWORD" redis-cli SAVE'
"${compose[@]}" stop redis
resume_services() { "${compose[@]}" start redis rails sidekiq >/dev/null || true; }
trap resume_services EXIT
docker run --rm --network none -v "$storage_volume:/source:ro" -v "$backup_dir:/backup" alpine:3.22 tar -czf /backup/storage.tar.gz -C /source .
docker run --rm --network none -v "$redis_volume:/source:ro" -v "$backup_dir:/backup" alpine:3.22 tar -czf /backup/redis.tar.gz -C /source .
cp -p .env docker-compose.production.yaml "$backup_dir/"
cp -p /etc/caddy/Caddyfile "$backup_dir/Caddyfile"
docker inspect --format '{{.Config.Image}} {{.Image}}' "$rails_id" > "$backup_dir/image-reference.txt"
(cd "$backup_dir" && sha256sum chatwoot.dump storage.tar.gz redis.tar.gz .env docker-compose.production.yaml Caddyfile image-reference.txt > SHA256SUMS && sha256sum -c SHA256SUMS)
printf 'Backup directory: %s\n' "$backup_dir"
BACKUP
Presupone adjuntos locales, el nombre de base mostrado y ausencia de otros productores que escriban en Redis o archivos. Para S3, obtenga un punto de recuperación equivalente de los objetos; el archivo local no será su fuente principal. Incluya código propio, configuración adicional y montajes no estándar. Compruebe la salud después de cualquier fallo: la trampa intenta reiniciar, pero no verifica el servicio.
Cifre la carpeta completa y cópiela a otra región o proveedor. Otra carpeta en el mismo disco no es recuperación ante desastres. Ajuste retención al RPO; por ejemplo, 7 copias diarias, 4 semanales y 6–12 mensuales. Consulte la estrategia de copias de VPS.
Utilice una VPS de prueba aislada, bloquee webhooks y correo saliente, y restaure imagen, base, modo de almacenamiento y claves correspondientes a .env. Compruebe SHA256SUMS desde dentro de la carpeta de respaldo antes de restaurar.
El orden básico original es:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml stop rails sidekiq
sudo docker compose -f docker-compose.production.yaml exec -T postgres dropdb -U postgres --if-exists chatwoot
sudo docker compose -f docker-compose.production.yaml exec -T postgres createdb -U postgres chatwoot
sudo sh -c "cat /var/backups/chatwoot/RESTORE_POINT/chatwoot.dump | docker compose -f /opt/chatwoot/docker-compose.production.yaml exec -T postgres pg_restore -U postgres -d chatwoot"
sudo docker compose -f docker-compose.production.yaml run --rm --no-deps \
-v /var/backups/chatwoot/RESTORE_POINT:/backup:ro rails \
tar -xzf /backup/storage.tar.gz -C /app/storage
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:chatwoot_prepare
sudo docker compose -f docker-compose.production.yaml start rails sidekiq
La eliminación de la base de datos en ese ejemplo solo corresponde al destino desechable y vacío de la prueba. Arranque primero PostgreSQL/Redis y mantenga Rails/Sidekiq detenidos. Si el usuario de la aplicación no puede acceder al respaldo o escribir los archivos, utilice un auxiliar privilegiado montado sobre el volumen existente del destino, previamente verificado. No adivine nombres de volumen ni restaure sobre el origen de producción; ajuste la propiedad al usuario de la imagen. Para conservar trabajos, restaure Redis sobre su volumen detenido; si decide perder la cola, documente esa pérdida y concilie notificaciones omitidas o duplicadas. Aísle el destino antes de iniciar workers para evitar mensajes reales repetidos.
Ejecute la preparación con la imagen correspondiente y arranque las aplicaciones. Verifique acceso administrativo, conversaciones antiguas, contactos, adjuntos aleatorios, widget, notificaciones y trabajos en un entorno controlado. Tener archivos exportados no demuestra que el servicio pueda recuperarse.
Lea las notas de todas las versiones entre origen y destino y respete las actualizaciones intermedias exigidas; no salte varios cambios principales de una vez.
El ejemplo original inicia aplicaciones antes de preparar la base. La etiqueta v4.17.2-ce es ilustrativa y no garantiza que exista o sea apropiada:
cd /opt/chatwoot
# 1. 先执行上一节的完整备份并记录当前镜像
grep 'image: chatwoot/chatwoot' docker-compose.production.yaml
# 2. 把 Compose 中的镜像改成已经核对过的新版本,例如 v4.17.2-ce
sudo docker compose -f docker-compose.production.yaml down
sudo docker compose -f docker-compose.production.yaml pull
sudo docker compose -f docker-compose.production.yaml up -d
# 3. 官方要求升级后运行数据库准备任务
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:chatwoot_prepare
# 4. 回读状态与日志
sudo docker compose -f docker-compose.production.yaml ps
sudo docker compose -f docker-compose.production.yaml logs --tail=200 rails sidekiq
curl -I https://support.example.com
Después de una copia completa verificada y de seleccionar la imagen real de destino, use este orden:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml stop rails sidekiq
# Edit the shared base image to the reviewed target tag before pulling.
sudo docker compose -f docker-compose.production.yaml pull
sudo docker compose -f docker-compose.production.yaml up -d postgres redis
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:chatwoot_prepare
sudo docker compose -f docker-compose.production.yaml up -d --force-recreate rails sidekiq
sudo docker compose -f docker-compose.production.yaml ps
sudo docker compose -f docker-compose.production.yaml logs --tail=200 rails sidekiq
curl -I https://support.example.com
Prepare la base mientras las aplicaciones siguen detenidas y luego recree Rails/Sidekiq. Una migración de esquema no se revierte simplemente volviendo a la imagen antigua. Restaure base y archivos previos con claves e imagen correspondientes y compruebe primero en aislamiento.
Supervise al menos:
- Memoria, swap, CPU, disco e inodos del host.
- Reinicios de Rails y Sidekiq.
- Conexiones, tamaño y copias de PostgreSQL.
- Disponibilidad y memoria Redis.
- Trabajos Sidekiq fallidos y acumulados.
- Certificados HTTPS, DNS y comprobación externa.
- Rebotes SMTP, fallos de webhook y crecimiento de adjuntos.
Inspección rápida:
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml ps
sudo docker stats --no-stream
df -h
df -i
free -h
sudo docker compose -f docker-compose.production.yaml logs --since=30m rails sidekiq postgres redis
No alerte únicamente cuando la web deja de abrir. Con Sidekiq detenido, el acceso puede funcionar mientras se acumulan correos, webhooks, importaciones y tareas.
cd /opt/chatwoot
sudo docker compose -f docker-compose.production.yaml ps
sudo docker compose -f docker-compose.production.yaml logs --tail=200 rails sidekiq
sudo docker inspect --format '{{.State.OOMKilled}} {{.RestartCount}}' chatwoot-rails-1
Revise SECRET_KEY_BASE, conexión a base, contraseña Redis y OOM. El nombre del contenedor cambia con el proyecto Compose; obtenga el real mediante docker compose ps antes de inspeccionarlo.
sudo docker compose -f docker-compose.production.yaml exec -T postgres pg_isready -U postgres -d chatwoot
sudo docker compose -f docker-compose.production.yaml exec -T redis sh -lc 'redis-cli -a "$REDIS_PASSWORD" ping'
Mantenga POSTGRES_DATABASE=chatwoot coherente con POSTGRES_DB=chatwoot y la contraseña de REDIS_URL igual a REDIS_PASSWORD. Aplique la corrección del valor vacío anterior. Abrir 5432 o 6379 a Internet no corrige autenticación interna.
Pruebe el origen sin CDN y revise WebSocket del navegador y registros Caddy/Rails. Caddy ya lo admite; el CDN/WAF anterior debe permitir conexiones largas y evitar caché en rutas API o WebSocket.
sudo docker compose -f docker-compose.production.yaml logs --since=30m rails sidekiq | grep -Ei 'smtp|mail|timeout|auth|tls'
Compruebe puerto, autenticación, identidad remitente, TLS y restricciones IP. Muchas VPS bloquean 25. Use 587 STARTTLS o 465 TLS según las instrucciones concretas del proveedor de correo.
df -h
df -i
sudo docker compose -f docker-compose.production.yaml run --rm --no-deps rails sh -lc 'df -h /app/storage && ls -ld /app/storage'
En local, revise disco, inodos y permisos del volumen. En S3 compatible, endpoint, bucket, región, path-style, CORS y tiempo de firma. Un reloj del host desajustado puede invalidar URL firmadas de inmediato.
Compruebe imagen y preparación de base:
grep 'image: chatwoot/chatwoot' docker-compose.production.yaml
sudo docker compose -f docker-compose.production.yaml run --rm rails bundle exec rails db:chatwoot_prepare
sudo docker compose -f docker-compose.production.yaml logs --tail=200 rails sidekiq
Mantenga tráfico detenido mientras repara migraciones. Ante un salto no admitido, siga la secuencia oficial en lugar de reiniciar repetidamente.
- Registros A/AAAA coherentes con rutas de red funcionales.
- Solo 22, 80 y 443 públicos; 3000/5432/6379 en loopback.
- Imagen revisada
v4.17.1-cefijada, sinlatest. -
.envcon permisos 600 y contraseñas predeterminadas/vacías sustituidas tanto en aplicación como en base. -
ENABLE_ACCOUNT_SIGNUPdesactivado tras crear el primer administrador. - Claves MFA conservadas en copias protegidas.
- Widget con mensajes bidireccionales en tiempo real.
- SMTP, invitaciones, notificaciones y contraseña probados.
- Canales oficiales con plan de rotación de credenciales.
- Puntos externos de recuperación para PostgreSQL, adjuntos, configuración y política de cola Redis.
- Una recuperación aislada completada.
- Alertas de Rails, Sidekiq, base, Redis, disco y HTTPS.
No es recomendable para producción. El mínimo oficial es 4 GB y el host también ejecuta Sidekiq, PostgreSQL, Redis, Docker y Caddy. Con 2 GB puede arrancar con poca carga, pero quedarse sin memoria durante importaciones, actualizaciones o picos de mensajes.
CE permite alojamiento propio y figura actualmente a 0 USD por agente. Revise las obligaciones de licencia de la versión elegida. No incluye todas las capacidades avanzadas: Captain AI, voz, marca, permisos, SSO/SAML, SLA y soporte dependen de los planes actuales.
No. PostgreSQL es la base oficialmente admitida; una adaptación no oficial no corresponde al despliegue mantenible descrito.
PostgreSQL guarda conversaciones, contactos y configuración; Redis gestiona colas y caché. Su pérdida puede eliminar trabajos pendientes o provocar reintentos. Persista y supervise Redis, vacíe colas antes del mantenimiento cuando sea posible y defina cómo se recuperan los trabajos.
Normalmente no: reverse_proxy lo admite por defecto. Ante fallos, revise CDN/WAF, conexiones del navegador, FRONTEND_URL y registros Rails.
No. Siguen aplicándose las reglas de Meta sobre cuentas, revisión, plantillas, webhooks y facturación. Utilice la integración oficial.
Una instalación sostenible necesita versiones controladas, dependencias Rails/Sidekiq/PostgreSQL/Redis claras, HTTPS y correo comprobados, y base y adjuntos recuperables.
Para un equipo nuevo pequeño o mediano, empiece con unas 4 vCPU y 8 GB RAM, CE fijada, Caddy HTTPS, adjuntos locales y copias externas. Separe PostgreSQL, workers y objetos al crecer canales y carga. La puesta en marcha termina cuando circulan los mensajes, las colas están sanas y ha realizado una recuperación.