Cloud-Native Metrics: Using the Provider's Own Monitoring
Here is a pleasant surprise hiding inside your cloud account: the provider has been monitoring your resources since the moment you created them. Every instance already has traffic graphs. Every load balancer already counts its healthy targets and times its requests. Every VPN tunnel already reports whether it is up. Nobody asked you to install anything, and the gauges are just sitting there — a whole wall of meters you did not have to build.
There are two catches, and this guide is about both. The first is that the wall of meters lives in the provider's console. Consoles are where attention goes to die: one more browser tab, one more login, one more place alerts can fire without you noticing. The second is that the provider measures from its side of the fence. Its metrics are trustworthy about the fabric and completely blind about your users, your office DNS, and the path between your building and the cloud.
By the end of this guide you will know what the provider measures for you. You will know how to pull those numbers into the monitoring view you already watch and what the gauges cannot see. You will see how your on-prem monitoring habits translate — check by check — into this new world.
In this guide
- What the provider measures for you
- What free-ish actually means
- The console trap
- Pulling provider metrics into one view
- What provider metrics cannot see
- Granularity and gaps, honestly
- On-prem habits, translated
- Where to go next
What the provider measures for you
Every major provider runs a metrics service that automatically collects numbers about the resources in your account. The names differ; the substance is remarkably consistent. Four families matter most to a network-minded admin.
Per-instance network counters
For each instance, the provider measures bytes and packets in and out of its network interfaces. These are measured at the hypervisor — the layer beneath the operating system. Because the count happens outside the OS, it works even when the instance is wedged. The count cannot be fooled by anything happening inside the guest. Many providers also expose counters for traffic they refused to carry because the instance exceeded its allowed bandwidth or connection limits. Those throttling counters are gold. They are the difference between "the network is slow" and "this instance is too small for its job," which are very different tickets.
Load balancer health and latency
A managed load balancer reports the count of healthy versus unhealthy targets behind it and how long backends take to answer. It reports how many requests it is handling and how many responses were errors. The healthy-target count deserves a permanent place on your dashboard. It is a piece of monitoring the provider runs for you, actively probing your servers the way your own monitoring would. When healthy targets drop from three to one, users have not noticed anything yet. That is the good kind of alert, the one that arrives before the outage finishes assembling itself.
Tunnel and interconnect state
For a VPN connection or a dedicated circuit back to your building, the provider reports tunnel state (up or down as it sees it). It reports traffic through the connection and often counters that hint at trouble on the path. This is one half of the hybrid picture — the far end's opinion of the link your building depends on. The near end and the middle are your problem, which is why monitoring the hybrid path gets its own guide in this pillar.
Gateway throughput
NAT gateways and the other doors of your VPC report bytes processed, active connections, and errors such as failed port allocations under load. Watching gateway throughput is also an early-warning system for cost. A NAT gateway's byte count climbing means the metered outbound door is busier. It is far cheaper to notice that on a graph mid-month than on the invoice later. The full story lives in the egress guide.
Events and status, not just numbers
Alongside the metrics, providers publish two streams that are easy to overlook. The first is per-resource events: an instance was rebooted for host maintenance, a gateway was migrated, a certificate on a managed endpoint is approaching expiry. The second is the provider's own health feed — the machine-readable cousin of the public status page, scoped to the services and regions you actually use. Both answer the question that eats the first twenty minutes of many cloud incidents: "is it us, or is it them?" Getting those events into the same place as your alerts means the answer is waiting for you instead of being a rumor on social media.
What free-ish actually means
Provider monitoring follows a consistent cost pattern, and knowing the pattern (rather than any specific rate, which varies and changes) keeps you out of trouble. The basic tier is included: standard metrics, collected at a coarse default interval — typically a few minutes between data points — with modest retention. That is the free-ish part, and for many resources it is genuinely enough.
The meter starts running when you want more. That includes finer-grained data points, longer retention, custom metrics you publish yourself, dashboards, and alarm rules. And it includes — the one that surprises people — reading the metrics out through the API at volume. Each call is cheap; a monitoring system polling hundreds of metrics every minute makes a lot of calls, forever. None of this is a reason to avoid the metrics service. It is a reason to choose polling intervals deliberately and poll the metrics you act on rather than everything with a name. Treat "let's collect it all just in case" — a habit that is free on-prem — as a thing that now has a price tag.
A practical way to hold the line: tier your polling. A handful of state metrics that gate user access — tunnel up, healthy targets, gateway errors — deserve the tightest interval you are willing to pay for. Trend metrics like instance traffic are perfectly served by relaxed intervals, because you read them in graphs, not in the middle of the night. Everything else can wait until a question actually needs it. The pattern scales in your favor: costs concentrate where minutes matter, and the long tail stays nearly free.
The console trap
The provider's console is genuinely good at what it is for: deep inspection of one resource, right now, with full context. The trap is letting it become one of your monitoring homes. Attention is the scarcest resource an admin has. Every separate place that can page you — or worse, can silently display a problem and not page you — divides it. You already have a monitoring view for the building. Add a cloud console, and on a bad day you are alt-tabbing between two systems trying to correlate timestamps by eye. Add a second cloud account or a second provider, and the arithmetic gets worse.
The failure mode is predictable. Alerts configured in the console go to a mailbox nobody reads because they are formatted differently and arrive from an unfamiliar sender. Dashboards in the console are checked enthusiastically for two weeks and then never again. And during an incident, the one person with console credentials becomes a human API for everyone else. Meanwhile the on-prem monitoring system — the one with your escalation rules, your on-call schedule, and your muscle memory — knows nothing about the cloud half of the infrastructure.
There is also a quieter cost: context-switching. Every console has its own graph style, its own time-range picker, its own idea of what "last hour" means and which time zone it is in. Correlating a latency wobble on an on-prem graph with a gateway blip on a console graph means holding two mental rulers at once. Off-by-one-time-zone errors have sent more than one investigation confidently down the wrong road.
The industry sells the cure as a "single pane of glass." Honest version: there is no single pane, and vendors who promise one are selling window cleaner. But fewer panes is achievable, valuable, and mostly a matter of plumbing — which is the next section. Aim for one place where alerts land and one place where the first five minutes of any investigation happen. Keep the provider console for what it is good at: the deep dive after your own monitoring told you where to dig.
Pulling provider metrics into one view
Every provider exposes its metrics service through an API (application programming interface). This is a way for software, including your monitoring system, to ask questions over HTTPS. The shape is the same everywhere. Authenticate with a read-only credential and list the available metrics for a resource. Then fetch data points for a metric over a time range at some resolution. Generically, the conversation looks like this:
GET metrics/list?resource=lb-front
-> healthy-targets, request-latency, request-count, error-count ...
GET metrics/data?resource=lb-front&metric=healthy-targets&period=5m
-> [ time=..., value=3 ] [ time=..., value=3 ] [ time=..., value=2 ]
Your monitoring system polls that API on a schedule and stores the answers next to its on-prem data. It applies the same thresholds and alert rules it applies to everything else. Whether that happens through a built-in integration, a plugin, or a small script you schedule yourself matters less than the result. That result is cloud numbers arriving in the place you already watch. A sensible rollout:
- 1. Shortlist the metrics that map to user pain. Tunnel state, load balancer healthy targets and latency, instance bytes in/out on the workhorses, NAT gateway throughput, and any throttling counters. Ten to twenty metrics cover most of what you will ever act on.
- 2. Create a read-only credential for monitoring. The polling account needs permission to read metrics and nothing else. Least privilege applies to robots too.
- 3. Pick intervals that respect the cost pattern. Five-minute polling is plenty for trend metrics; save tighter intervals for the few state metrics where minutes matter, like tunnel status.
- 4. Alert in one place. Point everything at your existing alert rules, escalation chains, and quiet hours. A cloud alert should look, route, and escalate exactly like an on-prem one.
- 5. Name and map as you go. Give each polled cloud resource a host entry in your monitoring with the same naming discipline as everything else. Wire up dependencies: the cloud app depends on the tunnel, and the tunnel depends on your edge firewall. When the hybrid path drops, one alert about the path beats forty alerts about everything behind it.
- 6. Keep the console for surgery. When your own system says the load balancer is unhappy, then open the provider's console for the deep inspection it is genuinely good at.
Tip: when you graph a provider metric next to your own measurement of the same thing, expect small disagreements. The provider counts at the hypervisor; your agent counts inside the OS; your ping measures the whole path between you and the resource. Each is honestly reporting a different vantage point. Disagreement between vantage points is not an error — it is information, and sometimes it is the diagnosis.
What provider metrics cannot see
The provider's gauges stop at the provider's fence. Inside the fence they are excellent witnesses. Outside it, they know nothing at all — and outside the fence is where your users live.
Provider metrics cannot see your user's experience. A load balancer reporting comfortable backend latency is measuring from itself to your servers. It is not measuring the office broadband, the overloaded VPN concentrator, or the laptop on hotel Wi-Fi. Provider metrics cannot see DNS from the office. If your internal resolver returns something stale or slow for a cloud name, every provider graph stays green while every user is dead in the water. And provider metrics cannot see the path between your building and the cloud, the segment where so much "the cloud is slow" pain actually lives.
The corrective is the synthetic check: a small test that behaves like a user — resolve the name, connect to the port, fetch the page. The test runs continuously from outside the provider's fence, ideally from where your users actually sit. Synthetic checks are the truth serum for cloud monitoring, because they measure the only vantage point that decides whether anyone opens a ticket. The guide on ping-up versus service-up covers why answering a ping was never the same thing as working. When a synthetic check from the office fails while the provider's metrics look healthy, you have not found a contradiction. In that case, you have found the location of the problem: somewhere between your users and the fence.
Granularity and gaps, honestly
A few limitations to internalize before you trust the gauges with your weekends. Default granularity is coarse. A data point every few minutes is an average, and averages flatten spikes. A ten-second burst that saturated an instance's bandwidth disappears inside a calm-looking five-minute mean. Finer granularity usually exists behind the cost meter, but even then, short microbursts slip between data points. When a user swears something froze and every graph looks serene, believe the user and suspect the averaging.
Metrics arrive late. Data points are published minutes after the moment they describe, which makes provider metrics better rear-view mirrors than windshields. The vantage point is the hypervisor. The provider sees the wire, not the socket. TCP retransmissions, connection queues, and which process is hogging the interface are invisible from outside the OS. That is why an agent on the instance — the same agent you run on any server — still earns its place. Managed services expose only the gauges the provider chose. There is no SNMP walk of their equipment, no supplementary OID to discover, no debug command. If the metric you want does not exist, your options are an agent, a synthetic check, or flow logs. The menu is fixed; order accordingly.
Finally, resources come and go, and their metrics go with them. On-prem, a server is a long-term relationship; its graphs stretch back as far as your retention. In the cloud, instances are replaced during scaling and rebuilds, and each replacement starts a fresh metric history under a new resource identity. If your capacity questions are really about a service — "how much traffic does the web tier move?" — make sure something aggregates across the members. Otherwise you will find yourself holding six short, disconnected graphs where one long story should be. A stopped instance simply stops producing data points. A gap in a graph is ambiguous by itself. It means "nothing was measured," which is not the same as "nothing was wrong." Pair provider metrics with an explicit reachability check for anything whose absence should wake someone.
On-prem habits, translated
If you already run a monitoring practice on-prem, you do not need a new philosophy — you need a phrasebook. Here is the translation table:
| On-prem habit | Cloud-native equivalent | What changes |
|---|---|---|
| SNMP interface counters on switches | Per-instance network metrics from the provider | Per-server view instead of per-port; no switch to poll |
| Ping every server | Provider status checks plus your own synthetic ping | Keep pinging — from where users sit, not just inside the VPC |
| Watch firewall deny logs | Flow log REJECT records | Denies are silent until flow logs make them visible |
| NetFlow at the core router | Flow logs per interface, subnet, or VPC | Summaries arrive minutes later; verdict included |
| WAN circuit graphs at the edge router | Tunnel and interconnect metrics from both ends | You only own one end of the path now |
| WMI or agent on every server | The same agent on every instance | Nothing changes — instances are just servers |
| UPS, temperature, and power monitoring | Nothing — the provider owns the physical layer | One less pager subject; read their status page instead |
| Watching the backup server's throughput | Gateway and egress metrics | Data leaving the cloud is metered; watch the doors |
The pattern in the right-hand column: everything you used to measure still gets measured, but the measuring points moved to whoever owns the layer. The provider measures its fabric; you measure your instances from inside and the user experience from outside. Monitoring did not shrink — it redistributed.
Where to go next
Provider metrics are a genuine gift: hypervisor-grade truth about instances, gateways, tunnels, and load balancers, collected before you asked. Treat them as one vantage point among three. Those are the provider watching its fabric, your agents watching the inside of instances, and synthetic checks watching from where users sit. Pull all three into one view so your attention stays whole. The rest of the Cloud Network Monitoring pillar fills in the flanks. It covers the VPC mental model if the nouns are still settling, flow logs for traffic truth, and egress for the money. It covers the hybrid path for the road between your building and all of it.
Put this into practice with SysPeep Monitor
Fewer panes of glass is a plumbing project, and the on-prem pane is the natural place to consolidate. SysPeep Monitor gives you that home base: auto-discovered devices, SNMP and WMI health checks, dashboards and alert rules in one web console. Your cloud instances can report in over SSH or an agent like any other server on the list. The free trial installs on any Windows machine.
Download Free TrialLearn About SysPeep