Home › Topics › Streaming Telemetry › The Acronym Stack

gNMI, gRPC, and YANG: The Acronym Stack Decoded


The first time you read about streaming telemetry, you run into a sentence like this: "the collector subscribes via gNMI, transported over gRPC, to paths defined by YANG models." Three acronyms deep, and nobody has paused to say what any of them actually does. It reads like a job posting for a programmer. That is exactly why plenty of capable admins close the tab and go back to SNMP. There, at least the jargon is familiar jargon.


Here is the secret: the three acronyms are not three separate technologies to master. They are three layers of one clean stack, and each layer does one job you already understand from everyday life. One is a phone line. One is a grammar — a small set of verbs. One is a dictionary. Stack them up and you get a complete replacement for the machinery SNMP has provided for decades. You get a way to name device facts, ask for them, and move the answers.


This guide decodes the stack for a non-programmer. You will learn what each layer is in plain words, why it exists, and what an admin actually does with it. Then we will follow one real telemetry message all the way through the stack. We will finish with a translation table that maps every piece to the SNMP concept you already know. No code required, no prior telemetry knowledge assumed.


In this guide

  • One stack, three jobs
  • Bottom layer — gRPC: the phone line
  • Middle layer — gNMI: the grammar
  • Top layer — YANG: the dictionary
  • One message, end to end
  • The SNMP-to-telemetry phrasebook
  • Certificates: the new keys to the kingdom
  • One line per layer

One stack, three jobs


Any system where two machines exchange structured information has to solve three problems, and it pays to keep them separate. First: how do the bytes physically travel, reliably and privately? Second: what may the two sides say to each other — what requests exist, and what do responses look like? Third: what are the things being discussed actually called, and what type of thing is each one? Telephone line, grammar, dictionary. SNMP solves all three too, in its own way (UDP packets, get and set and trap operations, MIB files). The streaming stack just solves each one with a modern, deliberately chosen tool. It gives each tool its own name.


Keeping the jobs separate is not academic tidiness; it is what makes the stack durable. Because the dictionary does not care how bytes travel, the same YANG models are used by other management protocols too. You may meet the names NETCONF and RESTCONF — older siblings that speak to the same models over different transports. Because the grammar is standard, a collector from one maker can subscribe to a device from another. Learn each layer once and the knowledge keeps paying, even as individual tools come and go.


Diagram of the streaming telemetry stack drawn as a three-layer cake: YANG on top as the dictionary of named, typed data paths; gNMI in the middle as the grammar of four verbs, capabilities, get, set, and subscribe; gRPC at the bottom as the encrypted always-on transport over HTTP/2 with TLS. A single telemetry update message is shown descending from the device through the layers and arriving at the collector as path, timestamp, and value.

Figure 1: The stack. YANG names the data, gNMI provides the verbs, gRPC carries the bytes. Every telemetry update touches all three layers on its way from device to collector.


Read the cake bottom-up when you are learning it, and top-down when you are using it. To receive telemetry, you pick names from the dictionary (YANG) and use a verb from the grammar (gNMI subscribe). The sentence travels down the phone line (gRPC). Let’s take the layers one at a time, starting at the bottom.


Bottom layer — gRPC: the phone line


gRPC is a modern remote procedure call framework. "Remote procedure call" (RPC) is programmer-speak for a simple idea. One machine asks another machine to run a specific, named operation and hand back the result. It is like calling a function that happens to live elsewhere. The name gRPC, delightfully, is half-recursive; ask three engineers what the g stands for and you will get three answers. What matters is what it gives you: an efficient, secure, always-on phone line between collector and device.


Under the hood it runs over HTTP/2 — the same modern web protocol your browser uses. That is wrapped in TLS, the standard encryption layer behind every padlock icon. Messages travel in a compact binary format rather than human-readable text, which keeps them small and cheap to process. You never touch any of this directly; you just benefit from it.


Compare that to SNMP’s transport, and the upgrade is easy to state. SNMP sends individual UDP datagrams: fire the packet and hope. It has encryption only if v3 is configured. Its unsolicited messages (traps) are never acknowledged. The gRPC phone line gives you three things UDP never promised. Acknowledgment: it rides on TCP, so every update is delivered, confirmed, and retransmitted if lost. The stream survives exactly the flaky moments when monitoring matters most. Encryption: TLS is the default posture, not an optional add-on. Multiplexing: many independent conversations share one connection at the same time, without opening a new session for each. Think several subscriptions, a config read, a health check. One call, many conversations, line always open.


"Always on" carries one operational duty worth naming now: somebody has to notice when the line drops. A polling system rediscovers a device on the next cycle automatically. A streaming collector must detect the dead connection, redial, and resubscribe. Good collectors do this for you, but it is a behavior to verify, not assume. The blunt test belongs in every deployment: unplug something in the lab and watch whether the stream heals itself.


Middle layer — gNMI: the grammar


