NetDevOps CI/CD with Ansible, Jenkins and Cisco VIRL (Part 1 - What is NetDevOps?)

Introduction

In the world of networking NetDevOps is one of the latest buzz words flying around. But what is NetDevOps, or even DevOps? In this 3-part series we will answer these questions, and also dive into a NetDevOps implementation using Ansible, Github, Jenkins and Cisco VIRL.

Our example will be based on configuring SNMPv3 on a spine and leaf network. The code for this tutorial can be found at https://github.com/rickdonato/netdevops-cicd-snmpv3

Let’s go...

What is NetDevOps?

In a nutshell NetDevOps brings the culture, technical methods, strategies and best practices of DevOps to Networking.^[1] Therefore, let's first take a step back and answer - What is DevOps?

DevOps

DevOps is a software development strategy and culture that bridges the gap between the Development (Dev) and Operational teams (Ops), in order to build, test and release software faster and more reliably.

Background

Historically, software development involved 2 main teams - Development (Dev) and Operations (Ops). Each of these teams had different responsibilities (shown below) in order to take the code from initial development, to build and test and to final deployment.

Team silos were common, multiple handoffs were needed between the teams to get the code from dev to production. This resulted in software quality issues and delays, along with frustration amongst the Dev and Ops teams.

Figure 1 - Legacy software development pipeline.^[2]

With the increased growth of the digital age and the requirements on development teams to provide updates, features and application releases, these issues manifested. In order to address these issues the DevOps movement began.

DevOps Practices

There are a number of DevOps practices that can be adopted to achieve greater efficiency and reliability with your software development pipelines.

One fundamental DevOps practice is to perform very frequent but small updates.^[3] As stated by AWS:

These updates are usually more incremental in nature than the occasional updates performed under traditional release practices. Frequent but small updates make each deployment less risky. They help teams address bugs faster because teams can identify the last deployment that caused the error.^[4]

Another 2 key DevOp practices are:

Infrastructure as Code (IaC)

The process of managing and provisioning computer data centres through machine-readable definition files, rather than physical hardware configuration or interactive configuration tools.^[5]

CI/CD (Continuous Development)

CI/CD is best described as,

The natural progression of iteration times shrinking into insignificance. Through heavy use of automation, flexible infrastructure and modular architecture…^[6]

CICD consists of,

• Continuous Integration (CI) - Developers frequently merge their code changes into the code base (i.e central repository). Each check-in is built and verified by unit-tests. This allows teams to detect problems early.
• Continuous Delivery (CD) - Extends CI. Once CI is complete, the code is deployed to a test environment, where further testing is performed (such as load and integration testing). At this point, the necessary software artefacts are ready to be deployed to production. Deployment to production is then manually triggered.
• Continuous Deployment - Synonymous to CD, but instead deployment is automatically triggered.

Figure 2 - CI vs Continuous Deployment.^[7]

Note: For further details around unit-testing and integration testing please see: https://www.guru99.com/unit-test-vs-integration-test.html

Back to NetDevOps

DevOps is all well and good, but why do we need NetDevOps?

Today, network changes are normally large and complex, changes are seen as high risk, avoided if possible and subjected to rigorous, costly, and lengthy vetting processes. Even so, problems still occur. Human error and/or lack of the correct verification still creep in. All of which results in, what some call a "culture of fear"^[8] mentality around the network and in turn, network changes.

NetDevOps leverages the practices from DevOps (such as CICD and IaC), to ensure network changes are small and frequent but also performed in much more automated, efficient and reliable way.

Coming Up

In part 2 of this series we will look at the different components and tools that we will use to build our NetDevOps CI/CD pipeline. See you there ...

References