NTC + IP Fabric: From Tech Debt to Trusted Automation

good morning for those joining good afternoon good evening wherever you are in the world thanks for joining here we’re going to get started in just another minute just waiting for uh the rest of everyone else to get filtered in should be just about there and I think we’re good to go so let’s get started uh my name is Tim Schreyack I’ll be your host today for the webinar and today we’re going to be talking about Network automation with Nautobot and IP fabric creating a holistic Network automation solution with a network source of Truth and automation

Assurance engine uh with our great panelists here with Paddy Kelly from Network to code and Darren Fulwell from IP Fabric little agenda for uh topics today we’re going to go obviously here we have the intro we’re going to be going into the network automation framework Concepts some overview of Nautobot and IP Fabric and then finally ChatOps and a really cool single source of Truth demonstration and now our presenters I will let them introduce themselves so take it away go ahead Paddy thanks Tim hello everyone my name is Paddy Kelly I’m A managing

consultant with Network to Code and I’m happy to be here today uh started our life as a Java programmer moved then into the networking Arena and have about 15 years experience mostly in the service provider and data center space and now firmly in the network automation space enjoying my time at Network to Code and maintaining some of the open source projects and looking forward to the webinar down no deal thanks buddy um yeah Darren Fulwell I’m uh product evangelist with IP fabric I mean it’s the best title in the world isn’t it really um get to talk

about Network automation all the time why would you not want to do that um I’m uh I love the veteran east of the word veteran on the slide there it’s great I’ve I’ve been doing this network stuff a long time um from everything from uh from the engineer on the ground to the architect who does the design and operations uh side of things as well so um yeah I’ve got a couple of certifications but really my my focus these days is the same same as Paddy really that the idea of of network automation is the new way to operate Network so it’s a a fascinating

topic and I can’t wait to dig more into it with uh with Paddy today thanks uh Paddy and dare uh just a quick uh shout out about some of our upcoming Community webinars uh we have obviously today’s and then we do have coming up on October 6th uh simplify Network automation with Nautobot chops the links there you can see in the chat as well for those of you that might want the link to uh those upcoming events we also super excited to announce and uh start talking about hacktoberfest and our hackathons coming in October of 2022.

uh these are from Network to code and designed for our community we have two two of these separate events going on in the same month yes uh so factoberfest uh the full month of October uh definitely willing uh looking for people to participate in the community to join in as well you can see the uh links down there below for where you might be able to join and then the hackathon uh this we’re uh doing this year this year on October 14th and 15th uh you can join as an individual or as a team if you want to be able to really get in and compete for some of

our awesome swag and prizes we’ll be giving out so please uh definitely participate and then we also have some training coming up on uh Nautobot in November our source of truth and Nautobot fundamentals uh will be on November 7th through 8th and automating Nautobot with python and ansible on November 16th uh links there as well to sign up and just a quick point out here the code we have here is specially advertised for the attendees of the webinar and you get 20 off a great discount off of our standard rates here for the public training classes how much

and now moving into the presentation today I’ll hand off to Paddy for Network automation architecture great thanks Tim so we’re going to set the scene really for some of the Integrations that we have coming up and we want to do that by sort of explaining where they fit in the overall Network architecture so at Network to Code we’ve been building Network automation Solutions since 2014 and during that time we’ve created and refined a network automation architecture that represents the core components of the holistic Network automation solution so we’ll

go through this sort of end State architecture and we’ll review some of the components just give you an idea of where they fit in uh we’ll just start top down um so we’ll go for user interactions and the user interactions really is the sort of the entry and exit point of the network automation solution this sort of like how the how the clients or contributors would interact with the network automation platform so it contains some of the more common user interfaces or presentation layers that you might see for like ChatOps or service portals um maybe

some dashboards or even some documentation systems so the orchestration component this will basically uh this will be more of a sign of a sort of a mature organization if there’s a fully functional orchestration system in place um essentially now it defines the tasks that the automation system uh would be used to to connect the various sort of tasks that you want to automate um and it basically allows you to coordinate those tasks so if you have the the workflow engine would basically stitch together those tasks to be automated and they could be

executing jobs or getting data but ultimately it sort of gives you the flexibility to add sort of decision or use conditional logic to control when the tasks will be executed and then you might have an event driven system and here you would need the observability stack really to to be in place of viewability or analytics stack to be in place and that’s sort of the bridge between that workflow engine and the Telemetry system and that makes sure that any of these sort of uh events that are being triggered can can basically kick off the automation piece

within the workflow engine So within the Telemetry stack or the observability stack this is um where it exposes a continuous flow of enriched data so they’re pulling back data from the network and Darren will be going through a bit of this uh later on where we see like The observed State and how the network is actually operating um so this is one of the key things in terms of the information feedback loop that we get back from the automation systems to ensure that we have a feedback loop it’s very important because automation can only go so far if we