A phone line is useless without an agreed way of speaking. gNMI — the gRPC Network Management Interface — is that agreement. It is a small, standard set of verbs that any compliant collector can use with any compliant device, regardless of vendor. The whole grammar is four verbs. That is the entire vocabulary, and each one maps to something you already do:


  • Capabilities — "what do you speak?" The device answers with the data models it supports and the encodings it understands. This is first contact: the move you make against an unfamiliar device to learn what it can be asked. It is like flipping to a book’s table of contents.
  • Get — "read me these values, once." A one-shot fetch of named paths: the spot check. What is this interface’s current state? What serial number is in that chassis? The everyday screwdriver.
  • Set — "change these values." Write configuration through the same interface. Set a description, shut an interface, adjust a setting — with the whole change accepted or rejected as one unit. So a half-applied change does not leave the device in limbo.
  • Subscribe — "from now on, send me these values — on this schedule, or when they change." The star of the telemetry show: one request, then a continuous stream of updates for as long as the connection lives.

Subscribe is the verb this whole topic exists for. The push model, sample-based and on-change subscriptions, and what they are each good at are covered in the push-versus-pull guide. But pause on the quiet significance of Set. SNMP technically had a write operation too. In practice most shops disabled it and configured devices by typing into terminals. gNMI’s Set is different: it writes the same named, structured data that Get reads and Subscribe streams. One stack, one naming scheme, for both watching and changing the device. That symmetry is why the same skills that get you telemetry today are the entry ramp to network automation tomorrow. The industry calls the whole idea model-driven management.


One honest aside so the landscape does not surprise you later: gNMI is the most common grammar for streaming telemetry. But it is not the only management interface modern devices offer. Many also speak NETCONF or REST-style APIs, and some vendors add their own streaming dialects on top. The four-verb model you just learned is the portable core. Whatever interface a given platform favors, you will recognize the same read, write, and subscribe ideas wearing different uniforms.


Top layer — YANG: the dictionary


Verbs need nouns. When Subscribe says "send me these values," something has to define what values exist, what they are called, and what type each one is. That something is YANG — a language for writing data models, which are the dictionaries of this world. (The acronym stands for "Yet Another Next Generation." Engineers name things in moments of weakness; judge the tool, not the christening.)


A YANG model is a named, typed, tree-structured catalog of everything a device can report or accept. Named: every fact has a human-readable path. Typed: the model declares that this leaf is a 64-bit counter, that one a true-or-false state, that one a text string. So tools know how to handle each value without guessing. Tree-structured: facts nest inside containers the way files nest in folders, so all of an interface’s counters live together under that interface’s branch. If you know SNMP, this should sound familiar: it is exactly the job MIB files do. The difference is legibility. Compare the address of the same fact — bytes received on an interface — in both worlds:


SNMP OID:    1.3.6.1.2.1.2.2.1.10.3
YANG path:   /interfaces/interface[name=Ethernet3]/state/counters/in-octets

The OID is a numeric filing-cabinet locator you decode with a lookup file; the YANG path is close to a sentence. You can often guess a path you have never seen, and read one aloud to a colleague without either of you opening a reference. The [name=Ethernet3] part addresses the specific interface by its name rather than a numeric index that might shuffle after a reboot. That is a small mercy every SNMP veteran will appreciate.


Now the honesty paragraph. Models come from two sources. Standard models aim to describe common things (interfaces, routing, system health) identically across vendors. The best known is the OpenConfig family, written by a group of large network operators. Models from the IETF standards body sit alongside it. Vendor-native models describe everything else: each vendor publishes its own tree covering every feature of its own boxes. The standardization is real, and for everyday counters it genuinely works across vendors — but it is partial. The moment you reach for a platform-specific feature, you are in that vendor’s native tree, and a multi-vendor shop still juggles dialects. How models are written, published, and discovered — and how much uniformity to actually expect — gets a full guide of its own in YANG models and model-driven management.


One message, end to end


Time to assemble the cake. Here is the life of a single telemetry update — one interface’s receive counter, streamed once per second — written as a transcript. Every line is one of the three layers doing its one job:


step 1   collector opens a gRPC channel to the device
         TCP session, then TLS handshake; each side proves its
         identity with a certificate            [gRPC]

step 2   collector sends: SubscribeRequest      [gNMI verb]
         path      /interfaces/interface[name=Ethernet1]
                     /state/counters/in-octets  [YANG name]
         mode      sample
         interval  1 second

step 3   device validates the path against its models
         ("exists; it is a 64-bit counter") and accepts

step 4   once per second, device sends: Update  [gNMI]
         path       ...counters/in-octets
         timestamp  nanoseconds, stamped by the device clock
         value      918273645123
         carried as compact binary over the encrypted
         channel, delivery acknowledged         [gRPC]

step 5   collector decodes each Update and stores one point:
         path + timestamp + value  —>  time-series database

