In the previous post we’ve had a look at how native OpenStack SDN works and what are some of its limitations. In this post we’ll tackle the first one of them - overhead created by multicast source replication.
Continue readingNow that we have our 3-node OpenStack lab up and running we can start exploring how virtual networks are implemented under the hood.
Continue readingIn the previous post I’ve demonstrated how to get a working instance of a single-node OpenStack inside UNetLab. In this post we’ll continue building on that by adding two new compute nodes and redesigning our network to resemble something you might actually see in a real life.
Continue readingIn this post I’m going to show how to get a running instance of Openstack inside a UNetLab virtual machine.
Continue readingThe final post in a series demonstrates how to use the network-ci tools to safely replace a core routing protocol inside a small Active/Standby Data Centre.
Continue readingIn this post I’ll demonstrate how to use the network-ci tools to automate the build, test and upgrade of a small 4-node network.
Continue readingTraditionally, the first post in the series describes how to setup a development environment. This time I’ll do it DevOps-style. I’ll show how to use Packer to automatically create and configure a VM with UNetLab and Jenkins pre-installed.
Continue readingIn this series of posts I’ll introduce the tools I’ve been using for continuous network development and how they can be used with automation servers like Jenkins for network continuous integration and delivery.
Continue readingIn this post we’ll look at how to create arbitrary topologies and push configuration to Nodes in UNetlab via REST SDK. We’ll conclude by extending our sample application to create and configure a 3-node topology and enable full connectivity between all nodes.
Continue readingIn this post I’ll show how to build REST SDK to authenticate, create labs and nodes in UnetLab. I’ll briefly cover the difference between composition and inheritance design patterns and demonstrate how to use test-driven development.
Continue readingIn this post I’ll show how to setup environment for UnetLab REST SDK development on Windows. I’ll be running UNL inside a VM and using PyCharm as Python IDE on the host OS.
Continue readingThis is the first, introductory, post in a series dedicated to REST APIs for Network Engineers. In this post we’ll learn what REST API is, what are the most common tools and ways to consume it. Later in the series I’ll show how to build a REST client to control UnetLab, a very popular network emulation environment.
Continue readingIn this post I’ll show how to automatically build configuration files for Hubs and Spokes in FlexVPN network topology. I will also introduce two concepts that are frequently used in software development world - DRY and “Convention over Configuration”. This post is a precursor to the upcoming FlexVPN configuration post on Packetpushers.
Continue readingIn this post we’ll have a look at how to automate a typical BGP setup. This is where configuration may get particularly messy especially in presence of backdoor links and complex routing failover policies. However, as I will show, it is still possible to create a standard set of routing manipulation policies and selectively apply them to the required adjacencies to achieve the desired effect.
Continue readingThis post will demonstrate how to automate the build of a typical enterprise branch network consisting of a pair of WAN routers, a core switch and 3 access layer switches. I will show how to create the initial bootstrap configuration and enable basic routing with OSPF.
Continue readingIn this post I’ll show how to take an already established network, pull out some of the common configuration pieces and put them all into a standard Ansible environment. A lot of configuration files will be omitted for the sake of brevity, however all of them can be found on my github repository.
Continue readingThis post will give a brief overview of network configuration automation, describe its challenges and benefits and will set off a series of posts showing how to automate a configuration of a typical enterprise network.
Continue readingThis post gives a quick overview of how to use network Test Driven Development framework. As an example I’ll use a simplified version of a typical enterprise network with a Data Centre/HQ and a Branch office. A new branch is being added and the task is to configure routing for that branch using a TDD approach. First we’ll devise a set of TDD scenarios to be tested and then, going through each one of them, modify routing to make sure those scenarios don’t fail (a so-called red-green-refactor approach)
Continue readingNow that Ansible has done all the information gathering for us it’s time to finally make use of it. In this post I will show how to use Ansible to run traceroutes from and to the hosts defined in a test scenario and perform verification of the results of those tests. Should any of those tests fail, Ansible will provide a meaningful description of what exactly failed and why. While doing all this I’ll introduce a couple of new Ansible features like conditional looping and interactive prompts.
Continue readingAnsible has a very neat feature called “fact gathering”, which collects useful information from hosts prior to executing any of the tasks and makes this information available for use within those tasks. Unfortunately, this also relies on Python being available on the remote machine which doesn’t work for Cisco IOS. In this post I’ll show how to write a simple module which will collect IP address information from remote devices and store it in global variable for future use. I’ll also show how to write a module which will convert our human-readable TDD scenarios into YAML structures. As always, full code repository is available on Github
Continue reading