Now we're going to have just a talk about telemetry and where telemetry fits in.
The thing about telemetry and what's interesting on the Anarsi exam, in version 1.1, this is new
content that they've added to this. What they really want you to know for this exam is what
telemetry is and where it fits in. How to configure streaming telemetry is really a
DevCore or DevNet expert exam criteria. That's the configuration comes in there. WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
DevCore or DevNet expert exam criteria. That's the configuration comes in there.
So what we're going to talk about is what it is. Because with logging and with debug
and with SNMP traps, there are just a lot of downfalls or cons to this. For the first part,
logging and debugging basically requires you to be on the machine to read it. Yes,
you can configure syslog exports to send it to a syslog server, which is basically just a glorified WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
you can configure syslog exports to send it to a syslog server, which is basically just a glorified
database that holds all your log messages. But then that comes the second problem,
is that a log message itself is really just a blob of text. It's just a sentence, a human
readable sentence. And that makes parsing that text nearly impossible in a programmatic fashion.
It makes it to where the most that you can really do is get the log message into this database WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
It makes it to where the most that you can really do is get the log message into this database
and then build some sort of website to present you the log message, but it's still up to you
to do something about it. It still requires a human to be reading the website, which queries
the database, which comes from the log message. SNMP is really more of a polling and on an interval WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
the database, which comes from the log message. SNMP is really more of a polling and on an interval
schedule. It's also quite restrictive as to the kinds of things that it can pull or trap,
so to speak. And then you're still having to export this to some sort of SNMP server,
which has a web front end, which requires a human to step in and interact. The big problems here are,
first of all, can a computer react to the message? Usually not. It struggles to. And secondly, WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
first of all, can a computer react to the message? Usually not. It struggles to. And secondly,
how can we automate responses to this? And thirdly, how do we get notified quickly when
something goes wrong? With SNMP traps, logging and debugging, a flapping interface or a flapping
protocol might still get missed. This is the problem that streaming telemetry, we're going to
put streaming at here at the top, telemetry solves. Now, ultimately, with streaming telemetry, WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
put streaming at here at the top, telemetry solves. Now, ultimately, with streaming telemetry,
it begins with a model. What is a model? It's not someone who puts on clothes and lets you see what
clothes looks like on, you know, skinny people or whatever. No, we're talking about a data
structure. When I say data structure, everything is defined. Like, you know, if it begins with
an open and closed brace, we'll say, you know, name and date and event and, you know, detail WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
an open and closed brace, we'll say, you know, name and date and event and, you know, detail
and error message, something like this and where and when. Every single thing about who, what,
where, when and why and how can be answered in a predefined data structure such that when
something occurs, like an interface flap or an OSPF neighbor adjacency goes down, when that certain WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
something occurs, like an interface flap or an OSPF neighbor adjacency goes down, when that certain
event occurs, we know exactly what kind of data we're going to receive. What happens in streaming
telemetry is the event occurs and then that message gets delivered to some sort of application
that knows already how to read every single structure of this data. Rather than looking
like a free text sentence, a computer knows what the key and the value of that key is, like WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
like a free text sentence, a computer knows what the key and the value of that key is, like
interface gig one zero and date is, you know, a timestamp and the event is down and the detail
OSPF and the error, you know, faked or whatever, false, true or whatever. The point is, is having
a predefined set of data delivered to an application that knows how to parse or read that predefined WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
a predefined set of data delivered to an application that knows how to parse or read that predefined
set of data means we can now build responses and automations to this. These automations can be as
simple as send a notification to pager duty or telegram or email or slack or whatever communication
tool you have. Or it could be if this specific type of event occurs, run this Python script WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
tool you have. Or it could be if this specific type of event occurs, run this Python script
to fix it, to remediate it. Beyond that, this is actually going to include counters or metrics,
basically data that is quantifiable. So when this data gets streamed out and we have numbers that we
can work with, we can absolutely turn these into pretty dashboards and charts like so. And this is
actually what you see with things like Cisco's formerly DNA Center, now Catalyst Center, the WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
actually what you see with things like Cisco's formerly DNA Center, now Catalyst Center, the
assurance platform, something we're going to cover later on in this series. But ultimately what you
have is you have racks and racks and racks of switches and routers, hundreds, thousands of
routers. What we can now do is we can set up gRPC subscriptions as well as NetConf subscriptions
or even use RESTConf. And ultimately what these protocols mean is we're getting XML or JSON data, WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
or even use RESTConf. And ultimately what these protocols mean is we're getting XML or JSON data,
meaning the data has been structured in a way that computers, not people, but computers can
quickly read the data and react to it. So when we have these devices, imagine a campus with hundreds
or thousands of switches and routers, all sending in JSON data into some form of database, all of a WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
or thousands of switches and routers, all sending in JSON data into some form of database, all of a
sudden now my main application can parse and react to the data that's now being stored in the
database. Now this is a incredibly oversimplified way of saying it, but that's really all you need
to know and recognize for the Inarsi exam. It's that the point of telemetry isn't to pull for data
and then have a human read it and interact with it. With telemetry, we're collecting all sorts WEBVTT X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
and then have a human read it and interact with it. With telemetry, we're collecting all sorts
of data, counters, errors, events, and pushing them into a database where an application can
either present it as a beautiful dashboard or visualization or kick off a secondary workflow
where we notify our NetOps team or we kick off some sort of Ansible automation or Python scripting
to react to the events that have occurred.