Keith Byette
00:00:00
Let’s go ahead and dive in. So hello everybody and welcome to today’s webinar hosted jointly by Network to Code and Arista. And we’re thrilled to have you all here today. What are we going to do today? We are going to talk about modern network life cycle. So from design to automated operations. Network automation isn’t just a buzzword anymore. It’s essential for scaling operations. It reduces human error and building resilient infrastructure. So today we’re going to bridge that gap between initial network design and day two automations operations. So let’s take a look at our agenda this is what we’ll be covering today.
First, who we are, so we’ll start with a brief introduction to set the stage and introduce the teams the background, Next, we’ll dive into the context, explore the key industry challenges, why modernizing network operation has become so critical, the steps and the flows. So from there, we’ll map out the actual lifecycle process detailing specific steps, the end-to-end workflow from the initial design through implementation. Why, the why behind it, we’ll take a look at under the hood as why this approach works discussing the core benefits, design discussions, and strategic goals driving this operation model.
And then the demo, the fun part, the best part, the live demonstration where we show you all of this in action. So here’s the speakers. Let me do the quick introduction and I’ll do it for everybody. Well, first it’s me. That’s me, Keith Byette, territory account manager for Arista Networks. Second, Phil Bureau, Advanced Services Engineer at Arista, who works directly in the front lines, helping customers design and operationalized modern Arista environments. And then joining Phil will be Brad Haas, SVP of services at Network to Code. Brad brings deep expertise in helping enterprise teams transform their network automation strategies.
All right, my fun part is. All right, let’s talk a little bit about Arista. So to really understand where Arista sits in the enterprise landscape today, it helps to kind of hop in the time machine and do a little timeline behind the making of Arista’s decade. So over the past decade plus, Arista has grown from an innovator into a powerhouse, now serving over 10,000 customers with over 150 million ports shipped globally. I’ll call out a few cool key dates on this slide here.
So going public from 2014, Arista quickly quickly disrupted the status quo by introducing CloudVision in 2015 expanding into any cloud architectures and being added to the S&P 500 by 2018. Take a peek, capturing the number one market share position in data center switching by 2024, while also expanding into high speed 400, 800 gig platforms and pioneering AI networking architectures. All the way to the right, reaching 9 billion in revenue, doing some acquiring with Velo Cloud SD-WAN. So with that, Arista’s built really a complete unified networking ecosystem across data centers, routing campus and branch edge environments.
So when you choose, when people choose Arista for their network life cycle, you aren’t just buying hardware, you’re partnering with an industry leader with a proven track record of rapid innovation and reliable scale. So why do people choose Arista? Here’s some of the key things. We call them the six pillars, right? So high availability. Arista’s EOS is built on a unique state driven, publish, subscribe architecture. If a process even encounters an issue, the system automatically recovers that specific agent without crashing the switch. So it yields a defective rate under 1%. So that’s maximum uptime, zero time, and zero downtime for upgrades.
So who you gonna call, right? Top tier support. When you need help, you don’t just get passed through script readers tier one. So every single tech engineer who answers the call is an Arista badge level three engineer who will own that case from start to finish. The level of service is why our net promoter score is at an industry leading 9.5 out of 10. Another reason, open standards. So there’s zero proprietary vendor lock-in, everything fully open standards, networking that integrates seamlessly with the existing infrastructure lower total costs.
So between simplified licensing, perpetual options, and massive reduced operational overhead, Arista keeps costs predictable and efficient. Another reason, our single operating system. So unlike other vendors, Arista runs one single Linux binary image across all platforms. So from top to rack data switches to campus devices, it’s one OS to learn, manage and upgrade. And then, Arista is built for automation. CloudVision was built from modern NetOps with real-time state streaming and multi-domain automation through CloudVision. So it really provides an ideal foundation for automated life cycle management.
What I will do now to do a deeper dive into how all this works, you really kind of in practice, let’s talk about Arista AVD, which stands for architecture validate deploy and to walk us through that. Phil, I’m going to pass the microphone over to you. It
Philippe Bureau
00:05:49
Sounds good. Yeah, I’ll give you a brief overview of what AVD is. Like you said, it stands for Architect, Validate, and Deploy. It is at its core just a data driven automation framework that allows you to manage your network as code. It’s an open source project. It’s available on GitHub. Go ahead and check it out. It is a Python library, but we also package or distribute a certified Ansible collection that act as a wrapper around it to make it more user-friendly. This is available both on Galaxy and Ansible Automation Hub. AVD is not just a flavor of the month at Arista, or something that’s shiny for 15 minutes. It’s six years strong.
Like I said, it’s been, there’s a lot of effort. And if you look at the slide here, you can see it’s consistently being worked on. It’s not something that we just look at once in a while. Huge shout out to Carl Buchmann who started this project many years ago and published it around six years ago. Next slide, please. All right, so like I said, basically if it is expecting input in YAML and the YAML data model that we created is opinionated and abstracted. What we mean by abstracted data model is it allows you to express network-wide intent as opposed to device per device configuration.
The opinionated portion of the data model means we started from Arista’s design guides, we took all the recommended values and made those the default values in AVD. They’re still tunable but by default, as soon as you start using AVD, you get all the best practices from Arista included in the data model. Another key factor is even though this is an open source project, we put our tech behind it. And this is not common in the market rate. A lot of open source project out there are not supported. Arista, we believe in this project, so we support it with our tech. AVD is not a GUI-driven tool.
So our approach is to partner with the best in the industry, such as Nautobot to provide a custom UI experience where you can drive input for AVD if you so wish. It is not just a configuration generation tool. The workflow goes way beyond that. AVD will generate documentation, obviously the configuration. It allows you to deploy the configuration and also validate that your actual intent is working in the network. And it enables Digital Twin by creating Digital Twin topology files. We’ll see all of that stuff in the demo portion. AVD also builds offline.
It doesn’t require hardware to be present to be able to render the configuration, but it will render your entire CLI that you can review before you deploy. So you can really disconnect the intent generation and the deployment. And finally, automation, even though it gives you speed and scale our approach is that this is actually just unlocking configuration accuracy and removing risk from your operation. So de-risking is in our opinion, one of the major part of– the automation. I’ll give it up to you
Brad Haas
00:09:10
All right, thanks so much, Phil. So I’m just gonna quickly give a little background about Network to Code. And, you know how we’ve come to take a better together approach between Arista’s AVD solution and Nautobot. I think you saw it on what Keith was saying there. Arista is really built for automation and Nautobot and Network to Code have been in the automation history for 10 plus years as a company.
Nautobot’s six years, I think, believe now, we’re trusted across lots of Fortune 100 large enterprises, Gartner recognized around NetDevOps and network automation and just one of the faster growing automation companies around network automation platform. An overview of Nautobot just to give you a little background if you’re new to it. And I know I recognize some faces in the crowd there that are people who are using Nautobot already. So Nautobot is a network source of truth. It’s built purposely to represent real world modeling of networks. So what does that mean?
It essentially means that we can store things like inventory of devices, it could be locations, circuits, circuit providers, cabling even, IP address management, VLANs, anything you can think of that’s network related and beyond inclusive of metadata around that network can be stored in the source of truth. Now we’ve also got an ecosystem of applications that help on the automation side. In addition to the data, we take a data-driven approach to network automation.
And so you can see some of the examples, and we’re going to demonstrate this shortly, where all of these applications work together in harmony to take the best of the two solutions with Arista’s AVD and Nautobot, put them together, and have a full end-to-end solution from the point of– your architectural design all the way to day two operations when you’re making a change to the network. And we have proven results. We’ve been working, as I mentioned, in the industry for 10 plus years and have some great customer success stories. You can check out the Network to Code website and see some of those success stories.
So with that, let’s jump into the background about what we’re gonna show today. We’re taking this new approach to networking, which we call modern life cycle. And let me just kind of set the stage on why we think this is important. So changing things on the network is still hard, right? And we always start with the best of intentions. You have a network architect who is probably putting together a design document based on some business objectives. Maybe there’s a new site or a new data center that needs to be deployed. And that design is represented in the beginning with the best of intentions.
And you can kind of see Jamie over here, who’s got a new fabric design and it’s perfect. So what could possibly go wrong? Well, hey, two weeks later, we’re going to start building this. And the immediate question is, what IP addresses are we assigning to this new year? And do I have the right version even, right? And oftentimes, we see this done in spreadsheets or other systems that are disjointed and fragmented across an organization. Then you’ve got Riley here, who’s our field technician, who’s expected to deploy this new data center fabric into the data center. And he’s got a copy of the spreadsheet that he thinks is accurate.
But then when he goes to actually start installing it, he starts to realize that, oh, the leaf switches got a special configuration where the wiring isn’t what he expected. And so you can see he’s super nervous about going into that data center and doing the installation. Sam is asked to get this thing operational and tested before deploying to production, but he doesn’t have a proper lab environment. The production environment is a lab. Jamie on the night of the cutover, you can see it’s 2:50 in the morning.
He’s been at it all night after Riley’s racked and stacked everything, now it’s time to prove that it’s working and it’s operationally successful. He’s logging into dozens of devices, running dozens of show commands taking screenshots of them, copying them into a ticket very stressful night and as you can see he’s not happy. And then lastly, six months later, Sam is looking at the network diagram and the design that was started by Jamie. And he’s not sure it’s even still accurate. So not only is he not confident about the network configuration matching the intent, he’s not even sure if the documentation matches.
So how do we solve this problem? So, you know, I know we talk about network automation and oftentimes we think of that as generating configurations, but it can be so much more. And that’s what we’re gonna show here. So we’re gonna treat a network deployment just like creating a software release. So if you’re familiar with the software lifecycle, you know, you have one single place to represent the code and, you know, oftentimes that’s GitHub. Your configuration is the code, you’re running unit tests against it, and then you’re creating and stamping releases.
And those releases have been validated and through the ringer before they make it to production. So we’re going to do that with the network here and show how that works. So what that flow actually looks like is this. So you can see we’re taking the entire life cycle from intent to production. And you can read this from left to right. So as I mentioned, Jamie has created this design that design needs to get turned into a specification or a template. So what we’re going to do as part of the demonstration is use a Nautobot Design Builder application to do that and to represent the design.
From there, we’re going to integrate with Arista’s AVD solution. We’re going to have Nautobot send the inputs to Arista AVD and trigger a workflow that then goes and deploys and tests this into Digital Twin. Digital Twin is running Containerlab in Digital Ocean for our demonstration, but could be hosted on whatever infrastructure you have available. We’re also going to leverage Arista’s ANTA solution, which we’ll talk about shortly once we get into the demonstration. And that’s a way to do validation of your operational state.
From there, we’ll cut a release just like I mentioned, we’re gonna treat the network as software, we’re gonna release a version of software or a version of the network using an integration between Nautobot and GitHub, and that’s going to trigger a change control inside CloudVision. So tight integration with Arista’s CloudVision. And then. Ultimately, once that gets put into production, we’re going to leverage Nautobot’s operational compliance feature to take a snapshot of that production network. And the operational state will get stamped in time. This is what the operational state of this environment looks like at this moment.
So when we go back and do a change later on– we can compare the operational state between the two releases. And then lastly, we’re going to keep everything in sync using Nautobot’s single source of truth connector, which is tied to CloudVision and will synchronize the data right back to Nautobot all through this flow, we’re gonna keep the documentation up to date as we go. We’re gonna leverage. GitHub pull requests to do our release management and to maintain a human in the loop. We’re gonna do tests as in validation. We’ll even have release notes just like software in a generate a report of what’s changed in the environment.
I was just about ready to jump into the demo here. So just to kind of– show you what exactly we’re going to do. So we’re going to create a brand new data center fabric the one that Jamie designed. We’ll call it DC1. And that is we’re going to do a version 1.0 release. And so you can see the top row here. We’ll create that release. We’ll leverage that integration between Containerlab and GitHub to test and validate that. We’ll merge it in when Phil and I are going to talk about it and make sure that we’re feeling good about the changes and that it’s been validated successfully.
We’ll promote that to production, leveraging Nautobot’s integration to CloudVision, and then ultimately use the operational compliance to take that snapshot of the baseline version 1.0 operational state of the network. Then we’ll make a change. So this is our day two operations. We’ll add a new tenant of VRF into the network. We’ll run through the cycle again and promote it to production and we’ll be able to generate that change report and then we’ll, you know, ultimately show how this new workflow all fits together at the end. All right, Phil, so I think we’re at demo time.
So let’s go ahead and build out that data center fabric that we were talking to, talking about. I’m going to go ahead and switch over to Nautobot and just give a quick overview of Nautobot here. So this is the dashboard view inside of Nautobot. And you can see all sorts of information in here like locations and tenants, racks and other such things that represent your network. So we’re gonna go ahead and start with the design. So here you’re gonna see in Nautobot the design view and these are the templates for the design that we’ve integrated through AVD and brought them in. So there’s two designs that we have templated out inside of Nautobot.
We have the campus branch and then we have a data center fabric. You can see a brief description here in this view, but when I click into it, You’ll see a lot more documentation around this particular design specifically. This is a data center fabric that’s got EVPN and VXLAN that we’re planning to deploy. Spine leaf architecture with a couple server hosts that will be dual-homed in their racks. It’s underlay is deployed per Arista’s best practices as well as the EVPN overlay network. A couple of other things to point out is that we’re going to deploy some network services and each tenant is going to get a VRF with a few tags here.
In our case, we’ll have a blue VRF and a green VRF to start. And we have red as an option, but as part of the demo, we’re going to show you that later because we want to be able to illustrate– not just the initial deployment and config generation, but also what it looks like when you actually make a change to the network. And we’re going to do all of this through– something called a Nautobot Job. Nautobot Jobs are simply think of them as a lightweight automation. So, Nautobot can hold data and is a source of truth for data, but it’s also a powerful automation platform as well, network automation platform.
So there’s several jobs here and I’ve put numbers on them just to illustrate the flow of what we’re about to show. So we’ve got the data center fabric which is our design builder job that’s going to deploy the objects inside Nautobot. Then we’re going to take that and deploy it to our digital twin solution. In our case, we’re integrated to Containerlab. And then that is also going to trigger a pull request inside of GitHub, which is leveraging Nautobot’s integration to GitHub on Phil and I will review that. And if all looks good, we’ll merge it and promote to production.
And then we’ll run through that reconciliation steps here, these two last steps. So with that, I’m going to go ahead.
Philippe Bureau
00:22:24
And before we start, can we look at the device inventory, just to make sure there’s nothing and then we can see the compare afterwards.
Brad Haas
00:22:30
That’s a great call. So we are starting from an empty Nautobot instance. So here you can see I don’t have any devices configured yet in the system. And then we do have a little bit of boilerplate around the location and the location hierarchies. So we have two major locations, Europe and North America. And so our team that’s doing the network deployment has been asked to deploy a new fabric inside the New York location, which is their primary data center campus. So as part of our deployment, what you’ll see here is a change that happens inside the New York location. Thanks, Phil.
All right, so with that, we’ll go to our first job inside Nautobot, which is a data center fabric. So what you’re seeing here is the codification of the AVD inputs. So we can do things like make small updates to in our case, maybe you want to change the number of spines or number of leaves that are part of this fabric so I can increment that. And that will change the actual deployment just by changing the inputs. And I have it set up so that I can’t go above four just to illustrate that we have a way to control that on the input level through Design Builder through schema.
So I’m going to go ahead and just leave that at two for ease of deployment. Also, I’ve pre-populated some of these with prefix and BGP information. That’s another thing that Design Builder gives you the capability of which is to have same defaults to start, but you can override and type things in as needed. And we are going to deploy to our New York location, as I mentioned. So I will go ahead and select New York. Other things you can change, device types for the different roles and such. And then lastly, the tenant networks. So just quickly point out, we have the blue and the green networks ready to deploy.
And we do have that option for red, which I’m going to hold off on doing as our initial deployment. We’ll go ahead and kick that job off. And what’s happening under the hood here is Nautobot’s taking that design template and creating the objects inside of Nautobot, as well as the as well as the intended state file artifacts that are going to drive the automation here in just a moment. So you can see several YAML files here. Some of these are the Design Builder templates, but others are the AVD files that will drive the automation through our GitHub integration. If I scroll down, you can see the log of every change that happened.
So since this is the initial deployment, most of them are create just a few updates there, which you can see, and then a summary at the end showing all of the things that were planned as part of this new data center fabric. I’m going to go ahead and just show you inside of the location list now. We have a new location called DC1. This is what we just deployed through our design template and that is a child of the New York location.
So if I click on that location now, You’ll see, not only have I created those intended state config artifacts, we’ve also put information about the network that isn’t necessarily configuration related like racks or IP prefix ranges in VLANs, things that are associated with the configuration and maybe the physical deployment itself. We can actually also show here in Nautobot the rack elevations for what’s planned to be deployed. So the design template included these racks. So these did not exist before they were created as part of that design template.
And you can see we also have the device types in their front and rear images here that we can show as part of this as well. Just to illustrate, Nautobot’s got more than just configuration information. It also has the physical plan. Lastly, just before I move on to the next automation job, I do want to point out that we are also capturing the logical topology here as well. So you can see we have our spine-leaf architecture in the logical topology view too. All right, with that, so let’s. Continue with our flow. The next thing that we talked about doing when we showed you the workflow is to deploy that– Configurations to a safe environment.
So we have a digital twin. Containerlab environment that’s set up and we’re going to demonstrate the integration with git here as well. So when I run this job you’ll see at the top here several check boxes going through a workflow. This is a native Nautobot capability in the Nautobot Professional release called Job Chaining that was recently released. And the first thing I did here was create a few design artifacts or reports, which I’ll show you in just a moment. And as we’re talking, Nautobot is reaching out to Containerlab and provisioning and downloading the images, the cEOS images to the Containerlab environment.
So that’ll take a few minutes. So while we wait for that– I’m going to go ahead and show you what reports we have just generated. So let me go ahead to the Nautobot Insights and Reports.
Philippe Bureau
00:28:38
And just to clarify, Brad, the Containerlab environment was available, wasn’t pre-deployed. It’s being deployed through that job. The topology file was generated through the job and it’s generated based on our intent. So if we were to change the design template entries that topology file would also be modified and updated and available to be built as a digital twin. So everything is dynamic. It’s not something you have to build ahead of time
Brad Haas
00:29:06
That’s right. And you’ll see a little bit more of that here when we go to the GitHub repository as well to illustrate what you’re talking about, Phil. But yeah, absolutely. So here are the two reports that we are publishing as part of that job. The first one is the design document. So your network architect Jamie most certainly has to create a design document illustrating what was selected or chosen when the design was minted. So here we can see all the inputs that were selected. We can see the number of leafs that were chosen and the specific tenants that we selected as well. Additionally, we’re seeing everything that’s changed.
In this case, mostly additions. IP ranges prefixes, VRFs, VLANs, everything you would need for that implementation to configure these all of the devices, their IP assignments, and so on. In addition to that, If you remember, We had our friends. Riley, who’s responsible for rack and stack. And he’s sweated in the past because he’s following some outdated spreadsheet and he has very little confidence in let’s help solve Riley’s problem. So I’m gonna just show you we’ve created in addition to the design document, a field installation guide.
This guide is showing you not just the logical implementation details that you saw in the design, but also the physical implementation details. So here we can see we have the three racks. There are 42U, four post cabinets. How many devices per rack? what needs to be set up or installed into each rack and what rack unit they need to be installed to pictures of the devices so that there’s no mistake as that work is being performed. And then of course the cut sheet on what gets plugged in where. So you can see the dual homing of DC1 host one. This is the server being dual home to the two leaves and so on and so forth.
And you can see we’ve even captured through the design and Nautobot the types of cables that are gonna be used for the different parts of the network topology. All right, so with that, I’m going to go back to the job. We’ll see how it’s doing. Looks like the job is completed. Yeah, so we have deployed our digital twin and we’ll see this last step here. We’ve published a pull request in the GitHub. I’m going to go ahead here to our sister. Repository inside of GitHub. This is where all the AVD magic is going to happen. And you can see here on pull request.
I do have a pull request that is pending and it says “Validate and published data center 1 or DC1.” and so from here, I’m gonna hand it over to Phil to talk through what you’re seeing. So go ahead, Phil. Let’s.
Philippe Bureau
00:32:19
So if we think back a couple of minutes ago, Brad was filling the form in the design form with some data, the number of switches, a pool of IP addresses, so on and so forth the form took this input and actually generated the AVD YAML inputs that are expected for AVD data model to run. When the AVD build phase was executed part of that pipeline, it generated all of the artifacts that are required to deploy our configuration. So we can see here in the commit history, the validate and publish DC1 was the first commit where we created our files. And the build phase is where that happen.
So yeah, if we click on that commit we should be able to see the files changed exactly. So first under the devices, we can see the documentation. So the MD file. Those are markdown files, documentation rendered by AVD. So we do device-specific documentation and fabric-wide documentation. If you click on the rendered rich format we should see what this would look like. Yep. So basically we have a nice documentation. Again, this goes into your repository on top of what Nautobot generates in its own system, but that gets versionized in the repo as well. If you scroll down on the left, the more important bit is the.cfg file.
So this is what network engineers really want. So this is full switch configuration fully rendered by software. This is not prone to typos and human error. It will always render consistently all your switch configuration. Again, network engineers can relate and review that configuration the great part about the way AVD is built is it can build configuration offline like I mentioned earlier. It doesn’t need the devices. It can render that configuration for review before you move forward in the chain. And this is what we’ve done with the pipeline.
We obviously made that pipeline more efficient where if we go back and check the PR, if you could go back to PR, let’s check the series of commit. So that was AVD building the configuration and the documentation. But there’s another commit that we built as a pipeline job where. This is when it pushed the configuration to the digital twin. Well. Nautobot created the Digital Twin, AVD pushed the configuration to that Digital Twin. Let’s go ahead and check the content here.
And we can see that– Not a whole lot of number of files were changed here, but the important bit is you see the AVD catalogs part of pushing while the pipeline we built is we pushed the config, but we also ran the AVD validation phase. So AVD from the same inputs that were generated by Nautobot automatically wrote test cases for every feature we define. As an example, If we declare a BGP peer, if you will write the test to make sure the BGP peer is established. If you create a connection, it will look at it, connect on the switch, write the test to check LLDP to make sure it’s connected to the right peer.
And we do this for everything there’s hundreds of tests that can be automatically written and executed the whole thing will generate a nice looking report. And we actually build the pipeline here to print the report back into the PR. So here we have the result of those tests. So again, build– Deploy and the digital twin, test the digital twin to verify that our intent is actually working, not just that the configuration was accepted successfully. So here we see there’s many categories of tests that were executed against each devices and the state of these tests out. This is all green as far as I can see, there is no failure.
So this looks good. So now we have fully tested our proposed new data center in a virtual environment. So that gives us a huge level of confidence that when we push this production, this will be seamless deployment. How do you feel Brad? Do you think we should go ahead and push this product?
Brad Haas
00:36:27
Phil, I see lots of green check boxes, so I think we’re good to go. Let’s go ahead and merge this. We go ahead and click merge here on the pull request. And so what this is doing is committing these changes and preparing them for us to promote to production. So this is thinking of this as the human in the loop approving the changes. We’ve got all of these checks and balances that have occurred, and we’re feeling very confident that this deployment will go well. So we’ll come back to Nautobot now and go back to our next step here, which is to promote this to production. So I’m going to go ahead here to the third job and a simple job.
We’re just going to select the deployment that we created earlier for Data Center 1 or DC1 at New York location. So I’ve selected it and I’m ready to promote. So go ahead and run this job now. So here you’re gonna see we’re doing a quick preflight check against GitHub just to make sure that GitHub is operational and that our pull request has been merged. And then as I scroll down here, you kind of see a little bit of a. A log? as it– Talks to CloudVision. All these changes, so you can see we’ve minted a fresh token for CVaaS and are starting to do the actual provisioning. Let’s go and see if we can catch this in action.
Philippe Bureau
00:38:00
Alright, sounds good work workspace. Yeah, let’s wait for this to be created. So. Here, technically, this is not an actual physical production. We’re still running this in another virtual environment. So it takes a little while for the environment to be provisioned. So this might take a minute. But what’s going to happen is workspaces in CloudVision are– kind of get branches. When we propose changes that will eventually be a change control, CloudVision creates a copy of the main config and test the changes for a bunch of validation gates. If all of those gates are passed successfully, it gets promoted to a change control that can be executed.
Depending on where you are in your automation journey, you may want to do this manually or like we do in this demo fully automate the approval and execution of the change control. So let’s wait for. This complete, we should see this up in a couple of seconds. I think we’re going through onboarding devices. It’s a new site, so it takes a little while for the first time. There they go. You can see them running right now. Responding to your APIs. All right, let’s go check. I’m pretty sure to what workspace gonna be really quick maybe refresh your browser just in case.
Brad Haas
00:39:34
Oh, I think we missed it. See, 206, oh no, two hours ago.
Philippe Bureau
00:39:46
Keep track of it.
Brad Haas
00:39:55
Phil, they’ll show up under your open workspaces or others.
Philippe Bureau
00:39:58
Just open workspace because it’s open through a service account. It’s not technically tagged to your user.
Brad Haas
00:40:13
Okay, it is, looks like it is continuing additional work here. So let’s see.
Philippe Bureau
00:40:19
There it is there it is. So if we click on it, we should see those gates being slowly passed. So validating the input the config. Now it’s currently very validating. So CloudVision reached out to all the devices and made sure there was no syntax error. The commands were not incorrect. Since everything passed, it gave you a warning that it already promoted it to change control. So let’s go to the change control section, the option just beneath it. And then there’s one currently running. So it’s currently pushing the configuration to the switches and validating that everything happened correctly.
Again, this is the first push, so it’s gonna take a lot longer than usual because the switches are coming out of ZTP and they need to be rebooted. So this is gonna take a couple of seconds. Once it’s complete, now it’s a good time also to mention that if for any reason you pushed a change that was catastrophic and the devices in CloudVision lost, connect communication the switches will roll themselves back after four minutes. So that communication is key between the two devices. And if it’s severed. It’s automatic rollback. So it looks like all the changes were successful. Let’s go check your job chaining and we should see progress.
Brad Haas
00:41:37
Yep, so it looks like we’re at the next step here. What’s going to happen next is that Nautobot’s going to, once that deployment’s been validated in the status of the devices show as active. So if I come here and check our devices. They are moving into that active state. So coming back here. Nautobot’s just waiting to check and validate that cloud vision has been deployed properly and the configs are pushed to production. The next step is that Nautobot is going to take snapshot of the operational state of the environment. So what operational state means inside of Nautobot. It’s very similar to the ANTA solution that you saw.
So if I come here to operations menu, We’re gonna see that I have these rules that can be configured. These are modeled off of the AVD solution or the ANTA solution, I should say. And we’re checking things like BGP session state error disabled ports making sure that MLAG is up in the interface health is in a healthy status. And so what a snapshot is, is once that production environment stood up, We take that information and we timestamp it and you can see we have created a DC1 version 1.0 snapshot of that environment. In addition to that this configuration was minted as a release in the software repository.
So you can see we have version 1.0 as release. And when I click on that, we actually have release notes for this deployment. You can see we’ve got a new site that was added, DC1, with these particular tenants. We’ve generated 238 lines of intent that was the input files for AVD and that became over 1500 lines of code. We also have a link back to the job that promoted it inside of Nautobot as part of the release notes. You can see all the changes that were part of that as well as the ANTA report that supports the validation again here. We also, in addition to that, have a link to the snapshot inside of Nautobot that I was just referring to.
So if I click there, you’re going to see– These are the outputs of all the operational checks that we put inside of that snapshot that was taken. So the VLAN status. EVPN status route counts and so on and so forth. So we’ve got a very good picture of what production looks like right now, all integrated fully through GitHub as a valid software release. So if I go back to the flow and look where we’re at right now. We just landed here and took that snapshot and created that baseline. And I’m going to do one more step, which is to reconcile back to Nautobot coming back to the jobs.
You could, for what it’s worth, these jobs, I’m running them sequentially so you can see them step by step, but these could be chained further together. So right now I’m running that reconcile between CloudVision using Nautobot’s next-generation SSoT. And so that synchronization just completed. And I can show you real quickly what that– result looks like here. The run status, you can see what data was synchronized in how long it took. So you can see the full job only took about 3.4 seconds. And then here’s all of the information that got synchronized. We pulled in the devices and switches prefixes interfaces, etc.
Philippe Bureau
00:45:54
So now we should be able to see that in the device inventory, right?
Brad Haas
00:45:58
We should, I’m gonna do one more job real quick before that, which is to import the ANTA results. So when I run this job we will see additional information populated as well on the devices inside Nautobot. So now we have our inventory in Nautobot reconciled between CloudVision. So we should see additional information here. So right now I’m on the leaf. We can see, we actually see the serial number. The software version that was running came from CloudVision. And then down here, we can see the actual tag inside of GitHub that this change was tied to or this deployment was tied to, as well as the ANTA results that you saw in GitHub earlier.
So we’re reconciling, even pulling back the GitHub information back into Nautobot. You can even see the ANTA results here by clicking show/hide and these are the actual outputs of what ANTA provided when it did its checks and validations.
Philippe Bureau
00:47:02
Yeah, that’s very powerful because you need to tie down at a specific time for release one, how many tests were passed, how many failed potentially and all that stuff. So that’s powerful. And that reconciliation is important. It’s not just like the serial number. If you scroll up to the interfaces. A lot of these have IP addresses that were assigned by AVD, not by Nautobot. So it’s very important to reconcile that back into the source of truth, Nautobot being your source of truth.
You wanna make sure that any data that was derived from AVD and deployed to the switches gets reconciled back into your source of truth so you have a complete view of your network not partial view or multiple points or location to go and to find data.
Brad Haas
00:47:50
Yep, you can see we even synchronized the MTU back in as well that was set on the device. And then one more thing to note here is that snapshot information, we can see that the validation was also counted as compliant from Nautobot’s operational compliance perspective too. So we’ve essentially done checks and balances on both sides of this deployment, the before and after, and we have a snapshot of the network. So. Now, of course, things don’t always stay static. They’re always bound to change. And our team has just gotten a request to add a new VLAN or a new VRF tenant to the design or to that DC1 fabric.
As I alluded to earlier, we’re going to make a change now to the network. So going back to the flow, we’re now going to release a new version, version 1.1, which is going to incorporate this new VRF that we’re about to add. So changing that network now becomes as simple as making a selection here. So I’ve already got my DC1 design referenced, I’m going to go ahead and select the red tenant and run this job should go a lot quicker now because our digital twin environment will be up operational. So this is modeling out the change.
You can see our inputs have been created and– inside of Nautobot, and I should now see a red VRF that was just created from that. And then we’re gonna go ahead and deploy the digital twin as the step two here. So I’ll select the DC1 run the job and go back to our job chain here. So as part of this–
Philippe Bureau
00:49:45
So the thing is the digital twin doesn’t have to be only for new sites, right? Any changes can be tested. What we want is to move away from testing and production.
Brad Haas
00:49:55
Exactly. So you see that ran a heck of a lot quicker. That’s because the network’s already up and running. So couple things I can show you here is that while that Digital Twin is being tested. I’ll come back to reports. And you see, we have a couple new reports here. We see the reconciliation report from when we reconciled between Nautobot and CloudVision earlier. And it’s going to tell us what objects have changed and what was synchronized from CloudVision into Nautobot.
You can see there’s quite a bit of things that have been pulled in like if Phil called out the interfaces and IP addresses was one of the things that he mentioned and then also field level data like software version, serial number, and so on. Also, we have a new field install guide. So we just made a logical change to the network. We didn’t make a physical change. So let’s see if the work order is correct in our case the work order says no physical change was made to this environment. Data Center 1 has no net physical changes.
And therefore, the design is still valid and we don’t need to really change anything other than we still have our beautiful documentation around what gets racked where. While I was showing you that. Our system is working behind the scenes again and we have a new pull request. If I look at this pull request and the file’s changed. We’re gonna see the additional VRF that we had requested as part of our intended state configurations the red tenant in the red VRF configurations as well as the reports
Philippe Bureau
00:51:50
Documentation update yep configurations. But more importantly, yes, the CLI config that’s rendered by AVD that’s important. And now here it’s easier to see the diff earlier. We were building a brand new configuration, but now we’re able to see actually what we’re posing as a change. So our input were very minimalistic, just declaring at a high level our service model, by absolute VRF and the tenant. And then it’s rendering all the complex configuration like the VXLAN config, EVPN configuration, BGP, which is prone to human error and typos.
But more importantly, since we followed the same process as before, it deployed a config, but it also ran validation, or it’s going through right now. Looks like the job just completed while we were talking. Let’s go back to the pull request and actually see in the files change it again. Oh, no on top, go to files changed. And now we can look at the AVD catalogs. I kind of glanced over it earlier when we did the initial validation of the new site. But what I want to point out now is this– I alluded to that AVD uses ANTA, Arista Network Test Automation automatically wrote tests for your new intent.
So we declared a new service, which included a VLAN 300. It also generated 3502 for peering between the two MLAG pairs, that’s best practice. So if you built that pair, that peering automatically. If you scroll down just a bit, we’ll see the SVI for 300 that gets created. Oh, sorry, that’s the test cases. So, but if you look at the file, if you were to blow up the file of the JSON, sorry, to go back to the JSON file on top those test cases. AVD will retest everything all the time. It just included new tests, but the content of that file is significant and this is not something that human had to write.
So the automation piece wrote the validation piece executed it like last time. And if we go back to the PR– discussion or conversation. We set a pipeline to actually save the ANTA report, same as before. And now we can confirm if– applying this change to the network or the design change we’re proposing what’s the expected impact in this case? We see a lot of green no error, everything was okay. But the benefit is here instead of running a bunch of show commands we can run hundreds of test cases per second.
And this allows us to test everything all the time as opposed to just deciding, okay, I’m gonna run these 10, 20 show commands and document it into the ticket. This allows us to test the whole infrastructure every time.
Brad Haas
00:54:48
Yep, and I also want to point out here before we merge this, right? So merging is our validation where Phil and I are going to either agree or disagree that we’re ready to deploy this to production again. So before we do that, let’s say we have an operator who’s a little bit eager and they come into Nautobot and want to promote to production for this particular design. I’m actually going to run this right now, even though we haven’t agreed or merged that change into the system and just show you what happens.
So because we have this pre-flight check, We’re actually checking in with GitHub, our GitHub integration which is telling us, “Hey, you know what? Your main branch does not carry the changes. There’s three files that differ, and it’s suggesting we need to merge those first before we can promote.” So we’ve got the instructions. What we need to do. Phil, what do you think? Are we ready?
Philippe Bureau
00:55:45
Yeah, it looks good to me. Let’s go ahead and put
Brad Haas
00:55:48
All right, merging to production. Now, also important to note, this is not immediately deploying we have to trigger that promote to production step again. So I’m just simply going to rerun this job. We should see this one run a little bit quicker as well. Again, going out, reaching out to CloudVision in scheduling the change. We’ve also created a new software release. So let me go back to our repository. If you recall, we were on version 1.0 of the network. And what we’ve done is created a new release that is pending our approval or our merge into the cloud vision environment. And it’s showing us what exactly has changed here.
So our release has the new tenant version bump and again the amount of lines of configuration that were deployed as such. Going back to Nautobot a couple of things happening here in the deploy step, I scroll down. It looks like we’re talking back to CloudVision. And– It’s checking the actions inside of GitHub right now. So we’ll go to GitHub actions. We’ll see we have the deploy to prod step and then we have another ANTA check that’s running and doing yet another validation, right? Like let’s make sure that this thing is good to go.
Philippe Bureau
00:57:23
On the production and we have something to refer to. So if we tested in digital twin, we can compare to report with the post. So we have a guideline and a baseline to compare.
Brad Haas
00:57:36
Yeah, and that should take us about 30 seconds, 28 seconds. So one thing that happened right at the end of that is if I go back to our release notes now our release notes should have been appended. And we’ll see here’s. Hey, our change control and CloudVision was successful the ANTA check was successful. And here’s the particular. GitHub action that ran, that deployed it, and the number of tests that were validated and successful. So we’ve got a full blown network deployed at this point with release notes on version 1.1. So if I come back. CloudVision go back to our provisioning and our change control. We should see that 1.1 change right here.
And it was all green check boxes as Phil was pointing out earlier. If we ever had an emergency and needed to roll back, we can do that right here within CloudVision. So let’s just kind of wrap it up here. We have a couple more steps just to do the reconciliation. So we’ll run the reconcile job, which should just take a now five, six seconds and then we’ll run a second job to pull in our ANTA results once again.
And now we have are fully changed environment with the new VRF deployed to the production network and we’ve essentially closed the loop on the automation and gone through the entire life cycle and to end from the initial deployment all the way through to making a change on the network in a day two operations and having all those checks and balances. A couple other things happened on that second run. Nautobot’s operational compliance also triggered on, so we have multiple snapshots now that we can look at. So here– We’ll see we have a snapshot of version one of the network and a snapshot of version 1.1 as well.
And then under the compliance overview, we’ll see that we have them. We can do a compare between the two and comparing those two snapshots together, we see that we have 100% compliance. And so the network is good to go. Lastly. We have a new report that was published in Nautobot called Change Validation Report. And so this is taking that same information and creating something that you can attach to your change control ticket. So if I scroll down, it’s saying, hey, this change that we implemented touched six devices at DC1 what the devices were from a role perspective. What changes were checked? And then the.
You can see here the results of all of those, those evaluations across the devices and the rules that were checked against, just like the ANTA solution. This is effectively Nautobot doing one more check and balance against that. And you can see all of the passes and changes before and after as well. 10 versus configuration. And it also, I believe we have here the actual fabric settings as well that are attached to the change control. All right, so I believe that brings us to the end of the flow. So if you recall– We basically just treated the network like software release.
We created two releases, version one and version 1.1 with the change going all the way end to end with validation and documentation throughout. So let’s talk about what this means now to our team that we talked about earlier, the outcome. What is the outcome here? So first off, Jamie, who’s responsible for this network now, can feel confident that the design, the fabric that he designed is staying that way throughout and is staying up to date. His design documents are minted along the way and considered as part of the standard document solution that he has that he can hand over to Riley who as you can see is no longer sweating.
Riley’s got an installation guide that he can trust to every port and every rack elevation. Are you mounting that he needs to do as far as cabling goes? Sam has confidence that this thing is going to actually work because he tested it and saw that the validations worked on the Digital Twin. And he has a report to prove it. Took about two and a half minutes. Sam is no longer stressed out by the 1 AM change control window that he has. And he has actual version– releases of the network, along with release notes that show the links to all of the reports. Jamie’s no longer 2:30 in the morning scrambling to run.
26 show commands across the fleet or the entire fabric device by device and taking screenshots anymore. The proof is built into the workflow now and the change report is something that he can hold in his hand and attach back to the change ticket that he’s responsible for. And lastly, the documentation at the end, is it still accurate? Well, Heck yeah, we’re going from the full life cycle here from design to day two operations. These documents are staying up to date all throughout and updated as they go. So that reconciliation step, as Phil mentioned, very important.
So yeah, the change is verified now and the team can really feel confident that the– everything is working as intended. With that, Keith, over to you.
Keith Byette
01:04:04
Yeah, sure. Basically what we’ll do is we’ll put a close to this and talk about next steps. So to wrap things up today, the real big takeaway, it’s simple. Stop guessing, start running your network like software. If you’re ready to take some next steps in automating your network lifecycle, here’s a few ways to get in touch with us. You can hit me up with a. Keith B at Arista.com. You can get in touch with Network to Code, with that info@networktocode.com. Or if you wanna find us out in the wild, you can join at AutoCon.
So if you or your team are attending AutoCon, come on by, stop, say hello, and let’s talk about some network automation in person. If you’re looking to speak with an expert, reach out to schedule a dedicated one-on-one session with someone from our team and we can map out your specific architecture workflow and automated goals. And then contact us, drop us a note directly through our website, request some more information, and we’re happy to give you some follow-up resources. So thank you so much to Brad, Phil, all of you for taking your time and joining us today.
Keep an eye out for your inbox for the recording, the slide deck, and some future joint collaborations like some workshops, and have a fantastic rest of your day. Thanks, everybody. Thanks, everyone.