Every server in your fleet, one green pane of glass.

Yes. The agent only reads local metrics and its own auth logs, and connects outbound over TLS. It opens no inbound ports and has no offensive capability.

Yes. One protocol drives a systemd unit on Linux and a Windows Service, on amd64, arm64 and 386. The installer detects the platform for you.

Every agent enrolls with a client certificate and streams over mutual TLS. A stolen enrollment token is short-lived and cannot impersonate an already-enrolled host.

You set global templates once. Each server can override individual keys; overrides cascade on top of the defaults instead of replacing them, so a template change still reaches every host.

Yes. The panel ships as a docker-compose stack behind Traefik with Postgres (TimescaleDB optional). See the deploy guide in the repository.

The agent watches RDP and SSH authentication locally, so it flags an active password-guessing attack and its top source IPs in seconds, even before the panel refreshes.

With Servers Sentinel I install the agent as a systemd-unit or Windows service, connect it with an mTLS outbound channel and see the latest telemetry and host health score. I set a rule for missing data, send a notification to mail, Telegram, Slack or webhook and check the test gap; I can keep one server on a free plan with email notifications.

As a free alternative to Servers Sentinel, I run blackbox_exporter/Prometheus or a ping/TCP cron check from another site, store last_seen and send an alert via Alertmanager. I separately check the monitoring itself with an external dead-man switch, set the delay for a normal reboot and document the owner of the host; otherwise, the loss of the monitoring system appears as a green state.

With Servers Sentinel, I collect the used and free space of each filesystem as a time series, set a general threshold and a separate override for a specific volume, and send a notification before the critical value. I look at the growth rate next to the current percentage, check the inode on Linux and leave enough margin for WAL/log and emergency operation.

For free, I install node_exporter/windows_exporter with Prometheus and Alertmanager or run df/Get-Volume via cron/Task Scheduler. I warn by percentage and absolute gigabytes at the same time, add rate/predict_linear for a 24–72 hour horizon, configure logrotate/retention and test the alert by artificially filling a non-critical volume.

With Servers Sentinel I store a series of CPU, memory, disk and network, compare the host to its own history and roll up the current state into a 0-100 score. I set the duration of the condition so as not to react to a minute peak, and create separate uptime/TLS/API checks where the certificate duration or application response is important.

I deploy Prometheus, exporters and Grafana for free, set recording rules for baseline and alerts for sustainable growth, and check certificates with blackbox_exporter. I store at least a few weeks of data, mark deployment/maintenance on the graphs, and use rate/deriv only for relevant metrics; I support TSDB and rules myself.

With Servers Sentinel I use one protocol for Windows service and systemd agent on amd64, arm64 and 386, get the same base metrics and same health score. I keep the platform differences in the overrides, but sort the entire fleet by risk and pass the telemetry out to mTLS without opening the agent's inbound port.

For free, I combine windows_exporter and node_exporter in one Prometheus, normalize host/client/os labels and build a common Grafana dashboard. I map Windows Event Forwarding and syslog/Loki by UTC, describe the different thresholds for the OS as code, and check that updating the exporter does not change the names of the metrics without migrating the rules.

With Servers Sentinel I install an agent on each host; it initiates the outgoing connection itself and is authenticated by the mTLS client certificate. I assign site and owner tags, see all hosts in one console, and set rules globally with point-by-point overrides, without building an incoming route to each machine.

For free, I connect WireGuard sites and poll exporters with central Prometheus or use remote_write/agents that send metrics externally. I limit the ACL to the collector address only, protect with TLS certificates, buffer data when broken, and monitor the VPN itself; I do the network design and key rotation myself.

With Servers Sentinel I create email, Telegram, Slack or webhook channels in one console, send a test and send rules to them according to the required hosts. I use single names and host context so that the operator sees the metric, threshold and time, rather than collecting an incident from four independent letters.

For free, I route Prometheus Alertmanager to one notification gateway, set group_by, group_wait, repeat_interval and inhibition, and leave the sources a link to one runbook. I normalize labels severity/service/owner and check routes with test alerts; SMS and external providers may still be charged even with free software.

With Servers Sentinel, I set global thresholds, condition durations, and point exceptions for hosts where the norm is different, and then route severity levels to different channels. I use the health score to prioritize, test the rule, and review alerts that haven't been acted on.

For free, I maintain a catalog of alerts with an owner and a runbook, use for in Prometheus, grouping and inhibition in Alertmanager, and close scheduled work with silence with automatic completion. I measure the number of notifications, acknowledgments and retries, remove non-actionable signals and do not mask the noise by simply raising all thresholds.