Walk it back through the layers. The subscription (step 2) is a gNMI sentence whose nouns come from YANG: it names a path and a cadence. The validation (step 3) is the dictionary earning its keep. The device can refuse a misspelled or unsupported path up front, instead of silently returning nothing. The update (step 4) is the payload you actually wanted. The device reads a number it already holds and stamps it with its own clock. So the timestamp records when the value was measured, not when it happened to arrive. The device hands it to gRPC, which moves it encrypted, in order, and acknowledged. And the decode (step 5) shows how little magic remains at the end. What lands in your database is just a name, a time, and a value. Multiply by every subscribed path, every second, every device, and that humble triple is the whole river of streaming telemetry.


And when the channel breaks — a reboot, a failover, a fiber cut — the transcript simply stops at step 4. It restarts from step 1. The collector redials, the handshake and subscription replay, and the stream resumes. The minutes in between are an honest gap in your data rather than a silent lie. That is exactly what you want a monitoring pipeline to do when it cannot see.


The SNMP-to-telemetry phrasebook


If you have spent years with SNMP, you already own most of the concepts here — they just wear new names. This table is the fastest route to feeling at home:


You know it as (SNMP)The stack calls itSame underlying idea
OID, like 1.3.6.1.2.1.2.2.1.10.3YANG path, like .../counters/in-octetsA precise address for one fact
MIB fileYANG modelThe published catalog defining the facts
snmpgetgNMI GetRead named values once
snmpwalk to explore a deviceCapabilities, then GetDiscover what it knows, then read it
Polling every N minutesSample subscriptionValues on a steady clock
TrapOn-change subscriptionNews when state changes — but acknowledged, on an open session
Community string / v3 userTLS certificates, both directionsProving who may talk to whom
ifInOctetsin-octets under an interfaceThe very same counter, new address

Two rows reward a second look. The walk-to-Capabilities row is a genuine workflow upgrade. Exploring a device with snmpwalk means pulling everything and sifting the wall of text. Capabilities hands you the device’s table of contents first. And the trap row is the big reliability fix. A trap is a single unacknowledged packet that can vanish precisely when the network is misbehaving. An on-change update rides the acknowledged stream and gets retransmitted if the first attempt is lost.


Certificates: the new keys to the kingdom


One operational shift deserves its own section, because it changes your day more than any protocol detail: the authentication model is certificates, not passwords. SNMP access control was a shared secret — a community string, or a v3 username with keys. The telemetry stack’s natural posture is TLS with certificates, usually in both directions. The device presents a certificate so the collector knows it is streaming from the real switch and not an impostor. And the collector presents one so the device knows who is allowed to subscribe or write configuration. Writing configuration is far more sensitive with Set in play.


Certificates age better than passwords: nothing secret crosses the wire, and a certificate can be revoked without touching every device that trusted it. But they demand hygiene that shared secrets never did. Certificates expire. Devices and collectors each need the right ones installed. Someone must own issuing, deploying, and rotating them. A lapsed certificate does not fail loudly — the stream just ends, and a collector that is not watching for silence will happily chart nothing. Plan for that from day one. Know where each certificate lives and when it expires. Alert on both "certificate nearing expiry" and "no updates received from device X," so a quiet failure still makes noise. Here is one more practical wrinkle while you are planning. In the common arrangement the collector dials the device. But many platforms can also be configured to dial out from device to collector. That is worth knowing early, because the two directions cross your firewalls differently.


Tip: treat telemetry certificates exactly like the web certificates you already monitor — inventoried, expiry-checked, renewed on a calendar, never by heroics. The most common early telemetry outage is not a protocol problem; it is an expired certificate nobody was watching.


One line per layer


Here is the whole guide, compressed to something you can recall in a hallway. gRPC is the phone line: encrypted, always on, every message acknowledged. gNMI is the grammar: four verbs — Capabilities, Get, Set, Subscribe — and Subscribe is why you are here. YANG is the dictionary: a named, typed tree of everything the device can say, addressed by readable paths instead of numeric OIDs. The dictionary goes on top, the grammar in the middle, the phone line at the bottom. Every update that reaches your collector is just a path, a timestamp, and a value that rode all three.


Where to go next


With the acronyms decoded, the rest of the subject opens up. If you want the operational picture of what streaming changes day to day, start with push versus pull. If you are weighing whether any of this belongs on your network yet, the honest SNMP-versus-streaming comparison is written for exactly that question. The full set of guides lives on the Streaming Telemetry pillar page.


Put this into practice with SysPeep Monitor

Learning the new stack is smart; meanwhile, your network still needs watching with the tools it speaks today. SysPeep Monitor covers that ground. It discovers your devices and collects health and performance data over SNMP, WMI, and SSH. It keeps alerts quiet until something matters. The free trial installs on a Windows machine in minutes.

Download Free TrialLearn About SysPeep