Tutoriais de VPS
Grafana Loki na VPS (2026): Docker, Alloy, HTTPS, alertas e backups
Instale Loki, Grafana e Alloy no Ubuntu com Docker e Caddy HTTPS. Colete logs de contêineres, configure retenção de 30 dias e alertas, e teste backups privados e restauração.

Quando uma VPS executa sites, bancos, proxy e vários serviços Docker, procurar ocasionalmente com docker logs dificulta saber quando uma falha começou, quais contêineres afeta e se os erros estão aumentando.
Este guia Ubuntu monta uma plataforma central de logs:
- Loki armazena e consulta logs.
- Grafana oferece busca, visualização e alertas.
- Alloy descobre contêineres e coleta seus registros.
- Caddy publica Grafana por HTTPS.
- Loki Compactor aplica retenção de 30 dias.
- Backups offline incluem configuração, dados, checksums e ensaio de restauração.
O original fixa Loki 3.7.6, Grafana 13.2.1 e Alloy 1.19.2. São versões publicadas no período do artigo, sem afirmar que continuam sendo as mais recentes e seguras. Confira notas e mudanças incompatíveis antes de escolher versões mantidas.
Loki indexa principalmente rótulos, sem indexar todo o texto. Geralmente exige menos recursos que uma pilha comparável de busca completa. É adequado para:
- Vários projetos Compose em uma ou poucas VPS.
- Consultas por host, contêiner e serviço.
- Alertas de 5xx, logins malsucedidos e falhas de tarefas.
- Centenas de MB por dia sem manter um grande cluster.
- Equipes que já usam Prometheus e Grafana.
OpenSearch pode ser melhor para buscas complexas ou investigações de segurança. Para exceções, versões e usuários afetados, veja o guia Sentry. Apenas docker logs não exige serviço novo, mas limita correlação, retenção após recriar contêineres e alertas.
Grafana posiciona o modo monolítico para cargas relativamente pequenas, em torno de 20 GB/dia ou menos. É uma referência de arquitetura, sem garantir essa capacidade em uma VPS barata. CPU, RAM, IOPS e consultas podem limitar antes.
| Logs diários | Início conservador | Condições |
|---|---|---|
| Menos de 500 MB | 2 vCPU / 4 GB / 40 GB SSD | Poucos sites e tarefas |
| 500 MB–2 GB | 4 vCPU / 8 GB / 100 GB SSD | Vários contêineres de negócio |
| 2–5 GB | 6–8 vCPU / 16 GB / 200 GB NVMe | Controle rigoroso de consultas/rótulos |
Para 1 GB/dia e 30 dias, reserve pelo menos 60–100 GB para dados, índices, compactação, logs Docker e espaço temporário de backup. Armazenamento filesystem não exclui dados por falta de disco: configure retenção e alertas juntos.
O tráfego local Alloy/Loki/Grafana fica na rede Docker. Consultas grandes do navegador, backups remotos e agentes de outros hosts geram tráfego externo. Ingestão remota exige HTTPS, autenticação e cálculo de volume e cobrança de saída.
Docker stdout/stderr passa por Alloy até Loki, e Grafana apresenta os registros por Caddy. Neste exemplo, Loki 3100 e Grafana 3000 são publicados apenas no loopback do host. O diagrama original é:
Docker 容器 stdout/stderr
|
v
Grafana Alloy --> Loki :3100(仅 Docker 内网)
|
v
Grafana :3000(仅 127.0.0.1)
|
v
Caddy HTTPS :443
Loki não inclui autenticação. Mantenha a API privada; Caddy fornece TLS público apenas para Grafana.
Aponte um domínio como logs.example.com à VPS e instale requisitos:
sudo apt update
sudo apt install -y ca-certificates curl caddy
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker "$USER"
O original executa o instalador de conveniência Docker. Em produção, inspecione o script ou use o repositório apt oficial. Instale openssl e ufw se faltarem. Reconecte SSH após mudar grupos. O grupo Docker concede capacidades administrativas do host: restrinja-o a operadores confiáveis. Confira acesso por chave antes de desabilitar senha SSH.
Permita SSH, HTTP e HTTPS:
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status
Não abra 3000/3100. O vínculo Grafana a 127.0.0.1 acrescenta uma restrição. Confira portas publicadas e regras UFW/nuvem.
sudo mkdir -p /opt/loki-stack/{loki,grafana/provisioning/datasources,alloy}
sudo chown -R "$USER":"$USER" /opt/loki-stack
cd /opt/loki-stack
openssl rand -base64 30
Guarde a senha no gerenciador e crie .env:
umask 077
printf 'GRAFANA_ADMIN_USER=admin\nGRAFANA_ADMIN_PASSWORD=替换为刚才生成的密码\n' > .env
Troque o marcador de senha do comando original pelo valor gerado antes de usar. Não deixe o marcador como senha nem envie o arquivo ao Git.
chmod 600 .env
ls -l .env
Crie /opt/loki-stack/loki/loki.yaml:
auth_enabled: false
server:
http_listen_port: 3100
common:
path_prefix: /loki
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
replication_factor: 1
ring:
instance_addr: 127.0.0.1
kvstore:
store: inmemory
schema_config:
configs:
- from: 2024-01-01
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
retention_period: 720h
ingestion_rate_mb: 8
ingestion_burst_size_mb: 16
max_query_length: 744h
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
analytics:
reporting_enabled: false
Usa TSDB, schema v13 e índice de 24 horas. retention_period: 720h representa 30 dias, mas também exige compactor.retention_enabled: true. Mantenha o diretório Compactor persistente para preservar marcadores pendentes.
Com disco menor, escolha 336h para 14 dias antes de iniciar a ingestão. A documentação diz que mudanças não são retroativas para logs já ingeridos. Reduzir o valor não libera dados históricos imediatamente. Amplie disco ou use exclusão documentada; não apague chunks/índices ativos manualmente.
Crie /opt/loki-stack/grafana/provisioning/datasources/loki.yaml:
apiVersion: 1
datasources:
- name: Loki
uid: loki
type: loki
access: proxy
url: http://loki:3100
isDefault: true
editable: false
jsonData:
maxLines: 1000
http://loki:3100 é o serviço interno Compose. localhost:3100 apontaria ao próprio contêiner Grafana.
Crie /opt/loki-stack/alloy/config.alloy:
discovery.docker "local" {
host = "unix:///var/run/docker.sock"
refresh_interval = "5s"
}
discovery.relabel "docker_logs" {
targets = discovery.docker.local.targets
rule {
source_labels = ["__meta_docker_container_name"]
regex = "/(.*)"
target_label = "container"
}
rule {
source_labels = ["__meta_docker_container_label_com_docker_compose_service"]
target_label = "service_name"
}
rule {
source_labels = ["__meta_docker_container_label_com_docker_compose_project"]
target_label = "compose_project"
}
}
loki.source.docker "local" {
host = "unix:///var/run/docker.sock"
targets = discovery.docker.local.targets
relabel_rules = discovery.relabel.docker_logs.rules
labels = {
host = "vps-01",
job = "docker",
}
forward_to = [loki.write.local.receiver]
}
loki.write "local" {
endpoint {
url = "http://loki:3100/loki/api/v1/push"
}
}
Mantém container, service_name, compose_project, host e job. Evite IDs de requisição/usuário, URLs completas e timestamps nos rótulos: eles geram alta cardinalidade.
Alloy acessa /var/run/docker.sock. Montar com :ro não torna a API Docker somente leitura; o cliente do socket tem grande poder no host. Use imagens confiáveis fixadas, proteja configuração e execute cargas confiáveis.
Crie /opt/loki-stack/compose.yaml:
services:
loki:
image: grafana/loki:3.7.6
command: -config.file=/etc/loki/loki.yaml
restart: unless-stopped
ports:
- "127.0.0.1:3100:3100"
volumes:
- ./loki/loki.yaml:/etc/loki/loki.yaml:ro
- loki-data:/loki
healthcheck:
test: ["CMD", "wget", "-qO-", "http://localhost:3100/ready"]
interval: 15s
timeout: 5s
retries: 10
logging:
options:
max-size: "10m"
max-file: "3"
grafana:
image: grafana/grafana:13.2.1
restart: unless-stopped
depends_on:
loki:
condition: service_healthy
ports:
- "127.0.0.1:3000:3000"
environment:
GF_SECURITY_ADMIN_USER: "${GRAFANA_ADMIN_USER}"
GF_SECURITY_ADMIN_PASSWORD: "${GRAFANA_ADMIN_PASSWORD}"
GF_USERS_ALLOW_SIGN_UP: "false"
GF_AUTH_ANONYMOUS_ENABLED: "false"
GF_SERVER_ROOT_URL: "https://logs.example.com"
volumes:
- grafana-data:/var/lib/grafana
- ./grafana/provisioning:/etc/grafana/provisioning:ro
logging:
options:
max-size: "10m"
max-file: "3"
alloy:
image: grafana/alloy:v1.19.2
command:
- run
- --storage.path=/var/lib/alloy/data
- /etc/alloy/config.alloy
restart: unless-stopped
depends_on:
loki:
condition: service_healthy
volumes:
- ./alloy/config.alloy:/etc/alloy/config.alloy:ro
- /var/run/docker.sock:/var/run/docker.sock:ro
- alloy-data:/var/lib/alloy/data
logging:
options:
max-size: "10m"
max-file: "3"
volumes:
loki-data:
grafana-data:
alloy-data:
Os limites logging rotacionam logs Docker da própria pilha. Sem eles, a partição raiz pode encher mesmo com retenção Loki. Veja o guia Compose de produção.
As verificações originais são:
cd /opt/loki-stack
docker compose config --quiet
docker run --rm \
-v "$PWD/loki/loki.yaml:/etc/loki/loki.yaml:ro" \
grafana/loki:3.7.6 \
-config.file=/etc/loki/loki.yaml -verify-config
docker run --rm \
-v "$PWD/alloy/config.alloy:/etc/alloy/config.alloy:ro" \
grafana/alloy:v1.19.2 \
fmt --check /etc/alloy/config.alloy
Alloy documenta --test, sem o --check do original. Formatação confere sintaxe/formato, sem validar componentes; rode também validate:
docker run --rm \
-v "$PWD/alloy/config.alloy:/etc/alloy/config.alloy:ro" \
grafana/alloy:v1.19.2 fmt --test /etc/alloy/config.alloy
docker run --rm \
-v "$PWD/alloy/config.alloy:/etc/alloy/config.alloy:ro" \
grafana/alloy:v1.19.2 validate /etc/alloy/config.alloy
A imagem Loki fixada é distroless, sem wget, shell e du. O healthcheck original falha e bloqueia dependências service_healthy. Antes de iniciar, crie este compose.override.yaml, carregado automaticamente, e confira readiness por HTTP no host:
set -eu
cd /opt/loki-stack
cat >compose.override.yaml <<'YAML'
services:
loki:
healthcheck:
disable: true
grafana:
depends_on:
loki:
condition: service_started
alloy:
depends_on:
loki:
condition: service_started
YAML
docker compose config --quiet
docker compose pull
docker compose up -d loki
LOKI_READY=0
for LOKI_ATTEMPT in $(seq 1 60); do
if curl -fsS http://127.0.0.1:3100/ready; then
LOKI_READY=1
break
fi
sleep 2
done
test "$LOKI_READY" -eq 1
docker compose up -d grafana alloy
docker compose ps
Contêiner iniciado não comprova saúde. Mantenha monitoramento de readiness no host. Após as correções, os comandos originais ajudam a inspecionar:
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 loki alloy grafana
curl -fsS http://127.0.0.1:3100/ready
curl -fsS http://127.0.0.1:3000/api/health
Loki deve retornar ready; Grafana deve indicar banco ok. Aguarde inicialização antes de concluir que a verificação falhou.
Edite /etc/caddy/Caddyfile com domínio real, igual à root URL de Grafana:
logs.example.com {
encode zstd gzip
reverse_proxy 127.0.0.1:3000
header {
Strict-Transport-Security "max-age=31536000; includeSubDomains"
X-Content-Type-Options "nosniff"
Referrer-Policy "strict-origin-when-cross-origin"
}
}
Valide e recarregue:
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
curl -I https://logs.example.com/login
Caddy obtém e renova certificados. Veja o guia Caddy HTTPS para diagnosticar o proxy.
Após entrar, crie outro administrador e confira-o antes de desabilitar ou renomear admin. Para vários usuários, prefira provedor de identidade com MFA a compartilhar senha.
O teste temporário original é:
docker run --rm alpine:3.22 sh -c \
'echo "loki-smoke-test level=info"; echo "sample failure level=error" >&2'
Ele termina e se remove antes que a descoberta, atualizada a cada 5 segundos, possa vê-lo. Mantenha o contêiner ativo durante essa descoberta:
docker run --rm alpine:3.22 sh -c \
'echo "loki-smoke-test level=info"; echo "sample failure level=error" >&2; sleep 20'
Abra Drilldown > Logs ou Explore, selecione Loki e consulte:
{job="docker"} |= "loki-smoke-test"
Outras consultas:
{compose_project="myapp"}
{service_name="nginx"} |~ "(?i)error|critical|panic"
sum by (service_name) (
count_over_time({job="docker"} |~ "(?i)error|exception" [5m])
)
topk(10, sum by (service_name) (
rate({job="docker"}[5m])
))
Reduza período e rótulos estáveis antes de filtrar com |= ou |~. Evite regex em todos os contêineres por 30 dias como consulta habitual.
Rótulos úteis têm poucos valores estáveis:
- Host.
- Ambiente, como production/staging.
- Projeto Compose.
- Serviço.
- Contêiner.
IPs, pedidos, usuários, requisições, URLs completas e IDs aleatórios de tarefas devem ficar no texto e ser analisados ao consultar. Se o número de fluxos cresce, confira rótulos dinâmicos Docker e relabeling Alloy. Cada rótulo proposto deve ter valores limitados e estáveis.
Alertas gerenciados pelo Grafana podem avaliar Loki, por exemplo:
sum by (service_name) (
count_over_time({job="docker"} |~ "(?i)error|exception|panic" [5m])
) > 20
Conta linhas correspondentes em cinco minutos, sem representar percentual de erro. Configure cinco minutos de pending para evitar picos curtos de implantação. Defina contact points e políticas reais para e-mail, Slack, Telegram ou webhook.
Observe uma semana e crie limites por serviço em vez de alertar a cada “error”. Combine logs com CPU, RAM, disco e disponibilidade do guia Prometheus/Grafana.
Alerte também sobre:
- Disco raiz/Docker acima de 80%.
- Reinícios Loki ou falha em
/ready. - Registros descartados, falhas de escrita ou reconexão contínua no Alloy.
- Não registre senhas, cookies, Authorization, API keys e pagamento completo.
- Remova dados sensíveis na aplicação primeiro; regex do agente é complementar.
- Mantenha Loki 3100 e depuração Alloy privados.
- Limite administradores; leitores comuns usam Viewer.
- Revise permissões do proxy de fontes e plugins.
- Criptografe backups antes de enviar para outro host.
auth_enabled: false corresponde apenas a esta rede fechada de um host. Outros servidores precisam de proxy TLS autenticado ou gateway com autorização por tenant. Não publique 3100.
Pause a pilha e arquive os três volumes e a configuração. O original propõe /usr/local/sbin/backup-loki-stack.sh:
#!/usr/bin/env bash
set -Eeuo pipefail
STACK_DIR="/opt/loki-stack"
BACKUP_ROOT="/var/backups/loki-stack"
STAMP="$(date -u +%Y%m%dT%H%M%SZ)"
TARGET="$BACKUP_ROOT/loki-stack-$STAMP.tar.gz"
mkdir -p "$BACKUP_ROOT"
cd "$STACK_DIR"
docker compose stop alloy grafana loki
trap 'docker compose start loki grafana alloy' EXIT
LOKI_VOL="$(docker inspect loki-stack-loki-1 \
--format '{{range .Mounts}}{{if eq .Destination "/loki"}}{{.Name}}{{end}}{{end}}')"
GRAFANA_VOL="$(docker inspect loki-stack-grafana-1 \
--format '{{range .Mounts}}{{if eq .Destination "/var/lib/grafana"}}{{.Name}}{{end}}{{end}}')"
ALLOY_VOL="$(docker inspect loki-stack-alloy-1 \
--format '{{range .Mounts}}{{if eq .Destination "/var/lib/alloy/data"}}{{.Name}}{{end}}{{end}}')"
test -n "$LOKI_VOL"
test -n "$GRAFANA_VOL"
test -n "$ALLOY_VOL"
docker run --rm \
-v "$LOKI_VOL:/source/loki:ro" \
-v "$GRAFANA_VOL:/source/grafana:ro" \
-v "$ALLOY_VOL:/source/alloy:ro" \
-v "$STACK_DIR:/source/config:ro" \
-v /etc/caddy:/source/caddy:ro \
-v "$BACKUP_ROOT:/backup" \
alpine:3.22 \
tar -czf "/backup/$(basename "$TARGET")" -C /source \
loki grafana alloy config caddy
sha256sum "$TARGET" > "$TARGET.sha256"
find "$BACKUP_ROOT" -type f -mtime +14 -delete
Corrija nomes de contêiner presumidos e permissões amplas de criação. Use este script como root para os volumes documentados. Ele obtém montagens por IDs reais, protege credenciais e prepara reinício antes de parar:
#!/usr/bin/env bash
set -euo pipefail
test "$(id -u)" -eq 0
cd /opt/loki-stack
umask 077
exec 9>/run/lock/loki-stack-backup.lock
flock -n 9
LOKI_BACKUP="/var/backups/loki-stack/$(date -u +%Y%m%dT%H%M%SZ)"
install -d -m 0700 "$LOKI_BACKUP"
LOKI_CID="$(docker compose ps -q loki)"
GRAFANA_CID="$(docker compose ps -q grafana)"
ALLOY_CID="$(docker compose ps -q alloy)"
test -n "$LOKI_CID" && test -n "$GRAFANA_CID" && test -n "$ALLOY_CID"
LOKI_VOL="$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/loki"}}{{.Name}}{{end}}{{end}}' "$LOKI_CID")"
GRAFANA_VOL="$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/var/lib/grafana"}}{{.Name}}{{end}}{{end}}' "$GRAFANA_CID")"
ALLOY_VOL="$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/var/lib/alloy/data"}}{{.Name}}{{end}}{{end}}' "$ALLOY_CID")"
test -n "$LOKI_VOL" && test -n "$GRAFANA_VOL" && test -n "$ALLOY_VOL"
docker volume inspect "$LOKI_VOL" "$GRAFANA_VOL" "$ALLOY_VOL" >/dev/null
docker pull alpine:3.22 >/dev/null
trap 'docker compose start loki grafana alloy >&2' EXIT
docker compose stop alloy grafana loki
docker run --rm \
-v "$LOKI_VOL:/source/loki:ro" \
-v "$GRAFANA_VOL:/source/grafana:ro" \
-v "$ALLOY_VOL:/source/alloy:ro" \
-v "$PWD:/source/config:ro" \
-v /etc/caddy:/source/caddy:ro \
-v "$LOKI_BACKUP:/backup" \
alpine:3.22 tar -czf /backup/loki-stack.tar.gz -C /source \
loki grafana alloy config caddy
(
cd "$LOKI_BACKUP"
sha256sum loki-stack.tar.gz >loki-stack.tar.gz.sha256
sha256sum -c loki-stack.tar.gz.sha256
)
docker compose start loki grafana alloy
trap - EXIT
touch "$LOKI_BACKUP/COMPLETE"
chmod -R go-rwx "$LOKI_BACKUP"
printf 'Backup complete: %s\n' "$LOKI_BACKUP"
Habilite e teste:
sudo chmod 700 /usr/local/sbin/backup-loki-stack.sh
sudo /usr/local/sbin/backup-loki-stack.sh
sudo ls -lh /var/backups/loki-stack
sudo sha256sum -c /var/backups/loki-stack/*.sha256
O original presume projeto loki-stack. docker compose ps e docker inspect ajudam a conferir nomes reais. A substituição evita nomes gerados e inclui o override automático. Aceite apenas arquivo com COMPLETE e checksums verificados; o monitoramento confirma a volta da saúde.
Durante a pausa, Docker pode rotacionar registros ainda não lidos, causando perda de ingestão. Se precisa de continuidade, use objetos e backup consistente testado, sem executar tar sobre arquivos ativos. Veja o ensaio de backup/restauração para proteção externa.
Em uma VPS temporária isolada:
- Instale Docker/Caddy compatíveis e inicialmente as mesmas versões das aplicações.
- Verifique SHA-256.
- Extraia configuração/dados de forma privada.
- Crie três volumes novos e restaure seus respectivos dados.
- Confira volumes e domínio de teste em
compose.yamle no override. - Inicie Loki, Grafana e Alloy.
- Consulte um registro conhecido anterior ao backup.
- Confira fontes, alertas e usuários.
O exemplo original de extração é:
sha256sum -c loki-stack-20260906T020000Z.tar.gz.sha256
mkdir -p /tmp/loki-restore
tar -xzf loki-stack-20260906T020000Z.tar.gz -C /tmp/loki-restore
find /tmp/loki-restore -maxdepth 2 -type d -print
Use o arquivo real, sem copiar a data histórica. Confira consultas antigas, login, alertas e ingestão nova; iniciar contêineres não comprova restauração.
Exemplo de patch/versão menor Grafana:
cd /opt/loki-stack
sudo /usr/local/sbin/backup-loki-stack.sh
docker compose pull grafana
docker compose up -d grafana
docker compose ps
docker compose logs --tail=100 grafana
curl -fsS http://127.0.0.1:3000/api/health
Leia notas, faça backup e mude uma tag. Confira login, fontes, consultas e alertas antes de seguir.
Se atualizar o banco Grafana ou formato Loki, voltar apenas a imagem pode ser inseguro. Restaure o snapshot anterior correspondente. Siga backup, pull, atualização individual, saúde, consulta real e observação.
docker compose exec grafana \
wget -qO- http://loki:3100/ready
docker compose logs --tail=200 loki grafana
Use http://loki:3100, não localhost, na fonte.
docker compose logs --tail=200 alloy
docker compose exec alloy ls -l /var/run/docker.sock
docker inspect loki-stack-alloy-1 --format '{{json .Mounts}}'
Confira montagem do socket, configuração carregada e possível caminho Docker fora do padrão.
docker system df
docker compose exec loki du -sh /loki/*
docker compose logs --tail=300 loki | grep -iE 'compactor|retention|delete|error'
O du original não existe nessa imagem distroless. Inspecione o volume com contêiner de ferramentas em somente leitura ou monitoramento do host. Confira retention_enabled, índice 24 horas e diretório Compactor persistente. Exclusão tem atraso e mudanças de retenção não são retroativas; não espere 95% de uso.
Reduza o intervalo e adicione service_name, compose_project ou host. Confira cardinalidade. Regex em todos os serviços por 30 dias não deve ser rotina em uma VPS.
curl -fsS http://127.0.0.1:3000/api/health
sudo journalctl -u caddy -n 100 --no-pager
sudo caddy validate --config /etc/caddy/Caddyfile
Se 3000 local está saudável, confira domínio, certificado e destino do proxy.
- DNS e 80/443 públicos funcionam.
- 3000/3100 ficam privados.
- Loki, Grafana e Alloy com versões fixadas.
- Compose efetivo, Loki e Alloy validados.
- Senha administrativa alterada e anônimo desativado.
- LogQL encontra a entrada de teste.
- Rótulos sem IDs dinâmicos de usuário/requisição.
- Retenção e alertas de disco ativos.
- Alertas chegam a um canal real.
- Backups incluem três volumes e configuração.
- Restauração isolada concluída.
- Atualizações individuais.
4 GB é um começo prático para logs moderados, sem ser mínimo obrigatório. Intervalo, concorrência, volume e rótulos mudam a demanda. 2 GB permite testes, mas não é recomendável para serviços importantes e consultas longas juntos.
Não para todas as cargas. Loki filtra rótulos e percorre texto com menor custo de indexação. Busca completa, agregações complexas e segurança podem favorecer Elasticsearch/OpenSearch. Escolha conforme consultas.
Compactor exclui de forma assíncrona e mudanças oficiais não são retroativas. Confira índice TSDB de 24 horas, marcadores persistentes e erros. Reserve espaço sem depender de limpeza instantânea.
Sim, por gateway/proxy TLS autenticado, restrições de origem e planejamento de tráfego. Multi-tenant exige controle de cabeçalhos de tenant e autorização. Mantenha 3100 privado.
Prefira Alloy para instalações novas. Combina descoberta, relabeling, logs, métricas e traces. Compare etapas Promtail com a documentação de migração antes de mudar.
Este arquivo filesystem exige pausa para consistência. Serviço contínuo precisa de objetos/versionamento compatíveis ou snapshots testados, com procedimento próprio de consistência e recuperação.