don’t have that feedback loop and then the automation engine itself this is but obviously this is sort of uh one of the key components as well so the all the tasks basically that change the state of the network and any other sort of help helper functions um these are the components that are required to push the changes to the network and execute those ad hoc commands you know and that could be the rendering where you’re sort of pulling data from the source of Truth and mapping that against templates to produce the configuration or also the provisioning

element where you’re actually pushing the configuration out to the network you know compliance is also a component of this where it identifies any deviation from the design rules that basically supports our standardization and this is all underpinned by the um source of Truth which is basically a key component and it stores the data that defines the intended state of the network um so it’s rare to have one authoritative source of Truth for all types of systems but um a source of Truth should basically contain all of those systems and databases that act

as the Authority for their data domain so to give you an idea of sort of some of the common tools that sit across some of these uh Architectural Components now this is not the only tools that do these jobs it’s just some of the ones that are sort of give you a visual representation of where they would fit in this architectural framework um but today we’re only going to focus on two of these components so we’re going to focus on the source of Truth and we’re going to look at a tool called Nautobot that will allow you to to integrate a source of Truth

into your network and IP fabric for the observability and the analytics piece okay so what is Nautobot Nautobot is a source of Truth and a network automation platform so it’s a it’s an open source project that was created last year beginning of last year 2021 um and Network to Code is the primary sponsor you can find it there on GitHub you see the link down the bottom there the the GitHub GitHub organization um and now we’re just going to go through some of the the Nautobot use cases what does it do what what’s the what’s the goal of Nautobot well

primary use case here is that it’s a flexible source of Truth for networking you know so the aim is to basically act as the Authority for network data basically essentially document the network with the source of Truth so here we have the different components that would sort of make up your source of truths you have the ipam which are IP addresses and vlans or you have your sort of data center inventory management which are devices racks and sites that type of thing and circuit information so the goal is basically to model this data to drive automation

by defining the intended State okay so building a source of truths obviously can be difficult and it sort of depends on the environment so if it’s a green variant environment it’s more that you’d use the design to generate the source of Truth and more likely it’s a Brownfield environment um and what we’re going to do is we’re going to show you a use case where you can use IP fabric to generate this source of Truth within a Brownfield environment and by importing the inventory cleaning up the data adding a bit of metadata okay another use case for

Nautobot is to be an extensive extensible data platform for Network Automation and obviously to do that it needs to basically provide the an extensive API and which it does it has a rest API and a graphql API in addition to that we have a native git integration where you can basically pull git repositories into Nautobot and have them available they could be storing your templates or other types of data for Network properties that type of thing does webhook support where it can basically trigger a web request based on an action and in addition there’s

also the capability to run jobs and jobs is a is a notable feature that is basically running custom python code within Nautobot within the Nautobot ecosystem and job hooks these are basically like web hooks except they trigger the execution of a job within if there’s an action that was performed in Nautobot and last use case really is as a a platform for Network automation apps and this is a big part of Nautobot it basically supports creating and deploying custom apps to support your network automation use cases now these could be custom and they could

be private you could build your own apps or you could take advantage of the app ecosystem that is within Nautobot and that are available on that GitHub organization and you can see some of them here um this is uh obviously it’s a it’s a fast growing list and this is as a result of sort of many of the customer engagements that we’ve had and we tried to give back to the community by releasing some of these publicly available apps um we have two of them circled here which are the two that we’re going to look at today basically is the IP fabric single

source of truth and the IP fabric ChatOps foreign we’re going to go through a very uh brief demo and we’re going to if you want you can follow along here at demo.Nautobot.com and let me shift this down so I can actually get to it and that’s it there so this is the main Nautobot screen here we can see a summary of all actually if you’re logging in you just use the username and password here at demo.Nautobot.com and the username is demo and the password is Nautobot as I said this is the main screen with all of the um summary of the data that we have

stored in the system and this is a sample data that we have so people can take a look around basically we have the navigation bar at the very top and there’s lots of different options we won’t have a huge amount of time to go through all of this so what I’ll do is take a look at a more device-centric view of what we have and what we can store for a particular device so if we go into devices here once we click on that we will see all the devices that we have within our source of Truth and so if I want I’ll actually go to have a look at um one of the the

backbone readers so I could go to role here select backbone and apply that and I will go to this guy here so once I click on here now I see the detail view for this particular device so in here we can see the site location and the rack and we have all of that sort of physical information that we need we also know the tenant or the customer that’s just going to be associated with this device we know the device type um this is Cisco CSR which is great and we also know obviously what we just searched on is the role device role this is something that’s

quite important within a network automation architecture because we need to know what the function of the device is so we could have multiple devices that are the same type or platform but depending on the function and what it actually does will depend on what features that are enabled or what configuration we need to apply so roll is a really important metadata that we could store in the source of Truth we can also see the platform related information on any other management information would be here key thing that we also have that is uh within

Nautobot is providing the flexibility uh to basically create custom fields and we see custom Fields here and it has a field that is associated with a device now this is something you can add for any devices and it’s sort of specific to your environment in this instance we’ve created an end of support um a field that should be associated with every attribute that is on a device and then here we have it as a particular data and that could be useful for knowing when a device is out of support and so each device could have that stored and you can create as