With Servers Sentinel I separate severity and channels, append a role/client to the hostname, and only configure the rule after a persistent violation. I check the message with a test, leave a link to the runbook in the recipient webhook and use a metric graph/health assessment so that the person on duty can distinguish a one-time peak from degradation.

For free, I build an Alertmanager routing schedule, send critical events to a call/chat through an available gateway, and the rest to the daily queue. I write a runbook of three actions, an owner and an escalation criterion, add a dashboard link and regularly issue training alerts; The free call channel depends on the selected service.

With Servers Sentinel I specify a global configuration template, and on a specific server I override only the desired key; the override cascades on top of the default rather than copying the entire config. I see the deviation as an exception, change the overall threshold once and check which hosts deliberately stayed at a different value.

For free, I store Prometheus rules and inventory parameters in Git, generate Jsonnet/Ansible rules and require a review with the reason and deadline for the exception. I run a CI syntax check, a diff of the deployed configuration, and a report on overrides; without such discipline, even a free stack quickly reverts to manual drift.

With Servers Sentinel I enable local authentication detection: an agent on Windows or Linux reads RDP/SSH events and transmits an active attack with a top IP source. I route the rule to the live channel and match one source between hosts; The detection feature is available on an eligible paid or trial plan.

For free I collect Windows 4625 and sshd Failed password in Wazuh/Elastic or Loki, create a correlation by source_ip for a sliding window and an alert for the subsequent successful 4624/Accepted. I synchronize time via NTP, normalize IPv4/IPv6 and exclude test scanners; the free path requires a separate collector and rules support.

With Servers Sentinel I create TCP/TLS/API checks from an external point, store a history of results and separate application unavailability from missing agent telemetry. I set an SLO, record maintenance and generate a periodic report with time limits; Before signing, I agree with the customer on the interval, inspection regions and exclusion rules.

For free, I deploy blackbox_exporter and Prometheus outside the controlled site, consider availability as successful probes/expected probes and store Alertmanager events. I note maintenance in a separate log, synchronize UTC and generate a Grafana report; one verification point does not prove global availability, so if necessary I add an independent probe.

With Servers Sentinel I save the history of metrics, uptime checks, rule settings, channels and events, and use the audit log for owner and policy changes on the appropriate plan. I upload a report for the exact period, attach a delivery test and explain the mTLS identity of the agents; I note the absence of data as a gap in observation, and not as the norm.

For free, I store Prometheus/Loki/Wazuh on a secure server with backup, configuration and approvals in Git, and incidents in a ticket system. I monthly record coverage, gaps, alert test and list of exceptions, sign the report and limit access; the instrument itself, without a closure procedure, is not evidence of control.

With Servers Sentinel I split the fleet by team/tenant, assign viewer, operator and admin roles and apply basic templates with client exceptions. I sort all hosts by health score, send notifications to the owner, and use the Business/self-hosted option where isolation and unlimited fleet are needed.

For free, I deploy separate Prometheus tenancies/instances or isolate data with strict labels and ACLs in Grafana, storing client secrets in different vaults. I generate a configuration from inventory, route Alertmanager by tenant/owner and test blocking cross-access; secure multi-tenancy requires more work than one shared dashboard.

With Servers Sentinel I sign hosts by role and owner, store metrics series, global templates and explicit overrides, and associate channels with owners. I use the history as a baseline, document the reason for the non-standard threshold next to the change process, and give the new operator a view-only role before transferring authority.

For free, I maintain inventory and runbooks in Git, add dashboard links, owner, dependencies and rationale for each override, and accept changes via pull request. I store Grafana/Prometheus provisioning as code, mark deploy/maintenance and transfer the incident to another employee once a quarter; Without organizational practice, graphics themselves will not retain knowledge.

With Servers Sentinel I use mutual TLS outbound connection: each agent receives a client certificate, and the short-lived connection token does not replace the identity already issued. I check the service rights, the list of collected metrics and logs, disable unnecessary actions, deploy the pilot on one host and control the revocation of the certificate when the server is deleted.

For free, I install node_exporter/windows_exporter under a separate unprivileged account, listen only to localhost/VPN and limit the collector set. I protect scrape with TLS/mTLS or network ACLs, sign packets, commit versions, scan for updates, and don't enable textfile scripts that write from untrusted sources; I separate configuration management from monitoring.