Your team needs monitoring, and three names keep coming up in every discussion: Grafana vs Zabbix vs Prometheus. Search results and vendor comparisons often treat them as direct alternatives, but that framing is wrong. Prometheus is a time-series database that scrapes and stores metrics. Grafana is a visualization layer that queries data sources and renders dashboards. Zabbix is a complete monitoring platform with its own agents, server, database, and frontend. Comparing Grafana to Prometheus is like comparing a web browser to a database: they work together, not against each other.
This comparison focuses on what each tool actually does, how you deploy it, and what it costs in CPU, RAM, and engineer time. You'll see real architecture differences, agent requirements, and decision criteria based on infrastructure size and team capacity. By the end you'll know whether you need Prometheus with Grafana, Zabbix alone, or a hybrid stack.
What Each Tool Actually Does
Prometheus: Pull-Based Metrics and Time-Series Storage
Prometheus scrapes HTTP endpoints every 15 or 30 seconds, stores the metrics in a local time-series database, and lets you query them with PromQL. It runs as a single binary with a config file listing scrape targets. The Prometheus data model uses labels for dimensions: http_requests_total{method="GET",status="200"}. You get basic alerting through Alertmanager, which groups, deduplicates, and routes alerts to Slack, PagerDuty, or email.
Prometheus does not do dashboards. It has a built-in expression browser for ad-hoc queries, but you pair it with Grafana for actual visualization. The open-source version has no clustering or high availability; you run multiple Prometheus servers and federate them, or add Thanos, Cortex, or Mimir for long-term storage and global queries. Prometheus also does not push metrics to you: exporters expose /metrics endpoints, and Prometheus pulls them. For short-lived batch jobs, you push to a Pushgateway that Prometheus then scrapes.
Grafana: Visualization Layer for Any Data Source
Grafana queries data sources and builds dashboards. It connects to Prometheus, InfluxDB, MySQL, PostgreSQL, Elasticsearch, Loki, Tempo, and dozens more through plugins. You configure data sources in the UI or provision them with YAML files, then build panels with queries specific to each backend. Grafana does not collect or store metrics: it is a stateless frontend that issues queries when you load a dashboard.
Grafana Cloud adds hosted Prometheus (Mimir), Loki for logs, and Tempo for traces, plus Grafana Agent for unified collection. The open-source version runs as a single binary or container, stores dashboard JSON in SQLite or PostgreSQL, and supports OAuth, LDAP, and SAML. Teams often run Prometheus for metrics and Grafana for dashboards, which is why "Grafana vs Prometheus" comparisons are wrong: they work together.
Zabbix: All-in-One Monitoring Platform
Zabbix is a complete monitoring system: agents collect data, the server processes it, a database stores it, and a PHP frontend displays it. You install Zabbix agents on hosts, configure items (metrics) and triggers (alert conditions) through templates, and the server polls agents or receives active checks. Zabbix handles metrics, logs, SNMP traps, IPMI sensors, JMX beans, and synthetic checks in one platform. Alerting, escalation, auto-discovery, inventory, and maps are built in.
Zabbix uses a relational database (MySQL, PostgreSQL, Oracle) for everything: configuration, history, trends. The server is written in C and runs as a daemon. For large deployments you add proxies between agents and the server to offload network traffic and database writes. Zabbix does not integrate with external dashboards like Grafana: it is a closed system with its own screens, graphs, and triggers.
Architecture and Deployment Model
Prometheus: Scrape Targets and Service Discovery
Prometheus reads prometheus.yml with a list of scrape targets or service discovery configs for Kubernetes, Consul, EC2, or DNS. Each job defines targets, scrape interval, and relabeling rules. Here's a minimal config:
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'node'
static_configs:
- targets: ['192.168.1.10:9100', '192.168.1.11:9100']
Run prometheus --config.file=prometheus.yml and it starts scraping. Data stays local in ./data for 15 days by default. For high availability, run two Prometheus servers scraping the same targets. For long-term storage, configure remote write to Thanos, Cortex, or Mimir. Federation pulls aggregated metrics from other Prometheus servers with a scrape config targeting /federate endpoints. Prometheus has no built-in clustering in the open-source release.
Grafana: Stateless Dashboard Server
Grafana runs as a single binary or container. It needs a database for dashboard storage and user sessions: SQLite by default, PostgreSQL or MySQL for production. You configure data sources in the UI or provision them with /etc/grafana/provisioning/datasources/ YAML files. A Prometheus data source looks like:
apiVersion: 1
datasources:
- name: Prometheus
type: prometheus
url: http://localhost:9090
isDefault: true
Start Grafana with grafana-server or docker run -p 3000:3000 grafana/grafana. Default credentials are admin/admin. Grafana is stateless: all dashboards, alerts, and config live in the database. You can run multiple Grafana instances behind a load balancer sharing the same database. For detailed setup steps, see our Prometheus + Grafana monitoring stack guide.
Zabbix: Server, Database, Proxy, Agent Hierarchy
Zabbix needs four components: the server (C daemon), a database (MySQL or PostgreSQL), the frontend (PHP/Nginx or Apache), and agents on monitored hosts. A docker-compose stack looks like:
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: rootpass
MYSQL_DATABASE: zabbix
zabbix-server:
image: zabbix/zabbix-server-mysql:latest
environment:
DB_SERVER_HOST: mysql
MYSQL_USER: root
MYSQL_PASSWORD: rootpass
zabbix-web:
image: zabbix/zabbix-web-nginx-mysql:latest
ports:
- "80:8080"
environment:
DB_SERVER_HOST: mysql
ZBX_SERVER_HOST: zabbix-server
The server writes every metric to the database. For 10,000 items at 60-second intervals, expect 15-20 GB per month in history tables. Proxies sit between agents and the server in distributed setups: agents send to the proxy, which batches data to the server. Zabbix's architecture is heavier than Prometheus. You need a relational database, PHP runtime, and more RAM for the server process. Budget 2-4 GB RAM for a server monitoring 500 hosts.
Data Collection and Agent Requirements
Prometheus Exporters and the /metrics Convention
Prometheus collects nothing on its own: it scrapes exporters. An exporter is a small HTTP server exposing a /metrics endpoint in Prometheus text format. node_exporter runs on Linux hosts and exposes CPU, memory, disk, network stats at http://host:9100/metrics. Install it with:
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz
./node_exporter &
Add the host to Prometheus scrape config and you're done. Other exporters handle MySQL (mysqld_exporter), PostgreSQL (postgres_exporter), Nginx (nginx-prometheus-exporter), and more. For services that don't expose /metrics, write a custom exporter or use the Pushgateway: your batch job pushes metrics to http://pushgateway:9091/metrics/job/backup, and Prometheus scrapes the gateway.
Zabbix Agents and Active vs Passive Checks
Zabbix agents run as daemons on monitored hosts. Install zabbix-agent2 (the newer Go-based version) or zabbix-agent (C), edit /etc/zabbix/zabbix_agent2.conf to set Server= and ServerActive=, then start the service. Passive checks: the server connects to the agent on port 10050 and requests metrics. Active checks: the agent connects to the server, asks which items to collect, and pushes results.
Each metric is an "item" configured on the server with a key like system.cpu.load[percpu,avg1]. Templates bundle items for common services (Linux, Apache, MySQL). You link a template to a host, and Zabbix starts collecting those items. Agents support user parameters for custom scripts. Zabbix also does agentless monitoring: SNMP polling, ICMP ping, JMX over RMI, IPMI sensor reads, and simple TCP/HTTP checks without installing anything on the target.
Comparing Installation Effort
Prometheus exporters are single binaries with no config file required: run node_exporter and it works. Zabbix agents need a config file pointing to the server, and you must configure items and triggers on the server side. Adding a new metric in Prometheus means exposing it in an exporter; in Zabbix you create an item, set the key, choose value type, and update interval through the web UI or API. Prometheus is faster for ephemeral workloads (Kubernetes pods); Zabbix is easier for static infrastructure where you want templates and auto-discovery rules. For more on Linux monitoring fundamentals, see our Linux System Monitoring and Performance guide.
Query Language and Data Analysis
PromQL: Powerful and Steep
Prometheus uses PromQL, a functional query language built for time-series math. You select metrics by name and filter by labels, then apply functions. To get per-second CPU rate over 5 minutes:
rate(node_cpu_seconds_total{mode="idle"}[5m])
The [5m] is a range vector: PromQL calculates rate across that window. For the 95th percentile of HTTP request durations from a histogram:
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
PromQL is expressive: you can aggregate across labels (sum by (instance)), join metrics, predict trends with predict_linear, and build complex expressions. The learning curve is real. Engineers coming from SQL or Zabbix expressions need a week to get comfortable. The PromQL documentation is your reference, but expect to test queries in the expression browser and iterate.
Grafana: Query Editors Per Data Source
Grafana provides a query builder for each backend. For Prometheus, you write PromQL in a text box or use the visual builder to select metrics and apply functions. Grafana adds transformations: rename fields, calculate differences between series, filter by value, or merge queries. Variables let you template dashboards: $instance in a query becomes a dropdown of available instances. You can query multiple data sources in one dashboard: Prometheus for metrics, Loki for logs, PostgreSQL for application state.
Grafana does not invent a query language. If your data source is MySQL, you write SQL. If it's Elasticsearch, you write Lucene or JSON queries. This flexibility means Grafana works for infrastructure monitoring, application metrics, business analytics, and IoT data, but you need to know each backend's syntax.
Zabbix: Web UI Filters and Calculated Items
Zabbix queries are simpler. In the web UI you filter items by host, application, or tag, then graph them. For calculated metrics, you create a calculated item with an expression. To average CPU load across all cores:
avg(/host/system.cpu.load[all],5m)
Trigger expressions use functions like last(), avg(), nodata(). To alert when CPU is over 80% for 5 minutes:
avg(/host/system.cpu.util,5m) > 80
Zabbix expressions are readable but less flexible than PromQL. You cannot join metrics from different hosts in a single expression, and advanced aggregations require calculated items or preprocessing steps. For most infrastructure monitoring (disk full, service down, high load) Zabbix's built-in functions work fine. For percentile calculations, rate-of-change analysis, or multi-dimensional aggregation, PromQL wins.
Alerting and Notification Workflows
Prometheus Alertmanager: Rules and Routing
Prometheus alerting rules live in YAML files loaded by the server. An alert for high CPU looks like:
groups:
- name: cpu
rules:
- alert: HighCPU
expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
for: 5m
labels:
severity: warning
annotations:
summary: "High CPU on {{ $labels.instance }}"
The for: 5m waits 5 minutes before firing: no flapping alerts. Prometheus evaluates rules every 15-60 seconds and sends active alerts to Alertmanager. Alertmanager groups alerts by label (all severity=warning from cluster A), deduplicates, silences based on regex, and routes to receivers. A routing config might send critical alerts to PagerDuty and warnings to Slack. Alertmanager also handles inhibitions: if the data center is down, suppress host alerts.
Configuration is file-driven. You edit YAML, reload Prometheus and Alertmanager, test with amtool. This suits GitOps workflows but adds friction for ad-hoc alert changes. Alertmanager has a web UI for silences and alert status, not for creating rules.
Grafana Alerting: Unified Alerts Across Data Sources
Grafana's unified alerting (introduced in v8) lets you alert on any data source: Prometheus, Loki, MySQL, CloudWatch. You define alert rules in the UI with a query, a condition, and a notification policy. A disk space alert queries Prometheus:
100 - ((node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100) > 90
Set the condition to fire when the query returns true for 5 minutes. Notification policies route alerts to contact points (Slack, email, webhook) based on labels and matchers. Grafana stores alert state in its database (SQLite, PostgreSQL, MySQL), so restarting Grafana doesn't lose pending alerts.
Grafana alerting is hybrid: you can configure rules in the UI or provision them with YAML. For teams already using Grafana dashboards, adding alerts is a small step. For teams running Alertmanager, Grafana can forward alerts to it or replace it entirely. The trade-off: Grafana alerting is newer and less mature than Alertmanager's grouping and routing logic.
Zabbix Triggers and Actions: Template-Driven Alerts
Zabbix alerts start with triggers. A trigger is an expression that evaluates to true or false. To alert when a host is unreachable:
last(/host/agent.ping) = 0
Triggers have severity levels (Not classified, Information, Warning, Average, High, Disaster). When a trigger fires, Zabbix creates a problem. Actions define what happens next: send an email, post to Slack, run a remote command. You configure actions with conditions (if severity >= High and host group = Production) and operations (send to user group Ops, wait 15 minutes, then send to Managers).
Escalations are built in: step 1 notifies the on-call engineer, step 2 notifies the manager if unacknowledged after 30 minutes. Zabbix also supports event correlation: if trigger A fires, suppress trigger B. Templates bundle triggers and actions for services. Link the Linux template to a host and you get CPU, memory, disk, and network alerts automatically. Everything is UI-driven, which is faster for small teams and slower for version-controlled infrastructure.
Comparing the three: Zabbix is easiest for traditional ops teams (point, click, done). Prometheus Alertmanager is most powerful for complex routing and GitOps. Grafana sits in the middle, offering UI and YAML options with the bonus of querying any data source.
Scalability and Resource Footprint
Prometheus: Single-Server Limits and Federation
A single Prometheus server handles millions of time series if you tune storage.tsdb.retention.time (default 15 days) and allocate enough RAM. Rule of thumb: 1-2 bytes per sample on disk, 3-4 bytes in memory during queries. For 100 hosts with 500 metrics each at 15-second scrape intervals, expect 2-4 GB RAM and 10-20 GB disk per month. Prometheus compresses old blocks but keeps recent data in memory for fast queries.
When one server is not enough, you federate: run multiple Prometheus servers scraping different targets, then a global Prometheus scrapes /federate endpoints from the shards to pull aggregated metrics. For long-term storage, configure remote write to Thanos (adds S3 backend and global query), Mimir (Grafana's scalable backend), or Cortex. These systems let you query years of data across clusters. Open-source Prometheus has no built-in HA: you run two servers scraping the same targets and accept that they will not have identical data at every moment.
Grafana: Horizontal Scaling and Database Load
Grafana is stateless. Run multiple instances behind a load balancer, point them at the same PostgreSQL database, and you're done. Each instance handles dashboard rendering and query execution. Grafana does not cache query results by default, so every dashboard load hits the data source. For 100 concurrent users, expect 200-500 MB RAM per Grafana instance and negligible CPU unless you're rendering complex dashboards.
The bottleneck is the database. Dashboard JSON, alert state, and user sessions live there. PostgreSQL handles thousands of dashboards fine; SQLite works for single-server setups but doesn't support multiple Grafana instances. For large deployments, enable dashboard provisioning from Git and reduce database writes.
Zabbix: Database Growth and Proxy Offloading
Zabbix scales vertically with the database. A single Zabbix server handles 10,000-50,000 NVPS (new values per second) depending on CPU, database tuning, and housekeeper settings. For 100 hosts with 200 items each at 60-second intervals, you're looking at 333 NVPS. The server needs 1-2 GB RAM, and the database grows 1-2 GB per month for history and trends. Partition the history tables by month and configure the housekeeper to delete old data:
HousekeepingFrequency=1
MaxHousekeeperDelete=10000
For larger setups, add Zabbix proxies between agents and the server. Proxies collect data locally and batch it to the server, reducing network traffic and database load. A proxy can handle 5,000-10,000 hosts. Frontend caching (Nginx reverse proxy, PHP opcache) speeds up the web UI. Zabbix also supports database partitioning and read replicas for reporting queries.
Ballpark memory for 100 hosts: Prometheus 2-4 GB, Grafana 200 MB, Zabbix server 1 GB plus 2-4 GB for MySQL or PostgreSQL. Prometheus is memory-hungry but fast. Zabbix is disk-hungry and needs database tuning. Grafana is lightweight but leans on the data source for heavy lifting. For scaling guidance in containerized environments, see our Kubernetes for Production: Scaling & Monitoring guide.
Use Case Decision Matrix
Infrastructure Size and Team Capacity
| Infrastructure | Team Profile | Recommended Stack | Setup Time |
|---|---|---|---|
| <50 hosts, mostly Linux | Small team, limited time | Prometheus + Grafana | 4-8 hours |
| 50-500 mixed (Linux, Windows, network gear) | Prefers UI over YAML | Zabbix | 16-24 hours |
| Kubernetes, microservices, cloud-native | Comfortable with PromQL and GitOps | Prometheus + Grafana | 8-16 hours |
| >500 hosts, legacy + modern | Need SNMP, IPMI, JMX monitoring | Zabbix with proxies | 40+ hours |
| Multi-cloud, ephemeral workloads | Engineers write code, prefer automation | Prometheus + Thanos + Grafana | 24-40 hours |
Pick Prometheus with Grafana when your infrastructure is cloud-native, you run Kubernetes or containerized workloads, and your team writes YAML and understands label-based querying. Prometheus works well in dynamic environments where hosts come and go: service discovery keeps scrape configs up to date, and exporters integrate with modern stacks (Envoy, NGINX Ingress, Kafka). The scrape model fits ephemeral pods better than agents that need installation and configuration.
When Zabbix Makes Sense
Choose Zabbix when you manage mixed infrastructure (physical servers, Windows hosts, network switches, storage arrays) and your team prefers configuring through a web UI. Zabbix's built-in support for SNMP, IPMI, WMI, and JMX means you do not need separate exporters for every device type. Templates give you 500+ pre-configured items for common services: link the MySQL template to a host, and you get queries per second, slow queries, replication lag, and buffer pool usage without writing a single expression.
Zabbix also wins when you need integrated alerting, escalation, and reporting in one platform. No need to run Alertmanager, configure routing, or set up Grafana alerts: triggers, actions, and dashboards live in Zabbix. For teams without Kubernetes experience or time to learn PromQL, Zabbix's learning curve is gentler. The trade-off: heavier resource usage, slower iteration on config changes, and less flexibility for custom metrics.
Hybrid Stacks and Managed Options
You can run Zabbix and add Grafana on top using the Zabbix data source plugin. This gives you Zabbix's agent management and templates with Grafana's superior dashboards and cross-data-source queries. Point Grafana at the Zabbix API, query items by host and key, and build panels. Teams doing this typically keep Zabbix for alerting and use Grafana for executive dashboards and correlation with logs or application metrics.
For managed services, Grafana Cloud bundles hosted Prometheus (Mimir), Loki, Tempo, and Grafana with generous free tiers: 10,000 series and 50 GB logs per month. Zabbix Cloud offers hosted Zabbix server and frontend; you install agents on your infrastructure and they report to the cloud. Managed options cut setup time to hours but lock you into a vendor. For production infrastructure, weigh the operational savings against the cost: Grafana Cloud runs $50-$500/month for typical workloads, Zabbix Cloud pricing scales with host count.
Real Deployment Example
Prometheus and Grafana with Docker Compose
Here's a minimal stack with Prometheus, node_exporter, and Grafana. Create docker-compose.yml:
version: '3.8'
services:
prometheus:
image: prom/prometheus:latest
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
command:
- '--config.file=/etc/prometheus/prometheus.yml'
- '--storage.tsdb.retention.time=30d'
node-exporter:
image: prom/node-exporter:latest
ports:
- "9100:9100"
grafana:
image: grafana/grafana:latest
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- ./grafana/provisioning:/etc/grafana/provisioning
Create prometheus.yml:
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'node'
static_configs:
- targets: ['node-exporter:9100']
Provision the Prometheus data source in grafana/provisioning/datasources/prometheus.yml:
apiVersion: 1
datasources:
- name: Prometheus
type: prometheus
url: http://prometheus:9090
isDefault: true
Run docker-compose up -d. Prometheus scrapes node_exporter at http://localhost:9090/targets, Grafana runs at http://localhost:3000. Import dashboard 1860 (Node Exporter Full) from Grafana's dashboard library, and you see CPU, memory, disk, network graphs instantly. Total time: 15-20 minutes including downloading images.
Zabbix Server and Agent Setup
Deploy Zabbix with docker-compose.yml:
version: '3.8'
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: zabbix
MYSQL_DATABASE: zabbix
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix
zabbix-server:
image: zabbix/zabbix-server-mysql:latest
environment:
DB_SERVER_HOST: mysql
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix
depends_on:
- mysql
zabbix-web:
image: zabbix/zabbix-web-nginx-mysql:latest
ports:
- "80:8080"
environment:
DB_SERVER_HOST: mysql
ZBX_SERVER_HOST: zabbix-server
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix
depends_on:
- zabbix-server
On monitored hosts, install zabbix-agent2. Edit /etc/zabbix/zabbix_agent2.conf:
Server=zabbix-server-ip
ServerActive=zabbix-server-ip
Hostname=webserver01
Start with systemctl start zabbix-agent2. In the Zabbix web UI at http://localhost (default credentials Admin/zabbix), go to Configuration โ Hosts โ Create host, set the hostname, add the agent interface on port 10050, and link the "Linux by Zabbix agent" template. Zabbix discovers items, starts collecting, and you see CPU, memory, disk graphs in Monitoring โ Latest data. Setup time: 45-60 minutes including database initialization and template configuration.
Common Pitfalls and Configuration Notes
Prometheus scrape interval versus retention: setting scrape_interval: 5s with retention.time: 90d generates 9x more data than 15-second scrapes. For 100 hosts that's 50-100 GB instead of 10-20 GB. Start with 15 or 30 seconds unless you need sub-minute resolution for specific jobs. Zabbix agent mode matters: passive checks (server polls agent) work through firewalls if you open port 10050 inbound. Active checks (agent pushes to server) need port 10051 outbound from the agent. For NAT or cloud environments, use active checks.
Grafana anonymous access is convenient for testing (GF_AUTH_ANONYMOUS_ENABLED=true) but a security hole in production. Disable it and configure OAuth or LDAP. Dashboard provisioning from JSON files in /etc/grafana/provisioning/dashboards/ makes dashboards version-controlled but read-only in the UI: users cannot save changes. Use provisioning for standard dashboards and let users create personal ones in the database. Zabbix templates export as XML; version-control them and import via the UI or API for repeatable deployments. For a complete walkthrough of Prometheus and Grafana deployment, see our monitoring stack setup guide.
Choosing Your Monitoring Stack: A Practical Checklist
Start with your infrastructure type. If you run Kubernetes, microservices, or cloud-native workloads, Prometheus with Grafana is the standard: service discovery, label-based queries, and exporters integrate well. For mixed environments with legacy servers, network gear, and Windows hosts, Zabbix's agent-based approach and SNMP support cover more ground with less custom integration work.
Evaluate your team's skills and preferences. Engineers comfortable with YAML, Git, and PromQL will move faster with Prometheus. Teams that prefer UI-driven configuration and want alerting, reporting, and dashboards in one platform will find Zabbix easier to adopt. Consider setup and maintenance time: Prometheus reaches first graph in 30 minutes but needs separate components (Alertmanager, Grafana, long-term storage). Zabbix takes longer to configure initially but bundles everything.
Test both stacks in a lab environment. Deploy the docker-compose examples above, add real hosts, build a dashboard, and trigger an alert. Measure the time you spend on setup, the resources each stack consumes, and whether the query language or UI feels natural to your team. For a deeper look at monitoring fundamentals and stack design, see our IT Infrastructure Management guide. The right choice depends on your infrastructure, team, and tolerance for complexity, not on which tool is objectively superior.
Frequently Asked Questions
Can I use Grafana with Zabbix?
Yes, install the Zabbix data source plugin in Grafana and point it at your Zabbix API. You can query items by host and key, build dashboards, and combine Zabbix metrics with other data sources like Prometheus or Loki. Teams often keep Zabbix for agent management and alerting while using Grafana for better dashboards and cross-platform correlation.
Is Prometheus better than Zabbix for Kubernetes monitoring?
Prometheus is purpose-built for Kubernetes. It uses service discovery to find pods automatically, scrapes metrics from the kubelet and cAdvisor, and integrates with kube-state-metrics for cluster state. Zabbix can monitor Kubernetes through custom scripts or the Docker integration, but it lacks native service discovery and label-based querying. For Kubernetes, use Prometheus.
Does Grafana replace Prometheus?
No, Grafana is a visualization layer that queries data sources. Prometheus collects and stores metrics. You run both: Prometheus scrapes exporters and stores time-series data, Grafana connects to Prometheus and renders dashboards. Grafana can query other backends (MySQL, InfluxDB, Loki), but it doesn't collect metrics itself. They're complementary tools.
How much memory does Prometheus need for 100 servers?
For 100 servers with 500 metrics each at 15-second intervals, budget 2-4 GB RAM and 10-20 GB disk per month with 15-day retention. Memory usage scales with active series and query complexity. Increase storage.tsdb.retention.time to 30 or 90 days and you'll need more disk but similar RAM for recent blocks. Tune --storage.tsdb.max-block-duration if queries slow down.
Can Zabbix monitor Docker containers like Prometheus?
Zabbix can monitor Docker through the Docker API or by installing agents in containers. You get container CPU, memory, and network stats, but not the per-process detail Prometheus cAdvisor provides. Zabbix also lacks native service discovery for ephemeral containers. For static Docker hosts, Zabbix works. For dynamic orchestrated environments, Prometheus is better suited.