many others flexible options or attributes that you need let’s take a look at the interfaces here we just detail all of the interfaces for a particular device it’ll capture the the name of the interface the status and you can see some of the other information there we can also capture the cable what the end point is the device and what the the remote interface is and any of the other IP information as well we could trace as well and there’s lots of other options that we can do here but this just gives you an overview of the type of information that we

can see within uh for a particular device another thing I’d like to just show you is looks like we may have lost Paddy’s internet it looks like Petty is back did I drop you did we did lose you for a minute we were just getting ready to move on to Darren there if we needed to so uh you know you could reach air and we can get we can pick back up uh funny enough I actually heard myself in my headset and I was like that doesn’t sound right um apologies for that so uh we’ll kick straight back into it here if you can see my screen um within config context we

can see that we have um ACL and bgp data and root Maps so we can pull that in and Associate that with a particular device we can also do it based on a site and we could do it locally so that uh Define it within Nautobot or we can Define it within a um git repository and Pull It in associated with a particular type of device or or a site the flexibility is there to do whatever we want really so quite quite powerful in that respect one last thing that I would like to show you on the um device page here is that on this part of the page is that we have

additional plugins that can be enabled and plugins are like a first class citizen I guess within Nautobot and that we can enable different apps and that gives us additional functionality so if we see here the device onboarding firewall policies these are enabled and we can basically get additional information by just installing these apps so as an example we have a configuration compliance application and this shows us that we can we can track the compliance for particular features within a device config and it does that by going and getting uh going

out to the network and getting the intended or the actual state from the network and comparing that to the intended state that we store in the source of Truth it does the diff basically to compare it to see if it is as it should be and it will basically just tell us if it’s compliant or non-compliant so it’s a nice easy way to see if your device is standardized across the design and how the network is performing so I won’t come into any more there because we we will look at some of the plugins and stuff a little bit later um and there is uh obviously a

lot more that we could cover but what we want to do now is shift over to Dan um we do have one quick question here on this topic uh it’s Nautobot collecting this information here via netcomp or rest comp and or Telemetry hooks the information uh no well sort of this information that was uh put in was put in initially from an import and it could that’s that’s an easy way to get it in you can use like we said the device onboarding would be able to go out to the network and pull it back in uh for the compliance information if that was specifically around

compliance it can go out and pull it back in the uh the actual state of the network by pulling back into configuration and then it just Compares it to what it has stored in the database for the intended stage great thank you overdue Dan nice one thanks buddy um I guess I guess some of the uh some of the things you’ve touched on already quite interesting but but um IP fabric talks about um Network Assurance as being the next level so from the compliance checks that we’ve already seen um these are based on on config what the the role of Ip fabric is is

what we call Network assurance and this is basically making sure that the network does uh what you intend it to not just one part of the network the whole thing um by fair means or fail I guess what do you do at the moment to do that well at the moment you use documentation or tribal knowledge or guesswork often in order to make make that happen um and and the pieces of the puzzle I suppose are the ones that are shown on the slide here right you you have an inventory you know what it is that makes up your network um but at the moment you might use a

cmdb for that or you might use a a a an Excel spreadsheet or you may have a a text file somewhere with with a list of all the devices in the network um every time a new device is installed all the ecomms uh then you have to go and make sure that’s kept up to date then of course you need the intended state for that device and that’s what we call configuration right that’s the the config file the templates um the backups of of what it is that that’s stored on those boxes in order to try and make the Box do the thing that you want it to now if you’re lucky

someone’s gone ahead and installed some tooling to allay enable you to track that or you may be using some of the features of Nautobot to do that the problem with config though is it’s only what you intend to happen on that device it’s not actually what that device is doing at a point in time um that state information that’s gathered on on a device is is impacted by the things around it it’s the networks are distributed system right there’s there’s routing protocols running and so on that make changes to devices without you even knowing so what you uh

what you configure isn’t necessarily going to give you the full detail of what you what you would expect to actually be seen on a device so you need to verify that now most people use monitoring tools for this capability right the ability to determine and say well is a device up is is an interface running how much data is passing through that how many errors are there on that but it doesn’t really give you the full sophistication you might need in order to work out is the device actually doing the thing you want it to then you’re going to need topology

information so you need to understand how those things are interconnected what the what those interfaces are doing if they’re Layer Three Links or layer 2 links um usually you’re going to have diagrams to do that and I know this is a huge part of every Network engineer’s job and probably their favorite pastime is sitting in Vizio drawing those diagrams out every time there’s a change um you’ll see what I’m getting at here there’s lots of different tooling and lots of fragmentation in the process that gives you that end-to-end view of the network so so

the point is that you can go through all these processes you can have all of this information for perhaps for one part of the network but then something else might be in somebody else’s head or another part of the network you might have really good data for and then that key part in the data center you might only have one or two people who have a good understanding and everyone else is is a bit of a black art the point with all of that is you’ve got different levels of data available you’ve got lots of gaps um and what ends up happening you fill the

