Tutoriales de VPS
Grafana Loki en VPS (2026): Docker, Alloy, HTTPS, alertas y copias
Instale Loki, Grafana y Alloy en Ubuntu con Docker y Caddy HTTPS. Recoja logs de contenedores, configure retención de 30 días y alertas, y pruebe copias privadas y restauración.

Si un VPS ejecuta sitios, bases, proxy y varios servicios Docker, buscar ocasionalmente con docker logs dificulta saber cuándo empezó un fallo, qué contenedores afecta y si aumentan los errores.
Esta guía Ubuntu monta una plataforma central de registros:
- Loki almacena y consulta logs.
- Grafana ofrece búsqueda, visualización y alertas.
- Alloy descubre contenedores y recoge sus registros.
- Caddy publica Grafana por HTTPS.
- Loki Compactor aplica retención de 30 días.
- Las copias offline incluyen configuración, datos, checksums y restauración de prueba.
El original fija Loki 3.7.6, Grafana 13.2.1 y Alloy 1.19.2. Son versiones publicadas del periodo del artículo, sin afirmar que sigan siendo las más recientes y seguras. Revise notas y cambios incompatibles antes de elegir versiones mantenidas.
Loki indexa principalmente etiquetas, sin indexar todo el texto. Suele necesitar menos recursos que una pila comparable de búsqueda completa. Encaja con:
- Varios proyectos Compose en uno o pocos VPS.
- Consultas por host, contenedor o servicio.
- Alertas de 5xx, accesos fallidos y errores de tareas.
- Cientos de MB diarios sin mantener un gran clúster.
- Equipos que ya usan Prometheus y Grafana.
OpenSearch puede encajar mejor en búsquedas complejas o investigaciones de seguridad. Para excepciones, versiones y usuarios afectados, consulte la guía Sentry. Solo docker logs no necesita instalar nada, pero limita correlación, conservación tras recrear contenedores y alertas.
Grafana sitúa el modo monolítico en cargas relativamente pequeñas, alrededor de 20 GB/día o menos. Es una referencia arquitectónica, sin garantizar esa capacidad en un VPS barato. CPU, RAM, IOPS y consultas pueden limitar antes.
| Logs diarios | Inicio conservador | Condiciones |
|---|---|---|
| Menos de 500 MB | 2 vCPU / 4 GB / 40 GB SSD | Pocos sitios y tareas |
| 500 MB–2 GB | 4 vCPU / 8 GB / 100 GB SSD | Varios contenedores de negocio |
| 2–5 GB | 6–8 vCPU / 16 GB / 200 GB NVMe | Control estricto de consultas/etiquetas |
Para 1 GB/día y 30 días, reserve al menos 60–100 GB entre datos, índices, compactación, logs Docker y espacio temporal de copia. El almacenamiento filesystem no borra por falta de disco: configure retención y alertas juntas.
El tráfico local Alloy/Loki/Grafana queda en Docker. Consultas grandes del navegador, copias remotas y agentes de otros hosts generan tráfico externo. La ingesta remota exige HTTPS, autenticación y cálculo de volumen y cargos de salida.
Docker stdout/stderr pasa por Alloy a Loki y Grafana lo presenta mediante Caddy. El ejemplo publica Loki 3100 y Grafana 3000 solo en loopback del host. El diagrama original es:
Docker 容器 stdout/stderr
|
v
Grafana Alloy --> Loki :3100(仅 Docker 内网)
|
v
Grafana :3000(仅 127.0.0.1)
|
v
Caddy HTTPS :443
Loki no incluye autenticación. Mantenga su API privada; Caddy proporciona TLS público únicamente para Grafana.
Apunte un dominio como logs.example.com al 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"
El original ejecuta el instalador de conveniencia Docker. En producción, inspecciónelo o utilice el repositorio apt oficial. Instale openssl y ufw si faltan. Vuelva a conectar SSH tras modificar grupos. El grupo Docker otorga capacidades administrativas del host: reserve su uso a operadores de confianza. Verifique acceso por claves antes de desactivar contraseñas SSH.
Permita SSH, HTTP y HTTPS:
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status
No abra 3000/3100. La asociación Grafana a 127.0.0.1 añade otra restricción. Verifique las publicaciones reales y reglas UFW/nube.
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 la contraseña en un gestor y cree .env:
umask 077
printf 'GRAFANA_ADMIN_USER=admin\nGRAFANA_ADMIN_PASSWORD=替换为刚才生成的密码\n' > .env
Sustituya el marcador de contraseña del comando original por el valor generado antes de usarlo. No deje el marcador como contraseña ni confirme el archivo en Git.
chmod 600 .env
ls -l .env
Cree /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
Se utiliza TSDB, schema v13 e índice de 24 horas. retention_period: 720h indica 30 días, pero también hace falta compactor.retention_enabled: true. Mantenga el directorio Compactor persistente para conservar marcadores pendientes.
Con menos disco, elija 336h para 14 días antes de empezar a ingerir. La documentación indica que los cambios no son retroactivos para logs ya ingeridos. Reducir el valor no libera inmediatamente datos históricos. Amplíe disco o utilice eliminación documentada; no borre chunks/índices activos manualmente.
Cree /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 es el servicio interno Compose. localhost:3100 apuntaría al propio contenedor Grafana.
Cree /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"
}
}
Conserva container, service_name, compose_project, host y job. Evite IDs de solicitud/usuario, URL completas y marcas de tiempo como etiquetas: producen alta cardinalidad.
Alloy accede a /var/run/docker.sock. Montarlo con :ro no hace que la API Docker sea de solo lectura; sus clientes tienen gran poder sobre el host. Use imágenes confiables fijadas, proteja configuración y ejecute cargas de confianza.
Cree /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:
Los límites logging rotan los logs Docker de la propia pila. Sin ellos, el disco raíz puede llenarse aunque Loki tenga retención. Consulte la guía Compose de producción.
Las comprobaciones originales son:
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, sin admitir el --check del original. El formato comprueba sintaxis/formato, sin validar componentes; ejecute también 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
La imagen Loki fijada es distroless, sin wget, shell ni du. El healthcheck original falla y bloquea las dependencias service_healthy. Antes del arranque, cree este compose.override.yaml, cargado automáticamente, y compruebe preparación mediante HTTP desde el 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
Un contenedor iniciado no demuestra salud. Mantenga monitorización de readiness desde el host. Después de corregir, los comandos originales de inspección son útiles:
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 debe devolver ready; Grafana debe indicar base ok. Espere la inicialización antes de declarar fallo.
Edite /etc/caddy/Caddyfile con el dominio real, coincidente con 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 y recargue:
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
curl -I https://logs.example.com/login
Caddy obtiene y renueva certificados. Consulte la guía Caddy HTTPS para diagnosticar el proxy.
Tras entrar, cree otro administrador y compruébelo antes de deshabilitar o renombrar admin. Para varios usuarios, prefiera proveedor de identidad con MFA a compartir contraseña.
El test temporal original es:
docker run --rm alpine:3.22 sh -c \
'echo "loki-smoke-test level=info"; echo "sample failure level=error" >&2'
Termina y se elimina antes de que discovery, actualizado cada 5 segundos, pueda verlo. Mantenga el contenedor vivo durante el descubrimiento:
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 o Explore, elija Loki y consulte:
{job="docker"} |= "loki-smoke-test"
Más 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])
))
Reduzca rango temporal y etiquetas estables antes de filtrar con |= o |~. Evite buscar mediante regex en todos los contenedores durante 30 días habitualmente.
Las etiquetas útiles tienen pocos valores estables:
- Host.
- Entorno, como production/staging.
- Proyecto Compose.
- Servicio.
- Contenedor.
IP, pedidos, usuarios, solicitudes, URL completas e IDs de tareas aleatorios deben quedar en el texto y analizarse al consultar. Si crecen los streams, revise etiquetas dinámicas Docker y relabeling Alloy. Cada etiqueta propuesta debe tener valores limitados y estables.
Las alertas gestionadas por Grafana pueden evaluar Loki, por ejemplo:
sum by (service_name) (
count_over_time({job="docker"} |~ "(?i)error|exception|panic" [5m])
) > 20
Cuenta líneas coincidentes en cinco minutos; no es un porcentaje de errores. Defina cinco minutos de pending para evitar picos breves de despliegue. Configure contact points y políticas reales para correo, Slack, Telegram o webhook.
Observe una semana y establezca umbrales por servicio en lugar de alertar con cualquier “error”. Combine logs con CPU, RAM, disco y disponibilidad de la guía Prometheus/Grafana.
Alerte también sobre:
- Disco raíz/Docker por encima de 80%.
- Reinicios Loki o fallo de
/ready. - Logs descartados, escrituras fallidas o reconexión continua de Alloy.
- No registre contraseñas, cookies, Authorization, API keys ni pagos completos.
- Oculte datos en la aplicación primero; filtros regex del agente son complementarios.
- Mantenga Loki 3100 y depuración Alloy privados.
- Limite administradores; lectores normales utilizan Viewer.
- Revise permisos del proxy de fuentes y plugins.
- Cifre backups antes de enviarlos fuera del host.
auth_enabled: false solo corresponde a esta red cerrada de un host. Para otros VPS, añada proxy TLS autenticado o gateway con autorización por tenant. No publique 3100.
Pause la pila y archive tres volúmenes y configuración. El original propone /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
Hay que corregir sus nombres de contenedor asumidos y permisos de creación demasiado amplios. Use este script como root para los volúmenes documentados. Obtiene montajes de IDs reales, protege credenciales y prepara reinicio antes de detener:
#!/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 y pruebe:
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
El original asumía proyecto loki-stack. docker compose ps y docker inspect permiten inspeccionar nombres reales. La sustitución evita nombres generados e incluye el override automático. Acepte solo archivo con COMPLETE y checksums verificados; la monitorización confirma que el reinicio funcionó.
Durante la pausa, Docker puede rotar logs aún no leídos y causar pérdida de ingesta. Si necesita continuidad, elija objetos y copias coherentes probadas, sin ejecutar tar sobre archivos activos. Consulte el ensayo de copia/restauración para protección externa.
En un VPS temporal aislado:
- Instale Docker/Caddy compatibles y las mismas versiones de aplicaciones inicialmente.
- Verifique SHA-256.
- Extraiga datos/configuración de forma privada.
- Cree tres volúmenes nuevos y restaure sus datos.
- Revise volúmenes y dominio de prueba en
compose.yamly su override. - Inicie Loki, Grafana y Alloy.
- Consulte un log conocido anterior a la copia.
- Compruebe fuentes, alertas y usuarios.
El ejemplo original de extracción es:
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 el archivo real, sin copiar la fecha histórica. Verifique consultas anteriores, login, alertas e ingesta nueva; arrancar contenedores no prueba restauración.
Ejemplo de parche/versión 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
Lea notas, copie y cambie una etiqueta. Verifique acceso, fuentes, consultas y alertas antes de avanzar.
Si se migra la base Grafana o el formato Loki, volver solo a la imagen puede ser inseguro. Restaure el snapshot previo correspondiente. El orden es copia, pull, actualización individual, salud, consulta real y observación.
docker compose exec grafana \
wget -qO- http://loki:3100/ready
docker compose logs --tail=200 loki grafana
Use http://loki:3100, no localhost, en la fuente.
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}}'
Revise montaje socket, configuración cargada y posible ruta Docker no estándar.
docker system df
docker compose exec loki du -sh /loki/*
docker compose logs --tail=300 loki | grep -iE 'compactor|retention|delete|error'
El du original no existe en esta imagen distroless. Inspeccione el volumen con contenedor de herramientas de solo lectura o monitorización del host. Revise retention_enabled, índice 24 horas y directorio Compactor persistente. La eliminación tiene retraso y cambios de retención no son retroactivos: no espere 95% de disco.
Acorte el periodo y añada service_name, compose_project o host. Revise cardinalidad. No haga búsquedas regex de 30 días en todos los servicios como operación habitual de un 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
Si 3000 local está sano, revise dominio, certificado y destino del proxy.
- DNS y 80/443 públicos funcionan.
- 3000/3100 privados.
- Versiones de Loki, Grafana y Alloy fijadas.
- Validación Compose efectiva, Loki y Alloy correcta.
- Contraseña administrativa cambiada y anónimo deshabilitado.
- LogQL encuentra la entrada de prueba.
- Etiquetas sin IDs dinámicos de usuario/solicitud.
- Retención y alertas de disco activas.
- Alertas llegan a un canal real.
- Copias incluyen los tres volúmenes y configuración.
- Restauración aislada completada.
- Actualizaciones individuales.
4 GB es un inicio práctico con logs Docker moderados, sin ser mínimo obligatorio. Periodo, concurrencia, volumen y etiquetas cambian la demanda. 2 GB permite experimentos, pero no es recomendable para servicios importantes y búsquedas largas juntos.
No en todas las cargas. Loki filtra etiquetas y recorre texto con menor costo de indexación. Búsqueda completa, agregación compleja y seguridad pueden encajar mejor con Elasticsearch/OpenSearch. Elija según consultas.
Compactor elimina de forma asíncrona y los cambios oficiales no son retroactivos. Revise índice TSDB de 24 horas, almacenamiento persistente de marcadores y errores. Reserve margen de disco sin depender de limpieza instantánea.
Sí, mediante gateway/proxy TLS autenticado, restricciones de origen y cálculo de tráfico. Multi-tenant necesita control de cabeceras de tenant y autorización. Mantenga 3100 privado.
Prefiera Alloy para instalaciones nuevas. Combina descubrimiento, relabeling, logs, métricas y trazas. Compare etapas Promtail con la documentación de migración antes de cambiar.
Este archivo filesystem requiere pausa para coherencia. Servicio continuo necesita objetos/versionado compatibles o snapshots probados, con procedimiento propio de consistencia y recuperación.