Tutoriales de VPS
Sentry en VPS (2026): Docker, HTTPS, SDK, alertas y recuperación
Instale Sentry Self-Hosted 26.8.0 en Ubuntu con errors-only, Caddy HTTPS y SMTP. Configure SDK JavaScript/Python, mapas y releases, reduzca ruido y pruebe copias completas y actualizaciones.

Diagnosticar excepciones es difícil sin conocer versión, usuario, solicitud y entorno. Sentry recoge stacks, breadcrumbs, releases y contexto, agrupa eventos repetidos en issues y notifica responsables por correo e integraciones.
Esta guía usa Ubuntu 24.04, Sentry Self-Hosted 26.8.0, Docker Compose y Caddy. Incluye recursos, errors-only, HTTPS, SMTP, SDK JavaScript/Python, Source Map, releases, reducción de ruido, recuperación offline y pasos obligatorios de actualización.
Contexto de versión: el original presentaba
26.8.0como la versión más reciente el 5 de septiembre de 2026. Es una fecha histórica. La release verificada elimina siete contenedores metrics, sustituye Redis por el servicio compatible Valkey e incluye arreglos de seguridad. Fije un tag soportado revisado; evite nightly y actualizaciones automáticas de producción.
Hay dos límites:
- Self-Hosted oficial está orientado a poco volumen y evaluación, sin sustituir al SaaS sin mantenimiento.
- PostgreSQL, ClickHouse, Kafka, Valkey, Relay, Snuba, Symbolicator y SeaweedFS necesitan más recursos y operación que un blog.
Considere alojamiento propio cuando:
- Los eventos no deben llegar a un SaaS externo.
- El equipo controla retención y ubicación.
- Servicios internos no alcanzan Sentry público.
- Alguien mantiene Docker, bases, copias y alertas.
- Proyectos JavaScript, Python, Java o móviles de poco volumen necesitan una entrada común.
Para un proyecto pequeño sin respuesta y recuperación, la opción alojada puede costar menos. El ahorro de suscripción o salida de datos se cambia por VPS, backups, actualizaciones e incidentes.
| Herramienta | Mejor función | Entrada | No sustituye |
|---|---|---|---|
| Sentry | Excepciones, stacks, releases y trazas | Eventos SDK | Logs completos y métricas de infraestructura |
| Loki/OpenObserve | Búsqueda y retención de logs | stdout, archivos, agentes | Contexto SDK |
| Prometheus/Grafana | Tendencias numéricas | Métricas | Stack detallado |
| Uptime Kuma | Disponibilidad externa y certificados | HTTP/TCP/DNS | Diagnóstico interno |
Una sonda detecta sitio inaccesible, Sentry identifica release/línea y los logs muestran solicitudes próximas. Consulte Uptime Kuma si faltan comprobaciones externas.
El instalador 26.8.0 tiene mínimos específicos:
| Modo | Mínimo del instalador | Inicio práctico | Uso |
|---|---|---|---|
errors-only | 2 vCPU, unos 7 GB disponibles para Docker | 4 vCPU / 12 GB / 100 GB NVMe | Errores |
feature-complete | 4 vCPU, unos 14 GB disponibles | 4–8 vCPU / 16–32 GB / 200 GB NVMe | Rendimiento, Replay y más |
El original cita 4 núcleos, 16 GB y 20 GB libres como referencia oficial. Espacio mínimo no equivale a capacidad duradera: eventos, archivos, replay, perfiles, ClickHouse y Kafka crecen. Reserve 100–200 GB NVMe y mida volumen/retención.
8 GB deja poco margen incluso en errors-only. Mucho swap no reemplaza RAM, especialmente con ClickHouse/Kafka.
La subida mensual es aproximadamente tamaño medio × eventos diarios × 30. Fórmula original:
月上行流量 ≈ 平均事件大小 × 每日事件数 × 30
20 KB y 100.000 eventos/día producen unos 60 GB/mes antes de anexos, replay, Source Map y protocolos. Use conectividad estable y cuota suficiente; disco y RAM suelen limitar primero.
Configure muestreo, filtre errores esperados y excluya datos sensibles. Un bucle puede inundar el servicio en minutos.
Utilice getsentry/self-hosted oficial. Los SDK acceden por Caddy HTTPS, después nginx/Relay local y la cadena de eventos:
应用 SDK
↓ HTTPS 443
Caddy(宿主机 TLS)
↓ 127.0.0.1:9000
官方 nginx / Relay
↓
Sentry Web + Worker + Snuba
↓
PostgreSQL / ClickHouse / Kafka / Valkey / SeaweedFS
Solo Caddy es público. nginx se asocia a 127.0.0.1:9000; bases y colas quedan en Docker.
Apunte sentry.example.com al VPS y permita:
22/tcp: SSH limitado.80/tcp: certificados y redirección.443/tcpy443/udp: HTTPS/HTTP3.9000/tcp: solo loopback, sin apertura pública.- Ningún puerto público de PostgreSQL, ClickHouse, Kafka o Valkey.
export SENTRY_DOMAIN="sentry.example.com"
getent ahosts "$SENTRY_DOMAIN"
curl -4 https://ifconfig.me
Publique AAAA solo con IPv6 funcional. Verifique asociaciones Docker y reglas de nube además del firewall.
sudo apt-get update
sudo apt-get install -y ca-certificates curl git jq rsync
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
Esta versión requiere Docker 19.03.6+, Compose 2.32.2+ y Bash 4.4+. Verifique resultados e instale openssl si falta para generar secretos. Consulte Compose de producción.
nproc
free -h
df -h /
df -i /
uname -a
sysctl vm.max_map_count
Configure vm.max_map_count:
echo 'vm.max_map_count=262144' | sudo tee /etc/sysctl.d/90-sentry.conf
sudo sysctl --system
sysctl vm.max_map_count
Use NVMe suficiente. Mover /var/lib/docker exige parada y copia verificada; no cambie rutas de daemon casualmente tras instalar.
sudo install -d -o "$USER" -g "$USER" -m 0750 /opt/sentry
cd /opt/sentry
git clone https://github.com/getsentry/self-hosted.git
cd self-hosted
git fetch --tags
git checkout 26.8.0
git status --short
git describe --tags --exact-match
El resultado final debe ser 26.8.0. Evite master/nightly con cambios no revisados.
errors-only ofrece errores, issues, releases y alertas básicas. feature-complete habilita rendimiento, replay, perfiles y otras funciones compatibles.
Guarde overrides en .env.custom, sin copiar todo .env y congelar defaults antiguos:
cd /opt/sentry/self-hosted
LAUNCHPAD_SECRET="$(openssl rand -hex 32)"
umask 077
cat >.env.custom <<EOF
COMPOSE_PROFILES=errors-only
SENTRY_BIND=127.0.0.1:9000
SENTRY_EVENT_RETENTION_DAYS=30
SENTRY_MAIL_HOST=example.com
SENTRY_TASKWORKER_CONCURRENCY=2
LAUNCHPAD_RPC_SHARED_SECRET=${LAUNCHPAD_SECRET}
EOF
unset LAUNCHPAD_SECRET
chmod 600 .env.custom
Para funciones completas, cambie COMPOSE_PROFILES a feature-complete. Ajuste concurrencia a la RAM. Mantenga asignaciones dotenv válidas también para shell: el instalador oficial ejecuta el archivo además de usarlo en Compose.
Revise tag y cambios:
cd /opt/sentry/self-hosted
git status --short
sudo ./install.sh --no-report-self-hosted-issues
Comprueba recursos, crea volúmenes/configuración/secretos, construye imágenes e inicializa/migra almacenamiento. La primera instalación puede superar diez minutos.
Cargue ambos archivos de entorno:
cd /opt/sentry/self-hosted
sudo docker compose --env-file .env --env-file .env.custom up --wait
sudo docker compose --env-file .env --env-file .env.custom ps
sudo docker compose --env-file .env --env-file .env.custom logs --tail=200 web relay nginx
Investigue starting mediante salud y dependencias antes de reiniciar repetidamente toda la pila.
Se genera sentry/config.yml desde sentry/config.example.yml. Edite el archivo real:
mail.backend: "smtp"
mail.host: "smtp.example.com"
mail.port: 587
mail.username: "[email protected]"
mail.password: "replace-with-app-password"
mail.use-tls: true
system.url-prefix: "https://sentry.example.com"
system.internal-url-prefix: "http://web:9000"
Seleccione solo mail.use-tls o mail.use-ssl. Proteja credenciales:
cd /opt/sentry/self-hosted
sudo chmod 600 sentry/config.yml
sudo docker compose --env-file .env --env-file .env.custom up -d
Cambiar un archivo montado no recrea contenedores. Después de editar en vivo, ejecute sudo docker compose --env-file .env --env-file .env.custom up -d --force-recreate en mantenimiento y confirme recarga. Verifique propietario legible por el contenedor antes de restringir permisos.
Desde 26.6.0 se exige verificar nuevos correos. Use SMTP real, pruebe entrega y después invite; dummy no sirve para producción.
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:
sentry.example.com {
encode zstd gzip
reverse_proxy 127.0.0.1:9000 {
header_up Host {host}
header_up X-Real-IP {remote_host}
header_up X-Forwarded-For {remote_host}
header_up X-Forwarded-Proto {scheme}
transport http {
read_timeout 90s
write_timeout 90s
}
}
log {
output file /var/log/caddy/sentry-access.log
format json
}
}
Permita escribir registros, por ejemplo con sudo install -d -o caddy -g caddy -m 0750 /var/log/caddy, y recargue:
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
sudo systemctl status caddy --no-pager
curl -fsSI https://sentry.example.com/
Consulte Caddy HTTPS.
cd /opt/sentry/self-hosted
sudo ./sentry-admin.sh createuser
Introduzca correo/contraseña, cree superuser y abra https://sentry.example.com para organización/proyecto. Use contraseña fuerte y 2FA. SDK/CI no utilizan tokens administrativos.
set -euo pipefail
cd /opt/sentry/self-hosted
curl -fsS http://127.0.0.1:9000/_health/
curl -fsSI https://sentry.example.com/
sudo docker compose --env-file .env --env-file .env.custom ps
sudo docker compose --env-file .env --env-file .env.custom logs --since=10m --tail=300 web relay snuba-api
La salud local devuelve ok. Una página sana sin eventos necesita revisar Relay, consumidores Kafka, Snuba y ClickHouse, además de web.
Copie DSN de Settings → Client Keys:
npm install @sentry/browser
import * as Sentry from "@sentry/browser";
Sentry.init({
dsn: "https://[email protected]/PROJECT_ID",
environment: "production",
release: "[email protected]",
tracesSampleRate: 0.1,
beforeSend(event) {
if (event.request?.headers) {
delete event.request.headers.Authorization;
delete event.request.headers.Cookie;
}
return event;
},
});
Envíe excepción:
try {
throw new Error("sentry-self-hosted-test");
} catch (error) {
Sentry.captureException(error);
}
El muestreo 0,1 del ejemplo exige soporte de rendimiento. En errors-only use tracesSampleRate: 0 y traces_sample_rate=0 en Python. No tome tracesSampleRate: 1.0 como predeterminado de producción. Ajuste a carga/valor de diagnóstico. El ejemplo elimina solo dos formas de cabecera: redacte también URL, parámetros, usuarios y variantes de mayúsculas.
Use un entorno virtual de aplicación en Ubuntu 24.04, sin modificar Python del sistema:
sudo apt-get install -y python3-venv
python3 -m venv .venv
. .venv/bin/activate
python3 -m pip install --upgrade sentry-sdk
import os
import sentry_sdk
sentry_sdk.init(
dsn=os.environ["SENTRY_DSN"],
environment=os.getenv("APP_ENV", "production"),
release=os.getenv("APP_RELEASE", "[email protected]"),
traces_sample_rate=0.1,
send_default_pii=False,
)
def divide(a: int, b: int) -> float:
return a / b
divide(1, 0)
Compruebe entorno, release y stack. DSN no es contraseña administrativa, pero se administra por proyecto; Auth Token va al gestor de secretos.
Los mapas permiten entender stacks minificados. release del SDK coincide exactamente con la release subida:
name: build-and-upload-sourcemaps
on:
push:
tags:
- "v*"
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
env:
SENTRY_URL: "https://sentry.example.com/"
SENTRY_ORG: "example-org"
SENTRY_PROJECT: "web"
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: "22"
cache: npm
- run: npm ci
- run: npm run build
- name: Upload source maps
run: |
set -euo pipefail
VERSION="web@${GITHUB_REF_NAME}"
npx --yes @sentry/cli releases new "$VERSION"
npx --yes @sentry/cli sourcemaps inject ./dist
npx --yes @sentry/cli sourcemaps upload --release "$VERSION" ./dist
npx --yes @sentry/cli releases finalize "$VERSION"
El workflow crea web@${GITHUB_REF_NAME}, mientras el SDK fija [email protected]. Defina la variable de release antes de compilar y úsela en el SDK. Active mapas, inyecte debug IDs, suba y despliegue ese mismo dist modificado. Volver a compilar tras inyectar rompe correspondencia.
Fije versiones de Actions/herramientas según política. El token solo necesita permisos de publicación y nunca se imprime.
Compilación, identidad y subida pertenecen al mismo pipeline:
pipeline {
agent any
environment {
SENTRY_URL = 'https://sentry.example.com/'
SENTRY_ORG = 'example-org'
SENTRY_PROJECT = 'web'
}
stages {
stage('Build and upload source maps') {
steps {
withCredentials([string(credentialsId: 'sentry-auth-token', variable: 'SENTRY_AUTH_TOKEN')]) {
sh '''
set -euo pipefail
npm ci
npm run build
VERSION="web@${GIT_COMMIT}"
npx --yes @sentry/cli releases new "$VERSION"
npx --yes @sentry/cli sourcemaps inject ./dist
npx --yes @sentry/cli sourcemaps upload --release "$VERSION" ./dist
npx --yes @sentry/cli releases finalize "$VERSION"
'''
}
}
}
}
}
Pase web@${GIT_COMMIT} al build antes de compilar, inyecte/suba y despliegue los mismos archivos. Use Bash para el shell específico del ejemplo o flags POSIX compatibles. Consulte Jenkins para credenciales y agentes.
- P1: fallo nuevo en producción, muchos usuarios o aumento repentino; avisar inmediatamente.
- P2: regresiones, repetición o transacciones críticas; agrupar 5–15 minutos.
- P3: desarrollo/pruebas o baja frecuencia; resumen diario.
Asigne owner, entorno, release y acción. No envíe cada issue a un único canal. Filtre extensiones del navegador, bots, cancelaciones y excepciones esperadas en SDK; use inbound filters y muestreo en servidor. Observe coincidencias antes de descartar ampliamente.
Use identidades coherentes:
[email protected]+abc1234
[email protected]+def5678
Separe production y staging. Marque despliegues y use identidad correcta al volver atrás. SonarQube cubre calidad estática antes de integrar; Sentry observa fallos en ejecución.
Defina:
- Campos permitidos.
- Redacción de cookies, Authorization, teléfonos y correos.
- Acceso a la organización productiva.
- Retención.
- Revocación de usuarios y tokens.
- Adecuación regional a requisitos regulatorios/transfronterizos.
Defaults no prueban cumplimiento de su política. Combine beforeSend, send_default_pii=False, scrubber del servidor y privilegios mínimos.
SENTRY_EVENT_RETENTION_DAYS=30 en .env.custom afecta cleanup programado. Retención corta reduce crecimiento, sin cubrir cada cache, log y volumen.
cd /opt/sentry/self-hosted
sudo docker system df -v
sudo docker volume ls
df -h /var/lib/docker
df -i /var/lib/docker
sudo docker compose --env-file .env --env-file .env.custom logs --since=24h --tail=1000 sentry-cleanup
No ejecute docker system prune --volumes sin revisión: los volúmenes guardan eventos, archivos y bases.
https://sentry.example.compúblico y/_health/local.- Salud, reinicios y OOM críticos.
- CPU, RAM, carga, disco, inodes e I/O wait.
- Capacidad PostgreSQL, ClickHouse, Kafka y Valkey.
- Entrada Relay y lag de consumidores.
- Certificados Caddy, 5xx y latencia.
- Copias completas y transferencia externa.
Uptime Kuma prueba HTTPS, pero envíe también eventos: una página sana oculta un pipeline bloqueado.
scripts/backup.sh exporta configuración global a sentry/backup.json. No equivale a eventos completos ni snapshot coherente de todos los almacenes.
Incluya:
- Repositorio/configuración del tag.
sentry-data,sentry-postgres,sentry-clickhouse,sentry-kafka,sentry-redisysentry-seaweedfs.- Perfiles, taskbroker y demás persistencia necesaria.
- Configuración Caddy e instrucciones.
- Checksums, cifrado y copias externas.
El original exporta, enumera montajes, detiene y archiva:
#!/usr/bin/env bash
set -euo pipefail
cd /opt/sentry/self-hosted
STAMP="$(date -u +%Y%m%dT%H%M%SZ)"
BACKUP_DIR="/srv/backups/sentry/${STAMP}"
COMPOSE=(sudo docker compose --env-file .env --env-file .env.custom)
sudo install -d -m 0700 "$BACKUP_DIR/volumes"
sudo ./scripts/backup.sh --no-report-self-hosted-issues
sudo cp sentry/backup.json "$BACKUP_DIR/backup.json"
mapfile -t CONTAINERS < <("${COMPOSE[@]}" ps -q)
test "${#CONTAINERS[@]}" -gt 0
mapfile -t VOLUMES < <(
sudo docker inspect "${CONTAINERS[@]}" \
--format '{{range .Mounts}}{{if eq .Type "volume"}}{{println .Name}}{{end}}{{end}}' |
sort -u
)
test "${#VOLUMES[@]}" -gt 0
printf '%s\n' "${VOLUMES[@]}" | sudo tee "$BACKUP_DIR/volumes.list" >/dev/null
"${COMPOSE[@]}" down
sudo tar -C /opt/sentry -czf "$BACKUP_DIR/self-hosted-config.tar.gz" \
--exclude='self-hosted/.git' \
self-hosted
for volume in "${VOLUMES[@]}"; do
safe_name="${volume//\//_}"
sudo docker run --rm \
-v "${volume}:/source:ro" \
-v "$BACKUP_DIR/volumes:/backup" \
alpine:3.22 \
tar -C /source -czf "/backup/${safe_name}.tar.gz" .
done
sudo find "$BACKUP_DIR" -type f ! -name SHA256SUMS -print0 |
sort -z |
sudo xargs -0 sha256sum |
sudo tee "$BACKUP_DIR/SHA256SUMS" >/dev/null
"${COMPOSE[@]}" up --wait
echo "Backup complete: $BACKUP_DIR"
Sustituya por este script root para los volúmenes locales documentados. También inventaría volúmenes declarados existentes, registra commit, copia Caddy, protege secretos y prepara reinicio antes de parar. Los errores de inspección JSON no quedan ocultos en sustitución de procesos:
#!/usr/bin/env bash
set -euo pipefail
test "$(id -u)" -eq 0
cd /opt/sentry/self-hosted
umask 077
exec 9>/run/lock/sentry-backup.lock
flock -n 9
SENTRY_BACKUP="/srv/backups/sentry/$(date -u +%Y%m%dT%H%M%SZ)"
install -d -m 0700 "$SENTRY_BACKUP/volumes"
sentry_compose() {
docker compose --env-file .env --env-file .env.custom "$@"
}
./scripts/backup.sh --no-report-self-hosted-issues
cp sentry/backup.json "$SENTRY_BACKUP/backup.json"
git rev-parse HEAD >"$SENTRY_BACKUP/deployment-commit.txt"
sentry_compose config --format json >"$SENTRY_BACKUP/compose.private.json"
mapfile -t SENTRY_CONTAINERS < <(sentry_compose ps -q)
test "${#SENTRY_CONTAINERS[@]}" -gt 0
docker inspect "${SENTRY_CONTAINERS[@]}" >"$SENTRY_BACKUP/mounts.private.json"
jq -r '.[] | .Mounts[] | select(.Type == "volume") | .Name' \
"$SENTRY_BACKUP/mounts.private.json" >"$SENTRY_BACKUP/volume-candidates.list"
while IFS= read -r SENTRY_VOLUME; do
docker volume inspect "$SENTRY_VOLUME" >/dev/null
done <"$SENTRY_BACKUP/volume-candidates.list"
jq -r '.volumes // {} | to_entries[] | .value.name // empty' \
"$SENTRY_BACKUP/compose.private.json" >>"$SENTRY_BACKUP/volume-candidates.list"
sort -u "$SENTRY_BACKUP/volume-candidates.list" >"$SENTRY_BACKUP/volume-candidates.sorted"
: >"$SENTRY_BACKUP/volumes.list"
while IFS= read -r SENTRY_VOLUME; do
if docker volume inspect "$SENTRY_VOLUME" >/dev/null 2>&1; then
printf '%s\n' "$SENTRY_VOLUME" >>"$SENTRY_BACKUP/volumes.list"
fi
done <"$SENTRY_BACKUP/volume-candidates.sorted"
test -s "$SENTRY_BACKUP/volumes.list"
docker pull alpine:3.22 >/dev/null
trap 'sentry_compose up -d >&2' EXIT
sentry_compose stop
tar -C /opt/sentry -czf "$SENTRY_BACKUP/self-hosted-config.tar.gz" \
--exclude='self-hosted/.git' self-hosted
tar -C /etc -czf "$SENTRY_BACKUP/caddy-config.tar.gz" caddy
while IFS= read -r SENTRY_VOLUME; do
docker run --rm \
-v "$SENTRY_VOLUME:/source:ro" \
-v "$SENTRY_BACKUP/volumes:/backup" \
alpine:3.22 tar -C /source -czf "/backup/$SENTRY_VOLUME.tar.gz" .
done <"$SENTRY_BACKUP/volumes.list"
(
cd "$SENTRY_BACKUP"
find . -type f ! -name SHA256SUMS -print0 | sort -z | \
xargs -0 sha256sum >SHA256SUMS
sha256sum -c SHA256SUMS
)
sentry_compose up --wait
trap - EXIT
touch "$SENTRY_BACKUP/COMPLETE"
chmod -R go-rwx "$SENTRY_BACKUP"
printf 'Backup complete: %s\n' "$SENTRY_BACKUP"
Guarde como /opt/sentry/backup-offline.sh y pruebe en clon. Contraste inventario con almacenes necesarios; servicios externos requieren copia coordinada propia. Acepte COMPLETE verificado y confirme salud tras reiniciar. Cifre/copie fuera del host: el archivo local no sobrevive pérdida del disco. Consulte restic/rclone y restauración.
Al menos mensualmente en VPS aislado:
- Instale Docker/Compose compatibles.
- Checkout del tag/commit; descargue imágenes fijadas y reconstruya imágenes locales desde ese código.
- Verifique
SHA256SUMS. - Cree volúmenes vacíos de
volumes.list. - Extraiga archivos respectivos preservando propietario.
- Restaure configuración
self-hosted. - Inicie perfil completo seleccionado.
- Entre, abra issues históricos y envíe evento nuevo.
- Verifique SMTP, alertas y mapas.
- Registre RTO, RPO y fallos.
Mantenga aislamiento hasta aceptación para no competir con producción por eventos del mismo DSN.
Sentry utiliza CalVer. La lista oficial incluye 26.5.0 y 26.7.0 obligatorios; versiones antiguas pueden necesitar pasos previos. Consulte lista completa y cada release.
set -euo pipefail
cd /opt/sentry/self-hosted
git fetch --tags
git status --short
git tag --sort=-version:refname | head -n 20
sudo /opt/sentry/backup-offline.sh
En la ruta del ejemplo, actualice/verifique 26.5.0, después 26.7.0 y 26.8.0, integrando cambios de configuración en cada parada:
cd /opt/sentry/self-hosted
git checkout 26.8.0
git diff HEAD@{1} -- .env docker-compose.yml sentry/config.example.yml sentry/sentry.conf.example.py
sudo ./install.sh --no-report-self-hosted-issues --minimize-downtime
sudo docker compose --env-file .env --env-file .env.custom ps
curl -fsS http://127.0.0.1:9000/_health/
--minimize-downtime es experimental: puede dejar actualización parcial o no recargar configuración. Prefiera instalador normal en mantenimiento salvo ensayo de esa opción en su ruta exacta.
26.8.0 elimina siete contenedores metrics: corrija referencias en docker-compose.override.yml. También cambia la imagen Redis compatible a Valkey; los monitores no deducen salud por nombre antiguo.
git checkout de un tag anterior no revierte migraciones. El retorno recuperable es:
- Detener versión fallida.
- Aislar volúmenes actuales y conservar evidencia.
- Restaurar persistencia/configuración del mismo punto anterior.
- Checkout del tag original.
- Arrancar y comprobar pipeline.
- Impedir escrituras SDK simultáneas a dos instancias.
Un snapshot VPS necesita procedimiento consistente probado para ser plan de retorno.
El perfil fijado comprueba unos 4 núcleos/14 GB completo y 2 núcleos/7 GB errors-only. Amplíe o cambie perfil dejando margen; no eluda comprobaciones.
Revise DSN, DNS y hora, después pipeline:
cd /opt/sentry/self-hosted
sudo docker compose --env-file .env --env-file .env.custom logs --since=15m --tail=500 relay
sudo docker compose --env-file .env --env-file .env.custom logs --since=15m --tail=500 kafka
sudo docker compose --env-file .env --env-file .env.custom logs --since=15m --tail=500 snuba-consumer-errors
sudo docker compose --env-file .env --env-file .env.custom logs --since=15m --tail=500 clickhouse
Use docker compose config --services con ambos archivos de entorno para nombres reales. errors-only puede omitir servicios del ejemplo completo de otra persona.
curl -v http://127.0.0.1:9000/_health/
sudo ss -lntp | grep ':9000'
sudo journalctl -u caddy --since '15 minutes ago' --no-pager
9000 local inaccesible apunta a Sentry/nginx; investigue Caddy si local funciona y público falla.
Revise mail.backend, SMTP, puerto/TLS, credenciales, remitente y registros. Use 465/587 autenticados si 25 está bloqueado.
Compruebe inundación de eventos, retención, lag y cleanup. Corte volumen SDK anormal, copie y siga procedimientos por componente; no borre datos activos.
Revise notas. Los servicios metrics retirados requieren corregir overrides, monitores y listas de copia fijas.
- Tag oficial revisado
26.8.0, sin master/nightly. - Perfil elegido deliberadamente.
- Recursos superiores al mínimo, con margen del host.
-
SENTRY_BINDsolo en127.0.0.1:9000. - HTTPS Caddy sin backend público.
-
system.url-prefixcoincide con dominio. - SMTP, verificación y alertas probados.
- Excepciones JavaScript/Python en proyecto correcto.
- Release, entorno y mapas coinciden.
- Redacción y muestreo.
- Disco, contenedores, lag y certificados supervisados.
- Copia de toda persistencia/configuración necesaria.
- Restauración aislada probada.
- Todos los hard stops incluidos.
26.8.0 exige unos 2 núcleos/7 GB errors-only y 4/14 GB completo. El original cita referencia 4/16 GB/20 GB libres. Incluya crecimiento y host: aproximadamente 12 GB para errors-only y 16–32 GB completo, después mida.
errors-only puede iniciar sin margen suficiente para recomendar producción. Completo falla mínimos. Amplíe RAM, limite volumen/retención o use alojado.
Revise LICENSE.md y términos exactos. Poder descargar/ejecutar no implica licencia permisiva tradicional. Compruebe usos comerciales, modificaciones y servicio externo.
Web/nginx no prueban Relay → Kafka → consumidores → ClickHouse. Verifique DSN/hora y envíe excepción única siguiendo la cadena.
No. Cleanup tarda y Kafka, archivos, cachés y otros volúmenes tienen ciclos propios. Observe sentry-cleanup, capacidad y curvas de disco.
No. backup.json lógico no es snapshot coordinado de PostgreSQL, ClickHouse, Kafka, SeaweedFS y persistencia. Necesita mantenimiento, copia completa, transferencia externa y prueba de restauración.
Además de ejecutar install.sh, elija perfil, fije versiones, publique HTTPS, alinee mapas y controle volumen, privacidad y disco. Envíe un error de aplicación con release única y restaure una copia aislada. Ambos caminos necesitan verificación.