gaps through logging into devices and pulling commands out and it’s really difficult to get that consistent view across the entire estate so if you can just go to the next slide please probably and sorry Paddy can you just go to the next slide sorry so what IP fabric is doing to to to fix this is basically doing a network discovery okay we log into those devices for you we take the Drudge out of gathering all the data from all of those devices and in the blue boxes here you can see the information We Gather from those those devices so we we complete

your inventory we capture the config and that state information and create what we call a snapshot of the network a point in time model of the behavior of the network from that snapshot we can then start to build upon that with the green boxes you see on the on the left the topology so the diagrams the visualization that basically replaces the need for for operational Vizio um and then allows you to ask some really really interesting questions of that end uh end-to-end Network and I’ll give you some examples of those now uh I’m just going to share my

screen so the first first question that I’ve got here is is really simple one which devices have I got where are they which code versions are they running so we’ve gone in we’ve discovered the network we’ve crawled through all the devices and we can very quickly identify um all of the devices where they physically are because we’re able to associate them with each other and and locations usually based on maybe based on hostname maybe based on an external data source that you’ve already got um or maybe just manually placed into into those sites we’ve got

information then uh about what code versions they’re running and so on so you’ve got all of the information you would often see in a monitoring tool here really simply but you’ll notice a whole bunch of this stuff is color coded and what that is is IP Fabrics it gives you an idea of the Assurance capability straight away here because what we’re doing is a color coding based on conditions so for example the uptime here you see is red or green if I hover over the the temples at top here you can see ones that are red are basically devices with that time of

less than a day so we’re able to build rules to say how you want to to be able to to color code these and you can filter those things based on um on those those rules as well like so so for example if I’m given a code version of a device a bunch of devices that I know is is bad and I want to go and find all the devices running it I can simply build a rule here 155t I’ve been told is a nightmare if I clip through on here then I’ve you can see the version column all of these are the 155t devices and those are the ones that I need to go and do something

about so very quick understanding of exactly what sits in that Network the next question you might want to ask is well what does my network actually look like I can see all the devices or what does it look like what IP Fabric’s now done here is taking all the information it’s gathered from the config from the state to build the topology so each line in this start in these diagrams here represents a relationship between devices if I zoom these slightly and show you in a bit more detail this head office location for example has a bunch of layer 3 switches

connected to some layer two switches um with what layer one and Layer Two adjacency so in this case if I just flip to the visualization setup here I can show you the layer one these green lines represent CDP or lldp okay I may not have that everywhere I may not be able to trust it so I’m just going to turn it off um I may want to dig more into the layer too uh the layer two I’ve got 55 spanning tree instances potentially across this diagram I’m able to just pick one of those out and visualize that and let’s turn off this mandatory neighbor relationship

and there you’ve got um a map of the the behavior of that VLAN in terms of forwarding blocking uh ports and the root switch the point here is is IP Fabrics delivering this visualization for you without you having to go draw new diagrams or fetch the information by hand because the information is there in the platform and in this case um you can see I’ve got a bunch of different Technologies here I’ve got this this Cisco stuff uh standard Catalyst switching I’ve got um Azure connecting up here so I’ve got uh Cloud instance here and I’ve got victeller sd1

as well so we don’t care about those um those vendors the the specifics what we care about is that their Network objects that we’re able to query them all information through and deliver that to uh to whoever Evers want to look at it and I want to drill down into more detail so in this case I’ve got a bunch of Technology tables here I can understand a bit more about how for example osps behaving on the left hand side I’ve got the ospref configuration I can see the interfaces where it’s configured I can see how costs are configured and so on on the right

hand side I’ve got the state information that’s been gathered at that point in time that relates to that relationship so you can see in this case well I’m I’m in a good good State here by the look of it because all of my ospf neighbors are in full state and if I look at the top viewer act confirms that but I do have something interesting here I’ve got a cost consistency Problem by the look of it so if I click through on here I can see very quickly I’ve got a firewall connecting to a switch and a switch connects into a firewall that’s got a mismatch of

of my ospf costs on the interfaces being able to to pin down those kinds of things quickly based on the state um is is something that that without having um a whole bunch of automation scripts to do is going to be a struggle IP fabric gathers that and it will give you that that capability very quickly just through being able to understand the data in these tables what that leads to is this capability which which is really bringing all of this information together because what I can now do is Trace from from an a uh end IP address to a b end IP address

through the entire network um through every step of the way so I’ve got a for example I’m going to start at this router pass through these switches across an mpls network uh through another site with a firewall my firewall is showing green so it’s passing the traffic through over a VPN tunnel out into Azure in this case and I can understand the forwarding Behavior at every step of the way and if if I really want to I can dig into the actual path and look at the packet headers and and so on all of the information is here in IB fabric to do that the other

