Zabbix: The All-in-One Platform
I once inherited a network watched by four tools and a spreadsheet. One did servers, one did switches, one drew graphs, one sent alerts, and the spreadsheet remembered which watched what. The all-in-one platform is the family that refuses to pick one job, and its best-known open-source member is Zabbix.
The design idea is simple to state. Collect everything — from agents on servers, from SNMP on network gear, from agentless probes for the rest — and put every value in one relational database. Then build alerting, graphing, dashboards, and maps on top of that single store. One install, one vocabulary, one place to look.
This tour explains that design. It covers how a value travels from a device to your inbox through items, triggers, and actions. It covers how templates save you defining the same thing a hundred times. It covers how discovery rules find what to monitor and how to care for the database that holds it together. It closes with strengths, learning curve, fit, and what to check in the current docs before you commit.
In this guide
- The design: everything into one database
- Items, triggers, actions: how a number becomes an email
- Templates: the reusable bundle
- Discovery rules: letting the platform find what to monitor
- History, trends, and housekeeping: caring for the database
- Proxies: monitoring remote sites and spreading the load
- Strengths, learning curve, and where it fits
- The concepts in one table
- What to check in the current docs before committing
- Where to go next
The design: everything into one database
Picture the platform as four pieces around a hub. The hub is a relational database — the ordinary kind of database, with tables and rows, that you might already know from a web application. It holds the configuration (what to monitor and how), the collected history (every value that came in), and the long-term summaries. The database backend choices guide covers what kind of database a monitoring tool should sit on; here the answer is "one relational database, and treat it well."
Around the hub sit four pieces. The server is the brain: it decides what to collect, when, and from whom; it evaluates the alert conditions; and it runs the actions. The collectors are how values reach the server. There are three kinds:
- Agents are small programs you install on servers and workstations. An agent can answer questions the server asks it (a passive style), or gather values on its own schedule and send them in (an active style). Agents are how you get CPU, memory, disk, processes, log files, and anything a local script can read.
- SNMP is how the server talks to switches, routers, firewalls, printers, and UPS units, none of which can run an agent. The server polls them directly, and can receive their traps.
- Agentless methods cover everything else. That includes ping, TCP port checks, HTTP requests against a web page, SSH commands, database queries, and calls to web APIs. APIs are application programming interfaces — the way programs talk to other programs. No software is installed on the target.
The third piece is the web frontend, a single web application for everything. It handles adding hosts, editing alert conditions, looking at graphs, building dashboards and maps, and working the problem list. Unlike the check-based family, there is no separate text-configuration layer you must hand-edit; the frontend writes configuration into the same database the server reads. The fourth piece is the proxy, an optional collector for remote sites, which gets its own section below.
Items, triggers, actions: how a number becomes an email
The vocabulary is the first hill on the learning curve, so climb it with one example: a core switch whose CPU gets too busy. It is simple once you understand it, like every hill.
An item is one thing to collect from one host on a schedule. It has a key (which value to fetch), a type (agent, SNMP, and so on), and an interval. It also has rules for how long to keep the raw values and the summaries. "CPU utilization on sw-core-01, over SNMP, every sixty seconds" is an item. Items are the atom: every collected value is a row of history tied to its item.
A trigger is an expression over item values that defines a problem. It is not attached to a single reading. It looks at the recent history of one or more items and says whether the situation is bad. "The last five minutes of CPU utilization on sw-core-01 have all been above ninety percent" is a trigger. Triggers have severities, and a trigger can define a separate recovery expression so that a problem does not flap on and off at the threshold boundary.
An action is what happens when a trigger fires. It has conditions (which triggers, which hosts or groups, which severities). It also has operations: send a message to these users through these media, and run this script. And if nobody acknowledges within a set time, escalate to these other users. Actions are also where recovery messages are configured.
Here is the chain as a sketch. The syntax is illustrative — the real expression language has its own forms, described in the current documentation — but the shape is exactly this:
# ITEM: what to collect host: sw-core-01 key: cpu.utilization (SNMP, vendor CPU OID) interval: 60s history: keep raw values for two weeks trends: keep hourly min/avg/max for a year # TRIGGER: when is it a problem? name: High CPU on sw-core-01 expr: min(cpu.utilization, last 5m) > 90 recovery: max(cpu.utilization, last 5m) < 80 severity: High # ACTION: what to do about it if: severity >= High AND host group = "Core network" step 1: email the network team immediately step 2: after 30 minutes unacknowledged, also message the on-call lead recovery: email the network team "resolved"
The trigger uses five minutes of history, not one reading. That is the platform's answer to the same blip problem the check-based family solves with soft and hard states. The recovery condition is lower than the problem condition. That gap keeps a CPU hovering at ninety from generating a problem, a recovery, a problem, and a recovery every minute. (Your inbox has opinions about that.) The threshold tuning guides go into why that gap matters in any tool.
Templates: the reusable bundle
Fifty items per host times a hundred hosts is five thousand items. Nobody defines those by hand. A template is a bundle of items, triggers, graphs, and discovery rules that describes a kind of thing. That could be "a generic SNMP switch," "a Linux server with an agent," or "a web server." You link a template to a host and the host inherits everything in it. Change the template and every linked host changes with it.
Templates make the platform's breadth manageable. A new switch arrives. You add a host, give it an address and SNMP credentials, and link the switch template. Within a few polling intervals the host has interface items, CPU and memory items, triggers for link-down and high utilization, and graphs. None of those were written by you. Templates for many device types ship with the platform or are shared by the community; you can write your own for anything unusual.
Two related ideas make templates flexible. Host groups collect hosts that belong together ("Core network," "Branch offices," "Web tier") and are what actions and permissions are usually aimed at. And user-defined variables are named placeholders you can set at the template level and override per host. They let one template carry a default threshold that a particular host can adjust without breaking the link to the template. That last idea is how you avoid the classic trap of copying a template just to change one number.
Tip: when you start, resist editing the shipped templates directly. Clone them, or layer your own template on top, so that you can update the shipped one later without losing your changes. Ten minutes of discipline here saves a very unpleasant upgrade weekend.
Discovery rules: letting the platform find what to monitor
Templates answer "what should a switch have?" but they cannot know how many ports this switch has, or which filesystems this server mounts. That is the job of discovery, which the platform does at two levels.
Network discovery works at the level of hosts. You give it an address range and a set of checks (does it answer ping? SNMP? an agent?), and it finds devices you have not added yet. It also finds devices nobody admits to owning. An action can then create the host automatically, put it in a group, and link a template based on what responded. How discovery sweeps and classifies devices in general is explained in the auto-discovery guide; this is the platform's implementation of that idea.
Low-level discovery works inside a host. A discovery rule in a template asks the host to enumerate something — its network interfaces, its filesystems, its CPUs, or the entries in an SNMP table. The rule carries prototypes: item, trigger, and graph definitions with a placeholder for the name of each discovered thing. For every interface the switch reports, the platform stamps out real items, triggers, and graphs from the prototypes. Ports come and go, and the discovered items follow them, with a grace period before anything that disappears is removed.
Together, the two levels make "add a switch" a short sequence:
- 1. Network discovery notices a new address answering SNMP, or you add the host by hand.
- 2. An action or you link the switch template and put the host in a group.
- 3. Low-level discovery in the template enumerates the interfaces.
- 4. Prototypes create per-port items for status and traffic, per-port triggers for link-down, and per-port graphs.
- 5. The server begins polling; triggers begin evaluating; actions are ready to fire.
History, trends, and housekeeping: caring for the database
Now the honest part. Because every value lands in one relational database, the database is the thing that grows, slows, and eventually demands attention. The platform gives you the tools; you have to use them. This is the section the weekend install skips.
Every item stores two kinds of data. History is the raw values, one row per collection. Trends are hourly summaries — for each hour, the minimum, average, and maximum — which are tiny compared with history and are what long-range graphs are drawn from. Each item has its own retention period for both. A sensible pattern is short history (enough to troubleshoot last week's incident in detail) and long trends (enough to compare this quarter with last year's at a glance). The housekeeper is the background process that deletes history and trends past their retention periods.
Sizing the database is a method, not a lookup table:
- 1. Count values per second. For each template, add up its items divided by their intervals; multiply by the number of hosts using it; sum across templates. A hundred hosts with fifty items each at one-minute intervals is a much smaller number than it sounds, but discovered per-port items on big switches add up fast.
- 2. Multiply by bytes per value. The project's documentation gives an approximate storage footprint per history row and per trend row for each value type. Use its current figures, not a number from a forum post.
- 3. Multiply by retention. History rows times history days, plus trend rows times trend days. That is your steady-state size, reached once the housekeeper is deleting as fast as collection is inserting.
- 4. Add headroom for indexes and growth, then check that the database server's storage is fast enough to insert at your values-per-second rate while also answering frontend queries.
Two more operational habits. First, the housekeeper deletes rows one batch at a time, which on a very large history table becomes its own load. Many installations switch to partitioning the history tables by time so that old data is dropped a whole partition at once. The project documents how. Second, watch the platform's own internal queue and performance items — it monitors itself. A growing queue of unprocessed values is the earliest sign that the database has fallen behind. The monitoring the monitor guides make the general case for that habit.
At Harbourview Clinic the switch template went onto forty access switches one afternoon, and nobody redid the values-per-second sum. The frontend slowed first, then the housekeeper fell behind, then the platform's own queue graph climbed for a week before anyone opened it. The incident note described the database as "under some pressure".
Proxies: monitoring remote sites and spreading the load
A single server polling everything works well for one building. It works less well for a branch office across a slow link, a segment behind a strict firewall, or an estate so large that one server's polling capacity runs out. The platform's answer is the proxy: a lightweight collector you place near the devices. It gathers values on the server's behalf — agents, SNMP, and agentless checks alike. It buffers them locally if the link to the server drops, and forwards them in batches when it can.
A proxy needs its own small database for buffering but no frontend. Configuration still lives centrally, and the server pushes each proxy the part of the configuration that belongs to it. Proxies can be set up so that the proxy initiates the connection to the server (useful through firewalls that allow outbound only) or the server initiates to the proxy. Beyond remote sites, proxies are also the standard way to spread polling load. Several proxies each handle a slice of the estate, and the central server concentrates on evaluating triggers and serving the frontend. The pattern is the same remote-collector idea described in the probes and collectors guide.
Strengths, learning curve, and where it fits
Strengths
Breadth in one install is the headline. Servers, network devices, applications, virtual machines, cloud services, and log files are all monitored by one server. Their data is stored in one database and shown in one frontend. Templating is the second. The combination of templates, low-level discovery, and prototypes means that once you have described a kind of thing well, every instance of it is monitored consistently. And mature alerting is the third: triggers over history rather than single readings, recovery expressions, severities, escalation steps, and acknowledgement are all built in and well worn.
Learning curve
The effort goes into vocabulary and database care. There are items, keys, value types, preprocessing, triggers, expressions, actions, operations, and media types. There are templates, macros, host groups, discovery rules, and prototypes. The concepts are individually simple, but there are many of them and they connect in specific ways. So the first weeks feel like learning a language. Expect to read the concept chapters of the documentation twice. Then expect to become, at least a little, a database administrator. Retention, housekeeping, partitioning, and storage performance are your responsibility. The platform will slow down rather than warn you if you ignore them. I learned this afterwards, which is the usual way.
Where it fits
The platform fits teams who want one system for servers and network alike, who would rather learn one large vocabulary than run three tools with three small ones. It fits environments with many similar things, where templating pays for itself immediately, and organizations that can give the database proper storage and ongoing attention. It is a weaker fit for a team that only cares about network gear and wants graphs for every port with almost no setup. The network-first tools get there faster. The platform is also a weaker fit for teams whose world is containers and short-lived cloud instances, where the metrics-first stack is more at home.
The concepts in one table
| Concept | Plain-language meaning | Where it lives |
|---|---|---|
| Server | The central brain that schedules collection, evaluates triggers, and runs actions | One central machine (with high-availability options) |
| Agent | A small program on a server that answers questions or sends values | Installed on each monitored server |
| Proxy | A collector that gathers on the server's behalf and forwards in batches | Near remote or firewalled devices |
| Host | A thing to monitor: server, switch, service endpoint | Configured in the frontend, stored in the database |
| Item | One value to collect from one host on a schedule | Usually inherited from a template |
| Trigger | An expression over item history that defines a problem and its recovery | Usually inherited from a template |
| Action | Conditions plus operations: who to tell, how, and when to escalate | Configured globally, aimed at groups and severities |
| Template | A reusable bundle of items, triggers, graphs, and discovery rules | Linked to hosts; shipped, shared, or your own |
| Host group | A named set of hosts for actions, permissions, and dashboards | Configured in the frontend |
| Discovery rule and prototypes | Enumerate what a host has and stamp out items, triggers, and graphs per thing found | Inside templates |
| History and trends | Raw values versus hourly min/avg/max summaries | Database tables, per-item retention |
| Housekeeper | Background deletion of data past retention | A server process; often replaced by partitioning at scale |
What to check in the current docs before committing
The details below are exactly the kind that change. Open the current documentation and confirm each before you build on it:
- Which databases are supported, which one the project recommends for new installations, and what its own sizing and performance guidance says.
- The high-availability story for the server itself: what fails over, what does not, and what the frontend does during a failover.
- How agents are secured — encryption between agents, proxies, and the server, and how credentials are managed.
- The current expression language for triggers and how preprocessing (transforming a value before storing it) works, because the sketch above is illustrative only.
- Which templates ship with the platform for your specific devices and applications, and how the community shares additional ones.
- How dashboards and maps are built and whether your team will use them directly or prefer an external dashboard tool; see the dashboards guides for that decision.
- Upgrade procedure and compatibility between server, proxies, agents, and database schema, which must be kept in step.
Where to go next
One idea, carried through: every value is an item, every item lives in one database, and everything else is built on those rows. The reward is breadth: servers and switches watched with the same vocabulary, and the spreadsheet retired. The catch is the vocabulary itself, and a database that must be sized by method and cared for on purpose. Neither demand is unreasonable, but both are real.
To see how the other families answer the same questions, continue the Guided Tour of the Open-Source Monitoring Stacks. The check-based family reaches anything you can script. The network-first tools graph every port with almost no setup, and the metrics-first stack trades finished features for flexibility. Whichever you choose, the scaling monitoring guides help when the sizing method above starts producing large numbers.
Put this into practice with SysPeep Monitor
One console for servers and network gear is a fair thing to want, and the all-in-one idea is not exclusive to open source. SysPeep Monitor is a Windows-based option built on the same premise. It offers auto-discovery and collection over SNMP, WMI, and SSH. It offers thresholds and dependencies to keep alerts quiet, and dashboards and maps in one web console, with a choice of database backends. If an all-in-one design appeals but you would like to compare a packaged alternative, the free trial is an easy way to do that.
Download Free TrialLearn About SysPeep