Tutoriais de VPS
Sentry na VPS (2026): Docker, HTTPS, SDKs, alertas e recuperação
Instale Sentry Self-Hosted 26.8.0 no Ubuntu com errors-only, Caddy HTTPS e SMTP. Configure SDKs JavaScript/Python, mapas e releases, reduza ruído e teste backups completos e atualização.

Diagnosticar exceções é difícil sem identificar versão, usuário, requisição e ambiente. Sentry coleta stacks, breadcrumbs, releases e contexto, agrupa eventos repetidos em issues e notifica responsáveis por e-mail e integrações.
Este guia usa Ubuntu 24.04, Sentry Self-Hosted 26.8.0, Docker Compose e Caddy. Inclui recursos, errors-only, HTTPS, SMTP, SDKs JavaScript/Python, Source Map, releases, redução de ruído, recuperação offline e etapas obrigatórias de atualização.
Contexto de versão: o original apresentava
26.8.0como a versão mais recente em 5 de setembro de 2026. Essa data é histórica. A release verificada remove sete contêineres metrics, troca Redis pelo serviço compatível Valkey e inclui correções de segurança. Fixe uma tag suportada revisado; evite nightly e atualização automática de produção.
Há dois limites:
- Self-Hosted oficial atende baixo volume e avaliação, sem substituir o SaaS sem manutenção.
- PostgreSQL, ClickHouse, Kafka, Valkey, Relay, Snuba, Symbolicator e SeaweedFS exigem mais recursos e operação que um blog.
Considere hospedagem própria quando:
- Eventos não podem ir para um SaaS externo.
- A equipe controla retenção e localização.
- Serviços internos não alcançam Sentry público.
- Alguém mantém Docker, bancos, backups e alertas.
- Projetos JavaScript, Python, Java ou móveis de baixo volume precisam de uma entrada comum.
Para um projeto pequeno sem capacidade de resposta e recuperação, hospedado pode custar menos. A economia de assinatura ou saída de dados vira VPS, backup, atualização e incidentes.
| Ferramenta | Melhor função | Entrada | Não substitui |
|---|---|---|---|
| Sentry | Exceções, stacks, releases e traces | Eventos SDK | Logs completos e métricas de infraestrutura |
| Loki/OpenObserve | Busca e retenção de logs | stdout, arquivos, agentes | Contexto SDK |
| Prometheus/Grafana | Tendências numéricas | Métricas | Stack detalhado |
| Uptime Kuma | Disponibilidade externa e certificados | HTTP/TCP/DNS | Diagnóstico interno |
Uma sonda detecta site indisponível, Sentry identifica release/linha e os logs mostram requisições próximas. Veja Uptime Kuma se faltam verificações externas.
O instalador 26.8.0 tem mínimos específicos:
| Modo | Mínimo do instalador | Início prático | Uso |
|---|---|---|---|
errors-only | 2 vCPU, cerca de 7 GB disponíveis ao Docker | 4 vCPU / 12 GB / 100 GB NVMe | Erros |
feature-complete | 4 vCPU, cerca de 14 GB disponíveis | 4–8 vCPU / 16–32 GB / 200 GB NVMe | Desempenho, Replay e mais |
O original cita referência oficial de 4 núcleos, 16 GB e 20 GB livres. Espaço mínimo não é capacidade duradoura: eventos, anexos, replay, perfis, ClickHouse e Kafka crescem. Reserve 100–200 GB NVMe e meça volume/retenção.
8 GB deixa pouca margem até em errors-only. Muito swap não substitui RAM, especialmente para ClickHouse/Kafka.
Upload mensal é aproximadamente tamanho médio × eventos diários × 30. A fórmula original é:
月上行流量 ≈ 平均事件大小 × 每日事件数 × 30
20 KB e 100.000 eventos/dia geram cerca de 60 GB/mês antes de anexos, replay, Source Map e protocolos. Use conectividade estável e franquia suficiente; disco e RAM costumam limitar primeiro.
Configure amostragem, filtre erros esperados e exclua dados sensíveis. Um loop pode inundar o serviço em minutos.
Use getsentry/self-hosted oficial. SDKs passam por Caddy HTTPS, depois nginx/Relay local e o pipeline:
应用 SDK
↓ HTTPS 443
Caddy(宿主机 TLS)
↓ 127.0.0.1:9000
官方 nginx / Relay
↓
Sentry Web + Worker + Snuba
↓
PostgreSQL / ClickHouse / Kafka / Valkey / SeaweedFS
Somente Caddy é público. nginx usa 127.0.0.1:9000; bancos e filas ficam no Docker.
Aponte sentry.example.com à VPS e permita:
22/tcp: SSH restrito.80/tcp: certificado e redirecionamento.443/tcpe443/udp: HTTPS/HTTP3.9000/tcp: apenas loopback, sem abertura pública.- Nenhuma porta pública PostgreSQL, ClickHouse, Kafka ou Valkey.
export SENTRY_DOMAIN="sentry.example.com"
getent ahosts "$SENTRY_DOMAIN"
curl -4 https://ifconfig.me
Publique AAAA apenas com IPv6 funcional. Confira vínculos Docker e regras da nuvem além do 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
Essa versão exige Docker 19.03.6+, Compose 2.32.2+ e Bash 4.4+. Confira resultados e instale openssl se faltar para gerar segredos. Veja Compose de produção.
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 e backup verificado; não altere caminhos do daemon casualmente depois de 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
O resultado final deve mostrar 26.8.0. Evite master/nightly com mudanças não revisadas.
errors-only oferece erros, issues, releases e alertas básicos. feature-complete habilita desempenho, replay, perfis e demais funções suportadas.
Guarde overrides em .env.custom, sem copiar todo .env e congelar padrões antigos:
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 recursos completos, altere COMPOSE_PROFILES para feature-complete. Ajuste concorrência à RAM. Mantenha atribuições dotenv válidas também em shell: o instalador oficial executa o arquivo além de usá-lo no Compose.
Confira tag e alterações:
cd /opt/sentry/self-hosted
git status --short
sudo ./install.sh --no-report-self-hosted-issues
Verifica recursos, cria volumes/configuração/segredos, constrói imagens e inicializa/migra armazenamento. A primeira instalação pode superar dez minutos.
Carregue ambos os arquivos:
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 por saúde/dependências antes de reiniciar a pilha repetidamente.
Gera sentry/config.yml a partir de sentry/config.example.yml. Edite o arquivo 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"
Escolha apenas mail.use-tls ou mail.use-ssl. Proteja credenciais:
cd /opt/sentry/self-hosted
sudo chmod 600 sentry/config.yml
sudo docker compose --env-file .env --env-file .env.custom up -d
Mudar um arquivo montado não recria contêineres. Depois de editar em produção, execute sudo docker compose --env-file .env --env-file .env.custom up -d --force-recreate em manutenção e confirme recarga. Confira propriedade legível pelo contêiner antes de restringir permissões.
Desde 26.6.0, novos e-mails exigem verificação. Use SMTP real, teste entrega e depois convide; dummy não atende produção.
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
Crie /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 gravar logs, por exemplo com sudo install -d -o caddy -g caddy -m 0750 /var/log/caddy, e recarregue:
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
sudo systemctl status caddy --no-pager
curl -fsSI https://sentry.example.com/
Veja Caddy HTTPS.
cd /opt/sentry/self-hosted
sudo ./sentry-admin.sh createuser
Informe e-mail/senha, crie superuser e abra https://sentry.example.com para organização/projeto. Use senha forte e 2FA. SDK/CI não usam 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
Saúde local retorna ok. Página saudável sem eventos exige conferir Relay, consumidores Kafka, Snuba e ClickHouse, além 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;
},
});
Envie exceção:
try {
throw new Error("sentry-self-hosted-test");
} catch (error) {
Sentry.captureException(error);
}
A amostragem 0,1 exige suporte a desempenho. Em errors-only use tracesSampleRate: 0 e traces_sample_rate=0 no Python. Não adote tracesSampleRate: 1.0 como padrão de produção. Ajuste à carga/valor de diagnóstico. O exemplo elimina só duas grafias de cabeçalhos: remova também dados de URLs, parâmetros, usuários e variantes de caixa.
Use ambiente virtual da aplicação no Ubuntu 24.04, sem modificar Python gerenciado pelo 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)
Confira ambiente, release e stack. DSN não é senha administrativa, mas é gerenciado por projeto; Auth Token fica no gerenciador de segredos.
Mapas permitem entender stacks minificados. release do SDK coincide exatamente com a release enviada:
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"
O workflow cria web@${GITHUB_REF_NAME}, mas o SDK fixa [email protected]. Defina a variável de release antes de compilar e use-a no SDK. Habilite mapas, injete debug IDs, envie e implante esse mesmo dist modificado. Recompilar depois da injeção quebra a correspondência.
Fixe versões de Actions/ferramentas conforme política. O token precisa apenas de permissões de publicação e nunca é impresso.
Build, identidade e envio ficam no mesmo 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"
'''
}
}
}
}
}
Passe web@${GIT_COMMIT} ao build antes de compilar, injete/envie e implante os mesmos arquivos. Use Bash para o shell específico do exemplo ou flags POSIX compatíveis. Veja Jenkins para credenciais e agentes.
- P1: falha nova em produção, muitos usuários ou aumento repentino; notifique imediatamente.
- P2: regressões, repetição e transações críticas; agregue por 5–15 minutos.
- P3: desenvolvimento/teste ou baixa frequência; resumo diário.
Defina owner, ambiente, release e ação. Não envie toda issue para um único canal. Filtre extensões, bots, cancelamentos e exceções esperadas no SDK; use inbound filters e amostragem no servidor. Observe correspondências antes de descartar amplamente.
Use identidades consistentes:
[email protected]+abc1234
[email protected]+def5678
Separe production e staging. Marque implantações e use a identidade correta ao retornar. SonarQube verifica qualidade estática antes de integrar; Sentry observa falhas em execução.
Defina:
- Campos permitidos.
- Remoção de cookies, Authorization, telefone e e-mail.
- Acesso à organização produtiva.
- Retenção.
- Revogação de usuários e tokens.
- Adequação da região a regras regulatórias/transfronteiriças.
Padrões não comprovam conformidade com sua política. Combine beforeSend, send_default_pii=False, scrubber do servidor e privilégio mínimo.
SENTRY_EVENT_RETENTION_DAYS=30 em .env.custom afeta cleanup programado. Retenção curta reduz crescimento sem cobrir todos os caches, logs e volumes.
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
Não execute docker system prune --volumes sem revisão: os volumes guardam eventos, arquivos e bancos.
https://sentry.example.compúblico e/_health/local.- Saúde, reinícios e OOM críticos.
- CPU, RAM, carga, disco, inodes e I/O wait.
- Capacidade PostgreSQL, ClickHouse, Kafka e Valkey.
- Entrada Relay e lag dos consumidores.
- Certificados Caddy, 5xx e latência.
- Backups completos e transferência externa.
Uptime Kuma verifica HTTPS, mas envie eventos também: página saudável pode ocultar pipeline bloqueado.
scripts/backup.sh exporta configuração global para sentry/backup.json. Não é backup completo de eventos nem snapshot consistente de todos os armazenamentos.
Inclua:
- Repositório/configuração do tag.
sentry-data,sentry-postgres,sentry-clickhouse,sentry-kafka,sentry-redisesentry-seaweedfs.- Perfis, taskbroker e demais persistências necessárias.
- Caddy e instruções de recuperação.
- Checksums, criptografia e cópias externas.
O original exporta, enumera montagens, para e arquiva:
#!/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"
Substitua por este script root para os volumes locais documentados. Ele também inventaria volumes declarados existentes, registra commit, copia Caddy, protege segredos e prepara reinício antes de parar. Erros de inspeção JSON não ficam ocultos em substituição de processos:
#!/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"
Salve como /opt/sentry/backup-offline.sh e teste em clone. Compare inventário com armazenamentos necessários; serviços externos precisam de backup coordenado próprio. Aceite COMPLETE verificado e confirme saúde após iniciar. Criptografe/copie para outro host: arquivo local não sobrevive perda do disco. Veja restic/rclone e recuperação.
Pelo menos mensalmente em VPS isolada:
- Instale Docker/Compose compatíveis.
- Checkout do tag/commit; baixe imagens fixadas e reconstrua imagens locais desse código.
- Verifique
SHA256SUMS. - Crie volumes vazios de
volumes.list. - Extraia arquivos respectivos preservando propriedade.
- Restaure configuração
self-hosted. - Inicie o perfil completo escolhido.
- Entre, abra issues históricas e envie evento novo.
- Confira SMTP, alertas e mapas.
- Registre RTO, RPO e falhas.
Mantenha isolamento até aceitar a restauração, evitando competir com produção por eventos do mesmo DSN.
Sentry usa CalVer. A lista oficial inclui 26.5.0 e 26.7.0 obrigatórios; versões antigas podem exigir passos anteriores. Confira a lista inteira e 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
Na rota do exemplo, atualize/verifique 26.5.0, depois 26.7.0 e 26.8.0, incorporando configuração em 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 é experimental: pode deixar atualização parcial ou não recarregar configuração. Prefira instalador normal em manutenção, salvo ensaio dessa opção na sua rota exata.
26.8.0 remove sete contêineres metrics: corrija referências em docker-compose.override.yml. Também muda a imagem compatível Redis para Valkey; monitores não deduzem saúde pelo nome antigo.
git checkout de um tag antigo não desfaz migrações. O retorno recuperável é:
- Parar a versão que falhou.
- Isolar volumes atuais e preservar evidências.
- Restaurar persistência/configuração do mesmo ponto anterior.
- Checkout do tag original.
- Iniciar e verificar pipeline.
- Impedir escrita SDK simultânea em duas instâncias.
Snapshot de VPS precisa de procedimento consistente testado para ser plano de retorno.
O perfil fixado verifica cerca de 4 núcleos/14 GB completo e 2/7 GB errors-only. Amplie ou mude o perfil com margem do host; não burle verificações.
Confira DSN, DNS e hora, depois 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 com ambos os arquivos de ambiente para nomes reais. errors-only pode omitir serviços do exemplo completo de outra pessoa.
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 inacessível aponta para Sentry/nginx; investigue Caddy se local funciona e público falha.
Confira mail.backend, SMTP, porta/TLS, credenciais, remetente e logs. Use 465/587 autenticados se 25 estiver bloqueado.
Confira inundação de eventos, retenção, lag e cleanup. Reduza volume SDK anormal, faça backup e siga procedimentos dos componentes; não apague dados ativos.
Leia notas. Serviços metrics retirados exigem corrigir overrides, monitores e listas fixas de backup.
- Tag oficial revisado
26.8.0, sem master/nightly. - Perfil escolhido deliberadamente.
- Recursos acima do mínimo, com margem do host.
-
SENTRY_BINDsomente em127.0.0.1:9000. - HTTPS Caddy sem backend público.
-
system.url-prefixigual ao domínio. - SMTP, verificação e alertas testados.
- Exceções JavaScript/Python no projeto correto.
- Release, ambiente e mapas correspondem.
- Remoção de dados e amostragem configuradas.
- Disco, contêineres, lag e certificados monitorados.
- Backup de toda persistência/configuração necessária.
- Restauração isolada testada.
- Todos os hard stops incluídos.
26.8.0 exige cerca de 2 núcleos/7 GB errors-only e 4/14 GB completo. O original cita referência 4/16 GB/20 GB livres. Inclua crescimento e host: aproximadamente 12 GB errors-only e 16–32 GB completo; depois meça.
errors-only pode iniciar sem margem suficiente para recomendar produção. Completo falha nos mínimos. Amplie RAM, limite volume/retenção ou use hospedado.
Confira LICENSE.md e termos exatos. Poder baixar/executar não implica licença permissiva tradicional. Verifique usos comerciais, alterações e serviço externo.
Web/nginx não comprovam Relay → Kafka → consumidores → ClickHouse. Confira DSN/hora e envie exceção única acompanhando a cadeia.
Não. Cleanup leva tempo, e Kafka, arquivos, caches e outros volumes têm ciclos próprios. Observe sentry-cleanup, capacidade e curva do disco.
Não. backup.json lógico não é snapshot coordenado de PostgreSQL, ClickHouse, Kafka, SeaweedFS e persistências. Exige manutenção, backup completo, cópia externa e ensaio de restauração.
Além de executar install.sh, escolha perfil, fixe versões, publique HTTPS, alinhe mapas e controle volume, privacidade e disco. Envie uma exceção da aplicação com release única e restaure um backup isolado. Ambos os caminhos precisam de verificação.