aspect of that is of course that I’m doing this not just at one point in time I’m able to compare this between different points in time so for example in the snapshot I’m looking at the moment if I compare that with a couple of days later you’ll see that path has changed in this case my primary path failed and so this is my secondary path and you can see if I hover over the green here this is the New Path hover over the red that’s the old path so you can see the actual impact of that thing there and what what’s actually happened in the network as a

result of that and every single table across the uh the platform is enabled in the same way so that you’re able to gather that data and compare and contrast over points in time the other beauty of the platform is this that that this data is is great if you interactively but this is also available over API every single thing we look at here there’s an API endpoint documented within the platform to show that if you supply the appropriate payload and prod the appropriate API endpoint then you’re going to get the data that matches what you’re seeing in the

UI and that’s the same as data in the tables as it is with diagrams we can pull the diagrams out in exactly the same way we have the different uh API endpoints there for for if you want to export it to svgs and pngs or whatever or if you just want the Json data it’s all here and available just to prod and pull out of the platform which of course the API is the is the key to all of this and and certainly from a network automation standpoint because by by having access to that data over the API what you can do is incorporate all of the operations that

you’ve seen here into automation process you can you can update your documentation as part of your automation you can query that that information to help you build the workflow to say well I’m looking for all of the devices that are configured wrongly for SNMP or just come to open fabric we’ll tell you those and then you can go ahead and use that as the as the basis of your process you can create new snapshots and and update the documentation as part of the workflow so you’re not having to go manually do that afterwards so you’re you’re smoothing the

whole process along and um with the end-to-end path here for example you’re able to to basically validate that not just the individual tasks within a workflow are working but the workflow itself has the desired outcome the beauty of all of this of course is that that API is there and available and this is exactly what we’ve been working with with Paddy and and the guys at networks of code in really using to to develop a capability further um to do some interesting cool stuff right Bobby we’ve been having fun with this feel free to take the screen back

great thanks one second no okay so SSO T overview so we we touched on source of Truth earlier um and now we want to basically take a deeper look at it and what is ssot ssot basically is single source of Truth um and we know that sources of truths are abundant and organizations have different systems managing their network data that could be an ipam or a cmdb um and who owns the data that’s that’s obviously a a complex topic you know and it’s it often causes barriers to automation but it is important that the data flows between the systems um to support

automation so if we have a look at some examples of the types of data that can make up the intended State and these would be selected inventory as we see at the bottom here and the the DCM for your sort of location based stuff and then obviously the the ipam and circuit information that you would have but it can be difficult to maintain this authoritative data within a specific domain and it is crucial to have obviously one source of record for a given domain but duplication can happen across systems and then if it does you don’t know which one to trust

and if there’s a lack of trust then people are just ultimately not going to go to update that system so we find that an aggregation layer can really help in managing that data and it provides idea ideally it could provide a unified API and in that instance it could be a graphql API or it could be a rest API which is probably more standard but this helps in streamlining and this obviously supports automation so it streamlines the endpoints that you need to talk to and if you can provide that you can aggregate everything to one endpoint that can be really

useful for the automation engine in addition to that it can overlay additional metadata across these different domains and which can be really useful and and that can really support a really streamlined development for your automation systems so Nautobot offers an ssot framework and it has a plug-in for it and this is sort of a plugin that provides a baseline to allow you to build other Integrations on top of that so we have some existing Integrations which we went which we showed earlier for the applications and now what we can see is that there’s uh

there’s a lot of like apps that we can build to basically sync in and integrate uh other data from other systems back into Nautobot so this is the ETL bit which is the extract transform and load so take the data from the system do something with it and then load it into your into Nautobot today obviously we’re going to focus mainly on IP Fabric and this is the the application that we’re we’re going to show to you now basically the the Nautobot plugin ssot for IP Fabric and the use case here is that we were moving data from IP fabric into Nautobot and

that’s where that’s the sync Direction so we’re taking the observed data that IP fabric has and we’re using that to to basically build our source of Truth so um this is the demo that we’re going to look at is to try and populate our source of Truth um and that can be one of the biggest problems really is sort of getting started how do we get started how do you build your source of Truth so we’re going to leverage IP fabric to do that um and then in addition we’re going to show you how you can sort of run a diff between the snapshots that IP fabric takes

okay so we’ll jump over here to a local box this is sort of a Nautobot server that I have running on my laptop here so we don’t have any device it’s basically blank we don’t have any devices in it at least we shouldn’t and we’ve no IP addresses so what we’ll do is we’ll go over to the plugin section here um we didn’t touch in this earlier this is basically where we have our additional applications that we can load to provide uh like we said additional functionality for our Network automation use cases so we’re going to jump into single source of Truth

and we go to the dashboard here and here we have the different data sources so if we had multiple uh ssot applications we’d see them we only have one here at the moment which is IP fabric so this is like you say we’re going to sync data from IP fabric into Nautobot it shows us here sort of like a history of things that we had and on the right hand side it shows that history as well these are things that I had done previous um so we’re just going to jump in here and go with uh the the form data that we see here for a job so once we start once we click on

