Jason: All right. Hello everyone. First, I want to say thank you very much for joining us. Excited about today’s topic. We’re talking about network automation and a new NetBrain technology called Qapps or what we sometimes refer to as NetBrain Apps. It’s really writing an app for your network. We’ll talk more about what a NetBrain Qapp is and what it can do in this webcast.
Ok. My name is Jason Baudreau. I’m the U.S. Marketing Manager here at NetBrain. I will be your host today and walk through a set of slides, but the most interesting content of this presentation is going to come through demo. Dennis Kuruvilla, our NetBrain Pre-Sales Engineer, will be running the NetBrain demo showcasing some example Qapps and what a Qapp can do. And we also have Dr. Guangdong Liao. He’s our Lead Computer Scientist and our resident Qapp expert and will be taking your questions throughout the webinar, o, make sure you ask questions along the way, and he’ll be here to address those as we go through.
So, that’s who we have. I just have one housekeeping slide before we get started. I want to let everybody know that we’ll have this webinar recorded, so we’ll share this with you early next week. Same thing with the slide deck that I’m walking through, too.
Also, the GoToWebinar interface has that Questions window. So, as I mentioned a minute ago, Dr. Liao will be in the room with us answering your questions through that chat window. We’ll do our best to answer them along the way through the chat, and we’re gonna probably have 10 or 15 minutes at the end of the hour as well that we’re gonna reserve. So, you can keep asking your questions. We’ll also try to address those questions over the phone if we think it’s something that everybody would benefit from hearing.
And the last thing is actually an interesting and really exciting promotion that we have. So, once we talk about what a Qapp is and what a Qapp can do, hopefully, imaginations out there will get running about things that you guys want to automate with Qapps. As we receive your requests, we have an offer to actually work with your teams to write custom Qapps for your networks. And usually, this is something that our Advanced Services Team offers, but we’re gonna be offering that service free of charge through the end of the year.
So, our goal today is to introduce what a Qapp is and get you thinking about, “Oh, what can I automate?” And we’re gonna actually be working with you. We’ll take your requests, follow up with you, and build those Qapps together. So, more on that at the end of the webcast.
On to the agenda. First and foremost, for some of you, maybe your customers or you are using Qapps, but maybe aren’t quite familiar. What is a NetBrain Qapp? We’re gonna talk about how they work, but it’s difficult to talk about what a Qapp is without first talking about mapping, because a Qapp really a great way to customize your NetBrain maps through automation.
In our demo that Dennis is gonna run for us, we’ll shows you how to run some Qapps. He actually has four examples of some Qapps that we’re gonna run in our live environment here. You can see what that looks like and what that means. I’ll kind of address those with some use cases for Qapps. You’ll see that you can use them for troubleshooting, documentation, compliance, and a whole lot more, and we’ll talk about those examples.
And then, the last piece is writing a Qapp. So, one way to think about a Qapp is like an app for a smartphone. It’s like an app for NetBrain. Every new Qapp is a new feature, is a new use case or capability. Where that analogy kind of takes a turn is that with NetBrain, you can actually write your own apps, and you can do that without any scripting, whatsoever. So, the last portion of today’s webcast is talking about what that looks like, and we’ll actually run a live demo where we write two Qapps from scratch. You’ll see how easy it is.
So, the first question, what is a NetBrain Qapp? And you can see the line underneath here, it’s “Customized Mapping through Automation.” So, I mentioned it’s hard to talk about what a Qapp is without first talking about network mapping or network documentation. So, the first thing I want to do is start with a set of polls.
I want to ask the audience, in terms of network documentation. Is your network fully documented?” And so, you know, by that, I mean, are you basically satisfied with your network documentation? Perhaps you are a NetBrain customer and you use NetBrain for diagramming, or maybe you use another tool, or you’re doing it yourself. So, I’m taking everybody’s responses right now. There’s a poll on your screen. I’ll just let everybody submit those for just a moment or two.
All right, excellent. So I’m going to close this poll. Thank you for the responses, and I’ll actually share what everybody has to say about their documentation. So, we do have some NetBrain customers on the call, at least 30% of you, it looks like. A good chunk of you are, sort of, reporting that documentation is a disaster, and maybe that’s why you’re familiar with NetBrain. So, that’s certainly one thing that you can automate, is network diagrams. And then it sounds like the bulk on the people on the call are actually saying that, “We have documentation, but keeping it updated is a challenge.” So, thank you for the responses. That’s cool.
So with that, I’m going to segue a little bit about the Qapp – the goal of what a Qapp is and what a Qapp can do. It’s actually a lofty goal. The idea is to make any map become the interface to your live network. So, what does that mean? Not just a reference document, but the interface to your live network. So, a NetBrain Qapp, or rather a NetBrain Map, a NetBrain Qmap, as we call them – it gives you a custom view of your network, depending on the task that you’re performing. That’s number one.
But it’s the information that you can learn through that map that enables it to be that one interface to your network. You can see things like device or interface attributes, live performance history data, and a whole lot more. You can get all that information through a NetBrain Map, and that’s great, but if you really want to have an interface to the live network, you need to be able to access virtually any information through that map. So, we believe pretty strongly that a map is the best interface to your network because it’s visual, right? You have access to a lot of interfaces and a lot of devices in one visual platform. But, the best way to make it an interface is to be able to put any information you need on that map.
So, I have a couple of slides. You know, you have static…we call them static diagrams, or more traditional, maybe, you have a Vizio diagram, as an example. They’re incredibly valuable. They show you basic topology information. Here’s an example. Maybe your documentation is better than this, maybe it’s not in terms of details, but here’s an example. It gives you IP addresses, and hostnames, and all that good stuff.
Then you have a NetBrain Dynamic Map, right? So here’s a map that I took a screenshot, I zoomed into it. You can see all those dynamic details, things drilling into a device and looking through that, Properties, and Topology, and Device Information, that deck of cards there. You have the design reader that you can access through NetBrain, so you can learn about interface properties and configurations. So, these maps are great, right? They’re very information-rich. We call them dynamic because of all the information that can be dynamically accessible. But the challenge is, it’s still not enough if you really want to be able to use the map as the interface to your live network.
So, no map can tell you everything. There’s just too much information. If this orange circle represents what you can learn on a dynamic map, then this blue oval is going to indicate, just, suppose, any information you may need for a given instance. And I have some examples here. If you’re doing troubleshooting, or documentation, or compliance, you might have a lot of questions, a lot of things you need to find out. Is routing configured properly? Are there any duplex mismatches? How is QoS performing? Things like that. And traditionally we find the answers to these questions through the CLI, right? We do that, sort of…it’s a manual process. We do it through the CLI.
So, what a Qapp offers is a way to take this information from the live network and to display it on a NetBrain dynamic map. So, it’s a visual way and an automated way to pull information from the live network and display on a NetBrain map. Another way to think about that is like turning on layers on a map. So, I have this NetBrain dynamic map here. It’s a Layer 3 map. I can turn on various layers by running various Qapps.
One example, I can run a Qapp to analyze the routing design. In this case, it turns on what we call Highlighting. Highlighting gives me a legend down here on the bottom, an interface legend which tells me the dynamic routing protocol configured across the interfaces. And so, they’re color-coded interfaces. I can see, for example, dark green tells me that EIGRP 300 is configured. I can see my BGP peering happening between WAN routers, for example. My Bos-WAN has BGP on a specific AS. So, that’s a Qapp that I can learn about dynamic routing. I might run a different Qapp if I’m doing a compliance verification, maybe making sure that my network compliant.
This particular Qapp will color-code the devices, again via Highlighting. And in this case, it will be a security compliance check. It will tell me if my timeouts for Telnet or SSH exceed 10 minutes. That’s a potential security concern. So, in this case, the red device, LA-WAN, tells me that my VTY settings exceed the 10 minutes that compliance requires for security. So, that’s a compliance Qapp.
And the last Qapp example here is for troubleshooting. If I want to know, “Are there any increasing errors on any of the interfaces?” You can run a Qapp for that. It’s actually going to log into every device in the map. It’s going to pull out information from the interface command and display that on the map. You can see the Frame errors, input errors, CRC, and Collision errors on the map. And you see in red over here by LA-WAN, that’s telling me that there are increasing errors. So, there’s an app for that as well.
One of the things we say is, “With a Qapp, a picture is worth a thousand CLI commands.” Of course, that picture is actually a map. So, it’s a way to perform automation. Instead of looking at one device at a time or one interface at a time, you can diagnose, or analyze, or understand your network at the map level.
And so, just briefly, how that works, how a Qapp works. It takes a group of devices as input. For example, the previous examples I ran through a dynamic map. So you can take devices in a dynamic map as input. You can also look at a table or import a table. And it performs analysis on the devices. It’s actually reaching out to the live network for that. Whether it’s looking at the live config files, or issuing live CLI commands, or using SNMP, it’s pulling live data from the network. It’s performing an analysis based on that data.
The output of that Qapp is going to be some sort of an overlay, potentially, on the map. You saw examples previously where I was highlighting a map. You can run a Qapp to monitor the Map. You can run a Qapp to create an alert message or, actually, even export a report. So, there’s a lot of different ways that you can input data and, basically, output data, all depending on just what kind of task you want to accomplish, and that’s all through automation with Qapp.
So, the best way to talk about this is actually through a demo. I kind of gave you just a little bit about what it means and what it looks like, but Dennis will give you a much better explanation through a live demo. So, Dennis, would you give us a peek?
Dennis: All right. Thank you, Jason, and thank you, everyone, for attending today’s webcast. All right, so I want to direct your attention over to the left, if you can see this Qapp Center. And this is actually a location where you’ll be able to see all the built-in Qapps within the software, and also any of the files, and the Qapps that you build on your own. Now, if I select one of these Qapps, you’ll be able to see that we’ve got a description showing us how the Qapp is run. You’ll also see a brief output example of what it will look like once it’s executed.
All right, so before we start with showing how this Qapp works, I’m going to start with this quick scenario. Let’s say, for example, after troubleshooting multiple devices, you forgot to log out of some of your devices and you walked away from your desk. Well, due to the inactivity on your session, hopefully, it’ll automatically log out of your devices, all right? Well, with NetBrain, we can actually use a Qapp to help test it. I can do this on any map, right, as you can see right here. So, let’s go ahead and do this on all the devices within our data center. So, I can simply run our Qapp. Selecting the Qapp that we want to search, you also see that, you’ll be able to see a description here to the right.
Now, once I run this, you can see the status going below, and once NetBrain completes it on every single device, we’ll have a legend here showing us the devices that are in compliance and even the devices that are not, visually shown in a red highlight. You also see that we have a little note pop up on the devices, letting you know how the current timeout settings are set. All right?
So, let’s expand on this. What if I had a Golden Template, and I wanted to check my configurations in my entire environment now against this template? Well, with this Qapp that you see right now, we’ll be able to do this. So, eventually you can run this directly on that map that you had, or you can just simply run this on every single device in your environment.
So, here, I’ll be able to select the devices. Let’s go ahead and do this on our Cisco IOS switches. And I can add these devices in. Another thing to note, you go down here at the Execution Options. You notice that we’re just taking a look at the configuration files. We don’t have to actually access the live data because NetBrain has discovered your entire environment and collected all this data on the back-end, so I can just use the cached data. And here’s where I’ll be able to select the folder where I want to save it. So, let’s go ahead and save it on the desktop. All right?
So, once I start this, you can run this, and NetBrain is going to come up with a template, a pop-up. So, here’s where I will be able to select that template that we’re going to be able to use. So, I have this saved in our desktop files, and we’ll go ahead and start to run this. You can see the status below. You’ll never go through all of this text file, right? So, here’s an example of what this text file that we’re looking at is. You can see that we’re checking to see that the NTP settings are configured, right? We have enabled passwords, one of these three passwords configured. And, even at the interface level, to check and see if the trunk ports are allowing VLANs through.
But as you see, once it’s completed you can take a look at the report that it’s generated, and you can see that what comes out, it’s showing us the line items that are missing from the devices, right, even if something’s different. For example, you see on our Boston remote device, the password there is not the same as what’s configured on the device.
Those are two of the examples that we have. The first one that we showed was how you can simply highlight data on your maps. The other one was to generate a report, right, to compare all your data to a specific template. Now, another type of Qapp that we have is the ability to monitor live data, right? So, if I wanted to track interface statuses, even going to the interface level and see collisions or any type of errors, I can always use an app for this.
So, let’s go ahead and open up one of our Layer 2 maps. So, right here I’m going to go ahead and run our Interface Error Check. And when I run this, you can see that we’ll get a chart giving us the detailed data of what’s going on in this environment. And as I zoom in closer, you’ll start to see that NetBrain will visually show us links that are good in the green. And even if there’s any errors, we start the see the links highlighted in red, even highlighting the collision errors, CRC errors, or any other variable that you want to represent.
All right? And now there’s also one more type of Qapp that I want to showcase today, and that’s the neighbor checking type of your Qapp. So, this Qapp will allow you to check the neighbor configurations between two different devices. And so, with this particular one, it’s going to check the speed and duplex between two devices. Let’s try to see if we can use this Qapp to help troubleshoot that Layer 2 map that we had. Let’s see what’s going on, why these collisions are happening between these devices.
So, simply run this Qapp again, and selecting the Qapp that we were looking for, the Interface Speed and Duplex Mismatch Check, and I can run this. And you can see that NetBrain is going through every single one of the devices, and once it’s completed, it will populate a note on the map letting me know the actual configurations on these ports, and even telling me that there’s a mismatch at the duplex setting, and also noting the speed that’s configured on those ports.
All right, so just to recap, we’re able to go through Qapps that highlight key data on our maps, even generate reports to check the compliance. We’re able to monitor live statistics, and even do a neighbor check between devices to verify a consistent configuration.
I want to thank everyone for attending, and for your attention. I will go ahead and hand this back over to Jason.
Jason: That’s great. Thank you, Dennis. So, one of the things I mentioned at the beginning of the webcast was talking about the goal of Qapp. The goal is to enable us to turn a dynamic network map into an interface to the live network. The idea is to actually spend less time in the CLI and spend more time, automating things at the map view. So I think those examples that Dennis ran gives you a little bit of a sense of how you might be able to do that.
So, I do have another poll, my second out of three. I want to ask, “Do you currently automate any network tasks.” Looking for a kind of the ‘State of the Union’ right now for what everybody’s doing in terms of network automation. One thing I’ve noticed when I talk to people about network automation is they think about it in different ways. They think about, “I use a certain tool,” or, “I write scripts.” Maybe, “I use other scripts in my organization.”
It looks like people are still responding, so let me close this out, and I’ll share the results. It’s actually pretty interesting. So, it’s pretty split between people that aren’t automating but they wish that they could do more, saying, “I wish I could do more with less,” that’s 40%, of people that are automating. They’re using scripts for their automation, and definitely there’s a lot of power in that. If any of you are on the call that write your own scripts, I think you’ll be really interested to see, the second half of our demo, covering what it looks like to write a Qapp. So, let me hide those results, and we’ll move on.
So, we looked at use cases of Qapps through a demo that Dennis just ran for us. I’ll just summarize what we looked at. You can automate network management tasks across the board. We saw examples of troubleshooting, so here’s a couple more. You can monitor an application’s performance. Maybe you can check and see if there are any EIGRP neighbors flapping, detect any interface errors. That’s the example that we ran through Dennis’ demo, so we saw if there were any increasing errors.
And you can also automate documentation. And that goes beyond automated diagramming, which NetBrain does automatically, but you can automate detailed and customized documentation. The detailed network design you can document, for example, the Multicasting Distribution Tree, which is an image I actually have down here. Maybe you just want to export a specific report that details all the interfaces that have increasing errors. And that’s all possible through running a Qapp as well. You can see the orange lines down below indicate the Multicasting Distribution Tree.
And then, maybe, the last example here, although I’m sure there’s many more you can think of, is automating various compliance checks. Maybe you want to check all configurations against a “golden” set of rules. And you can create that “golden” set in a text file. That’s the Qapp that Dennis demoed a moment ago. Or, you can create a report for all the devices in your network with unencrypted passwords, generate a map of devices with public SNMP strings. These are just a list of our ideas, the things that we’ve come across with customers that are important, but the real benefit of Qapp is that you might have 100 or even 1,000 more ideas on your own.
And so, that kind of leads to the next point, which is it’s not enough for NetBrain to just build these things and include them out-of-the-box. We have to enable the customer to write their own Qapps themselves. And really, we’re going to start by doing that for our customers, taking the burden of writing these Qapps off you, and that’s the offer I alluded to earlier. More on that in a moment. But, what NetBrain offers is a visual programming environment that’s used to program the logic for each app.
So, there’s three breakthroughs in particular that I want to talk about that make this possible. And the first one is that we have this…we call it a topology-aware framework. What that means is that NetBrain already discovered the network, right? It’s aware of detailed device information. It’s aware of any neighbors. It can also map an application flow, right? Some of your customers know, it can map between point A and point B on a path. That means that when you build a Qapp, that Qapp can be aware of all of this information that NetBrain already knows.
Number two is there’s this canvas-based user interface, and that’s the image that we’re looking at on the right hand of the screen. It means that you can program via drag-and-drop. You can just kind of drag an icon to the map to indicate, maybe, a CLI command, or how you want to export that to a table, and our visual programming environment will generate the Python code on the back-end. You don’t have to worry about that. All you have to do is worry about what you want to do, and you can drag and drop.
Number three is, we call it sample-driven programming. What that means is if you want to, for example, write a Qapp to understand if there are any increasing CRC errors, well, there’s a show interface command for Cisco devices as the example. You issue that show interface command on a sample device, and then you manipulate the sample output as you’re writing the Qapp. And this will make a lot more sense, I think, when Dennis walks through the demo.
So, there are basically three steps to that. The first is, you select a template. We saw different kinds of examples of Qapps. You decide how you want the output of that Qapp to look based on the template that you choose. Through the previous demo, we saw a neighbor check. That was the duplex mismatch. We saw the highlight map. That was the configuration compliance check. And we saw the Monitor Qapp, and that was the interface errors, kind of, a troubleshooting Qapp.
So, the first you select a template. Then, to define a set of sample data, you issue a sample CLI command on a sample device, and then you define the fields of interest from the output of that command and you parse those out. The last step is to define the logic. So, in other words, if you want to see if those CRC errors are increasing, then you define that logic inside the Qapp and determine how you want those results to be displayed on the map. So again, it’s really difficult to talk about on a slide. It’s actually much more powerful if we can show that in demo. We’ll see that in just a second.
And the last thing I wanted to point out is that each Qapp you add to NetBrain is like adding a new feature. I think I mentioned this earlier, but one way to think about a Qapp is like adding features, or functionality, or use case capabilities to your NetBrain instance. So, this is the Qapp for that multicasting tree that you saw earlier.
So, with that, let’s look at what it actually looks like to write a Qapp. I think it’s really important to understand how flexible this interface is and how powerful. Because, at the end of this call, we’ll be inviting you all to submit your own requests, and we’re going work through those with you. So, Dennis, let’s take a look at what it looks like to write a Qapp.
Dennis: Thanks, Jason. All right, so let’s go ahead and continue with our compliance scenario, right? So, let’s say, even though we don’t have the timeout setting configured, we wanted to make sure that every single device has service password-encryption configured on it. Well, we can actually create a Qapp directly for that purpose. All right, so I simply go up here, go to New Qapp, and again, this template, this is where I’ll be able to choose the one I want to start with. Now, since we’re going to highlight some data, let’s go ahead and start with the Highlight Map Template.
All right, so now with this execution flow, it’s going to be as simple as just jumping right into this canvas. And right here, you’ll be able to see the first node, this is the Device Selector. So, here, I’ll be able to select the types of devices. Here, I’ll go ahead and select all of our Cisco devices, and I can also give this a name. Now, if I wanted to create this for multiple types of devices, I can just create another branch right here, and drag this to a new drop, and create another item for a different vendor.
So, since we’re actually doing this on the current config, we don’t have to run live network access to these devices, so let me go ahead and remove these CLI commands. And just to create a new node, I simply drag right from that node and create a new configuration command. Now you can see that what we’re going to get is the current baseline. That’s that cached data that’s already discovered of every single device.
Now, the next step is to re-create that table. We have our table here. Simply have to take that original result, which is actually that configuration file, and add to our table, right? And now the final step would be to create an output. So I can, in the same way, just drag this over and create the basic output. And now we can use this “if” and “else” statement, and the action, all right?
So right here, what I first do is say, “If my original results,” let’s say it contains anything … So, I’m taking a look at the configuration. I want to see if the configs contain anything, So, I say “no service password-encryption.” All right, now if that’s the case, the action that I want it to either alert, I can highlight, but let’s go ahead and re-create a new map. So I’m going to do a draw map. Simple as dragging that right to this pane.
The next step, I can simply see that if I wanted, I can highlight the devices, or I can even just add a note. So, let’s go ahead and type in a note saying, “Service password-encryption is not enabled.” All right? And the final step would be to save this into our save location. I can give this a name. All right? And I can even run this directly from this to test it out.
So, since we selected all our IOS switches, let’s go ahead and select that as the devices, move them over, and run this Qapp. You can see down below is going to be the status, letting us know what’s going on. And if you notice, what’s actually happening is with that interface, we’re able to create a Qapp. And on the back-end, we’re actually using Python scripting to build out and re-create this map. You can see that, instantly, we have every single device that does not include that information. And you can open this up to verify, and you see that it says, “No service password-encryption enabled.”
Well, if I wanted to fix this, we can actually use our change management module, and this will allow me to push the change to every single device. So, right here I can simply define that change. Let me just go ahead and save this. Now, this seven-step process is going to allow me to push that change to every single device and fix that issue, right? I can just go here and config T, add that command, and end. Now simply apply this to every single device, and that’s only going to apply it to the template, and then I can execute this to every device. So, now we’re able to find the issue and immediately fix every single device within seconds.
All right, so that’s one example I wanted to show you how to build a Qapp. So, the next example, I want you to remember this monitoring Qapp that we were working with, right? So, it looks like there’s a lot of data here. It looks pretty complicated, but I actually want to show you how easy it is to build something like this as well. All you have to do, again, same process, starting with a new Qapp. Within the templates, just go in and select that Monitor template.
And there might be a little bit of difference here, right? So you see that we have in the execution flow a loop. Well, that’s because we’re going to access the live data, so now we’ll be able to schedule how often it’s polling your environment. And then once we set that frequency, I can just jump right into the canvas again.
All right, so now on the same steps, I can just go into the devices, select the types of device that I want to include. Let’s go ahead and do this again for our Cisco Routers and IOS Switches. And again, you can give this a name, and then simply apply this. Now, since we’re doing this on the live data, I can use a CLI command on the devices to get a sample. So, let’s do a show interface. I can retrieve a sample from one of my devices in my environment. So, I’ll use our Boston router, pull this up, and you can see that NetBrain is retrieving the live data directly off that device.
Now you can see down below, I can zoom in, scroll down, and I can see all the details based off these interfaces. So, let’s say I wanted to monitor specific sections. You can take any part of this. So I’ll go ahead and take, let’s say, our CRC errors, and you see it pops up with a Define Variable. I can just simply define that variable now.
Here I can give that variable a name, I’ll call it CRC. And if you notice, we have nine matches. Well, that’s because every time we see an interface, that’s going to represent a new section, right? But we can actually tell this to separate it into paragraphs, so that each interface counts as a new paragraph. I can highlight this information and set that as a paragraph identifier.
Now, this information is not going to be static, all right? That interface will always change, so I can create a variable just by using a “$” as an interface, and even that status is going to be up or down. So let’s call that $STATUS, all right? Now, once I hit refresh, you’ll be able to see all those variables created instantly.
And I can even add more details here. So, let’s say we’ll go ahead and add our collisions as well. I can define that as a variable and call that collisions. And if you’ve noticed up above, you see we have those nine sections now for every single interface we can go through, all right? And now we can just save this variable.
So, if you look to the bottom right, you can see that the Parser Tree is going to show how the variables will be parsed out for you. And now the next step, just like we did it earlier, was just to add this to our table. We can add the interface, the statuses, the CRCs, and the collisions, and you see all this information on the table. All right?
So now, finally, we’ll create our output. So here, as you can see, we can highlight items on our devices or even at the interface level. So, since we’re dealing with the interface, let’s go ahead and select that Interface Item. And I’ll set the interface as my index. And now I can just drag over all these items, the STATUS, CRCs, and the collisions, into the map. As you see below, this will allow me to show some of this information on my maps, right? So, right here, I can select this icon, and it’ll show me where I want to place this information. So, either 1, 2, 3, anywhere here. So, we’ll start with those first items. You can see here, I can select Position 1, apply this. I’ll do Position 2 and 3. And now, once we see that preview again, you can see that data populated here. So, once we run this Qapp, we’ll be able to see that information.
And the final step, before we save this is to create some alerts. So, let’s say we wanted the links to turn red. We can enable the errors, based on a delta. So, if there’s increasing errors within the interface, you can say that if increasing errors are going above zero, we want this link to turn red. And that’s all there is to it. So, just simply save this, and then run that, and just go back to this monitor that we have running, if we can take a look at how it looks.
One thing I want you to see is I’ve had this monitor running for a while. And as I open this up, you can see the chart showing you details about those errors that you see, right? And you can even select that raw data right there to see the actual configs that are being issued for every single device, and even on the timestamps showing you how often it’s been polling the devices. All right? So, I hope everyone enjoyed the demonstration. I’m going to go ahead and hand this back over to Jason.
Jason: Awesome. Thank you very much, Dennis. I’ll take the control back. So, you can see over the course of maybe 5 or 10 minutes, Dennis wrote 2 apps from scratch. And you could imagine that each one of those apps, you could run again and again, possibly saving you hours or more. So, really, that’s the power, right, of network automation.
So, this is my last polling question. It’s designed to, hopefully, get everybody thinking about, “What would you like to automate? If you could automate any task, what type of task would that be?” So, I’ll launch that poll. This is leading into our offer, which is to help you automate these tasks, so specifically, if it’s troubleshooting, compliance and security, documentation, or configuration changes. I’ll leave that up for just a moment. Okay, I’ll give everybody just a second, because I still see them incrementing the polls. All right, I’ll cut that off there.
So, I’ll share the results. Thank you, everybody, for participating. So, troubleshooting is number one. I think when there’s an issue, or if you’re troubleshooting a network problem, certainly every minute counts, so I think that’s where automation is most important. So, I agree. That actually has my vote as well. Second was compliance and security, because I think that that’s just a large task that we’re faced with. So, 23%. Thanks again, everybody, for sharing your feedback.
And I’m gonna wrap up the webcast today with just another slide or two. The last one, I want to invite everybody as a reminder, please, let NetBrain write an app for your team. You can actually request a free custom Qapp. I have a link up here, info.netbraintech.com/request-qapp. It’s a form. You can fill out that form, and there’s a text field that asks you to describe what you want the Qapp to do. And one of our engineers will set up a call with you, sit down with you and your team to actually build out that Qapp and deliver that for you, free of charge.
So, top three reasons to use Qapps. 1- really every Qapp, again, adds a new feature to NetBrain for you. Some Qapps are even powerful enough 2- if you need to customize NetBrain to your network or your needs, especially for things like multi-vendor, we have dozens and dozens of these Qapps built in, but they’re mostly designed for Cisco and Juniper. If you have a different vendor in your environment, please submit your requests, and we’ll customize those for what’s important to you. And last, really, the offer’s free, so no reason not to take advantage of it. Thanks again, everybody.