sync it gives us the form information that we can use before we can basically kick off the job to sync so we will select a snapshot and we’re going to select this snapshot here which is the day two it’s smaller than the others so it’ll basically be quicker and these input parameters here are more of safety mechanism so the only one we want to click here is the dry run we don’t want to run a dry run a dry run would basically mean that we don’t want to commit any of the changes into the database in our instance we do we want to take the data and we want

to store it in Nautobot execution we could we could schedule it but right now we only want to run this once okay so we click on run job so that’ll kick off and that’s us running a job which will basically connect out to IP fabric you can see here we’re starting the job with all of those input parameters that we we had set at loading the data in from IP Fabric and then loading the data in from Nautobot which is nothing it’s empty then it does a diff to basically calculate what’s the difference between the number of objects that it’s getting in from IP

Fabric and the number number of objects that it has in Nautobot okay the div summary here will basically tell us that okay well this we’re going to have to create six over 600 objects because all of that data that’s in IP fabric is not in Nautobot so if we’re going to pull it in that’s going to be the change okay so that’s going to take a few minutes so what we’ll do is we will go ahead down no I was just going to ask the question you’ve got um 600 and however many objects there and you’re probably going to cover this anyway but what are those objects

what is it that your data is you’re pulling across from from might be fabric exactly yeah so if we look in here we see this is ipfab this is the IP fabric that we’re connecting to and it’s Darren’s demo 8 server gives us a high level overview of some of the the attributes in there but the the important table that we care about here is the data mappings here right and the data mappings will show us exactly the objects that we’re going to sync in from IP fabric into Nautobot so we have device site interfaces IP addresses and vlans so there’s there’s quite

a bit that obviously of data that will come in the in these particular objects um there is obviously more that we could do um and I’m sort of thinking that on the back of the some of the plugins that we’ve released in the last couple of weeks is the bgp models and the firewall models they would be real good candidates to sort of take data from IP Fabric and basically populate those models and and the database for like our firewall rules and bgp config that sort of thing I think that would be really useful is that something that we could do in IP fabric

totally because that data is all there so you know we’re scraping all of the the that config but the state data as well so we’re able to put all that through for security policies for empirical operation things like VX Lan overlays and all of these kinds of things you know it’s all all that data is there so there’s no reason why um you couldn’t bring that across there’s some interesting um I’m just just looking at the Q a and the chat here and the similar similar themes about the idea of of um the the kind of the difference I suppose in the data right

so because you’re using Nautobot as this intended source of Truth um what IP Fabric’s doing is providing that operational State and it’s there’s some interest there’s always some interesting questions and we’ve talked about this one before right about uh how often you use that data to to synchronize from one to the other and how you then use it thereafter um you know when when changes are made so uh I don’t know if that’s something we can we can touch on as well yeah yeah and that’s that’s a it’s an interesting point because really this sort of this

demo that we’re looking at here is sort of touching on the initial sync because it’s to say Okay I want to build a source of truth but how do I do it and that can take a long time just to to find out the information in the network because it’s coming from lots of different sources and most most organizations probably would say that the the network is actually the source of Truth at the moment right so then you could use IP fabric to discover the network and model it and have an API that you can use to query it once you do that then now what we’re saying

is okay now I can pull that data in to Nautobot and then start to build my intent from there and then use that data then to start uh provisioning or automating some of the process around how you manage your network and that that’s the key thing that we’re trying to do here and I guess I guess I’d be Christians such something in the chat as well here already that that once you once you’re then going back to the network to see what’s changed you’ve got the ability in a dry run for example I guess too exactly to do exactly that right yeah exactly so um

yeah we can show that so what we’ll do this one’s completed which is great took about four minutes um and let’s just check on the ssot sync details uh okay so it’s created over 600 objects um and we can see here the the basic uh diff and obviously it’s going to be pretty much all green here because there was nothing in Nautobot before so it goes through and shows us exactly what’s been created from a device perspective and an interface and further down we probably see vlans it’s probably easier to see on this screen because it’s uh rather than a diff

you can actually just go in and check the devices so now we have all of the uh devices that we’ve learned in and we’ve created roles for them we have our status and we have the different types and also the sites and the IP addresses so now we’ve basically um provisioned or started to import the data and to start building our intent uh in our Network source to choose again we had lots of IP addresses here um and all of that data is in there so on that point though what we could do is to say yeah well if you wanted to now that we have it in the data is in

there if we wanted to sync against another snapshot and we could just check to see what the difference is between those so we we could run a dry run as Darren has said um and we’ve selected different snapshot this time which has slightly different data and what we can do is if we run that we can see what the difference is between us so that could be if you basically made a change or you made a widespread change across the network and you wanted to check between those snapshots um it would be able to load all the data and tell you what the difference

would be so it’s essentially doing a diff on your network to see what the changes would be and if we we could see at a high level what the summary is there to so that it would create an additional 300 objects and it would obviously make some updates and remove some things if we go into the sync details it gives us a like a low level look and a detail look at exactly what’s changed so in this instance the device has changed its uh its management IP so it used to be zero two and now it’s zero two one and we can see that some other interfaces have been

added in and then obviously quite a lot of data and a couple of things have been removed yeah new devices uh yeah so that’s a a new PE gone in there as well yeah so it’s it’s yeah we can run it in dry run and see what would change before actually committing the data and that’s uh that’s the value of adding the dry run there to make sure that uh if you can check the data and see and that you’re happy and then you can import it okay I think that is uh not so let’s jump over to the ChatOps overview um so another application that we have within the Nautobot

ecosystem is the ChatOps framework and this provides basically a multi-platform uh chat bot that can be used to integrate into other systems or external systems or it can be used to just run different jobs within your source of Truth so it’s it’s quite extensible and really is very flexible in terms of what you need to do um the chat application itself obviously it like is is very common within Enterprises so providing with a new interface into network data to an existing application it’s quite powerful you don’t have to vet the the application and

you’re just basically running the additional functionality through the chat application that everybody has access to so what we’re going to cover today really is the IP fabric ChatOps application that we’ve built okay then it uses the there’s a ChatOps framework as well and that allows us to to build on top and that gives us that multi-platform capability um here we see the existing commands that we have for our IP fabric Chapel um and obviously the real value here is that we get to create your own commands you don’t have to use only these commands here

you can extend that you can basically create your own commands that would have something that would be useful for your environment like we said it could interact with multiple systems we could do lots of different things and basically you give you the capability to sort of aggregate and transform and display information and and and display it back to the user within a chat window so it’s it’s really really powerful expose some self-service capabilities to other teams something that you may normally get a ticket for and now you can sort of to create a

chaff command for that and rather than having to to dig into the network and and do some troubleshooting or some uh some investigation on certain uh some certain issues that users can have you can expose that functionality as a chat command and that basically gives that capability for other teams to access the network and see data within the network and that’s the key thing so in terms of the demo what we’d like to look at really is sort of um the chat commands some of the commands that we’ve shown there we want to basically get some connectivity

information for a host uh we’ll have a look at sort of bgp peering details which is a big one for a lot of organizations and then um a local path obviously the trace through a network and being able to having a source and destination IP and and finding out what the path is okay and here’s a high level overview of how this would sort of look and what the components so you’d have your chat window on one side and making a web request back into your your chat platform whatever that might be could be slack teams WebEx uh that then will talk to your chatbot

server which should be on the Note robot side and that then will uh initiate uh requests out to IP fabric to pull back in the data do something with it and then display it back into the chat window so let me jump over to my chat application uh let me do this type of fabric okay so if we do a slash IP fabric gives us the main command and this shows us all of the different options that we have and first option that we would do is we would set our snapshot so we set snapshot might be fabric said snapshot now we want to go to snapshot 2 this was the one

that we had selected and basically that will set it that’s it the context for any of the other commands then that we’re going to do because we’re going to query against that specific snapshot on IP fabric okay so let’s let’s try and find a host so for us if we have uh quite a useful command really for for anything not just for Network Engineers could be security uh security team or any other team so the computer storage team that need to find out where a particular host is connecting on to the network this is quite useful for for those teams and to

expose that capability to other teams so if we do find host we select IP here and we should get a little window like that and let me get my IP and if I enter in my IP it’s a query IP Fabric and it’ll get back the the details that we get for that particular host and what site it’s in and it’ll also show us the Gateway or the switch that it’s connecting onto and the interface and give us some host information with the MAC address so this is quite a common one down doesn’t it this is something that’s yeah obviously you know it’s that whole thing of of how

do you track down where where someone’s connected it’s that troll through the network looking for MAC address tables and spanning tree and uh and and ARP entries and that good stuff right so it it it’s a really useful uh corner to cut really I suppose it’s uh it gives you it gives you an instant response yeah so let’s check uh if we also had um Network changes if we wanted to check on our Roofing updates we’ll check if there was right now we have supported that we want to check uh if there’s bgp uh peering relationships uh and where what status they’re

in for a particular device so if we just click IP fabric routing we’ll get the selected device so if we selected a PE device uh do we have a PE device we should have one um yeah it isn’t there yeah let me select pgp neighbors so here we’d basically get back to say what type of State we want to go in um now we normally when we’re doing a change pre-change or a pre-check or a post check we don’t really care about the established ones sometimes you want to know which ones are not which ones are not connecting so if we select active here we would see um we

have two devices that are active and this can be very useful just to to consolidate that sort of information not get a huge output of all the all of the bgp peers that aren’t actually and that are actually connected with a lot of information here it just gives us a quick hit on the status of these particular uh connections and their endpoints and the vrf that they’re connected on so the beauty of that one as well is is is that you’re getting the configuration but also that that that state right so you’re checking on the state within that snapshot of of

what’s going on and that total received prefixes column right always a useful thing if you’ve got an established peer but you’re not receiving prefixes then that is not going to be very helpful when you fail over to that link and you’re not going to be able to shoot anywhere right that’s it okay last one that we wanted to check was really if we wanted to trace through uh a network and so we wanted to we have a source and destination AP somebody is basically a ticketless command or something or you want to basically quickly check what a path is so we

have a command that would allow us to do a path lookup um and let’s get some we’re using that uh demo or day two so let’s get source and destination IPS and now what we want to do as an engineer is just basically do a uh like a like a trace route I guess but we would while IPP fabric gives us is the capability to have a visual representation of how that would look across the network with the components and the notes that are in place so we have a the command that we will enter is just the path lookup we give our source to the destination IP and we want

to look across a specific protocol in this case https so once we issue the command we get back the uh the diagram and we can see here it is it’s very easy to see the path from source to destination right so we say it’s coming in on the left hand side and the router coming across our Colo a couple of switches hitting into the mpls on the PE and then it’s um into the head office and seems to be hitting a switch and then it looks like it’s hitting a firewall um do we need it do we need to know anything else with that firewall the farm was right right so

what that’s actually telling you is that the file was not passing the traffic um on towards our destination right so what you’ve what you’ve got there is an application that you’ve run that you want to run on the network and won’t work right now right because that firewall is uh is causing you a problem so um maybe if you have a look at say icmp through the same uh same source and destination and we can have a look at the path okay so if we do a path we also have another command which is the path look up icmp and here we have our today’s uh actually we

can just do it like this and then we’re good so first destination appear let’s give me the same one so last time we checked it was https now we’re going to check and see if icmp is going to pass through that firewall does it look any different and there’s this that’s something that we can check here echo echo reply that’s probably okay let’s check that one ah okay here we go yeah okay yeah so now we see the firewall is green so it’s obviously it’s passing icmp traffic and it’s allowing us through to the cloud and our destination is in uh Azure um yeah

so there you go so so the the next sort of uh the next action action on that I guess is then to go back to IP fabric um itself have a look at that firewall you can dig into the security policy that’s actually causing that to fail right so we can actually show you that show you the exact point where that is and so then it becomes a query to the to the security team to go to go deploy the appropriate policy but yeah you can you can give that to I don’t know a server uh a server team or application team who want to be able to deploy an application they can

do a quick check to say well if I deploy it will it work and if it won’t work why won’t it work and if they can narrow down quickly that it’s a firewall that’s causing the problem they don’t need to engage anyone from the network team they can just go straight to the security team and saying look there’s some security policy here that’s stopping my application working can you fix it please yeah which is really useful to be able to see that right and then have it available in a chat command is is really powerful that you can just run to share the

information across all the people who need it I mean that’s the other thing you don’t have to sit and wait for a network uh the network team to go and find that information out for you sir exactly great okay I think I think that’s all we had and so I apologize Tim I think we ran slightly over there I had a lot of connectivity issues so I apologies but that’s all good uh we have a couple of quick questions uh maybe we can just chat about live here and uh we’ll go maybe just a few minutes over uh one question uh getting back to the uh single source of

Truth idea and using IP fabric um supposing you know you have an environment where I’m not going to automate all the things all at once which is you know everybody’s environment right you can’t do all the things all at once so what do I do where I have a scenario where I’ve got some portion of my network automated and I’m driving that from my source of truth from not above and I have some portion of my network that is not automated and I’m getting that actual state from IP Fabric and let’s say I want to sync those two things how do I deal with that

problem of you know some of it’s coming in from IP fabric with actual data from the network versus I’m driving intent from from Nautobot into some other portion of the network um a really good question um shall I start yeah sure okay so yeah I mean we always talk about IP fabric as being that that observed truth if you like the the operational State and and from that perspective you’re always going to want the the Brownfield the the everything that’s in the network you’re going to want that nip fabric because the real value comes from having this this

end-to-end view of the whole network um there’s a couple of ways of of dealing with with that situation I guess you could in in IP fabric you can create um smaller snapshots of just the areas uh that are that you’re running the automation for for example so you could you could simply gather a separate snapshot of the state that’s that’s being built through the automation platform and then just synchronize that back because the other point here is that that we’ve and we’ve talked about this um the diffs Inc one of the things that we’ve also talked about

with the team is is looking at conditional um conditional synchronization so being able to filter the things that you want to synchronize back into in Nautobot I think that is um you know certainly something that we’ll we’ll hope to to develop further as we continue in the conversation because it’s this is relevant to not just um data coming from IP fabric this is coming from any external Source into the ssot database I think that’s fair paddy yeah yeah and uh one thing I’ll add to that is that we we do have the capability to add a site filter for um

for data that’s coming in from IP Fabric and it will only sync for a specific site we didn’t know about uh but that’s the capability that we have right now and as Darren mentions we are looking at ways to basically get a more granular control uh on a the models and then B the attributes sinking across as well great thank you for that uh and that actually uh is the last question that we have here outstanding that I’m aware of uh so with that uh thank you Paddy thank you Darren for this uh great discussion and presentation today and with that thank you again to all of our attendees of course thanks for joining and listening in great thank you thank you very much