Network Automation Academy

Curriculum Library

Click the buttons to explore our different training options

This curriculum library contains overviews, objectives, and outlines of all Bootcamps, Workshops, and Bite-Sized Learning offerings from Network to Code. Use the buttons to navigate to the curriculum section you would like to explore!

Contact Us

If you have questions or want more information about any of our training offerings, please contact us here and we will get back to you!

Bootcamps

From our beginner to more advanced bootcamps, each is an immersive deep dive for a jumpstart into network automation for that focus area. Each is structured with a 50/50 split for lecture/lab time for hands-on training and experience. They can be completed within a week’s time or less, at 3 to 5 days in length.

Network Programming & Automation

Course Length: 5-day Bootcamp, 8 hours per day

Level: Beginner

Course Overview

In this 5-day course, network engineers will learn about foundational skills as they pertain to network automation and programmability. The network industry is in the midst of change, and one part of that is the operational models and technologies used to manage and operate networks on a day to day basis. For over 20 years, the CLI has been the primary means to manage networks. Going forward, we are starting to see more open and programmable network devices emerge – this means having device APIs not only on network switches, but also on SDN controllers in the form of northbound RESTful APIs. In addition, we are also seeing network devices be integrated with existing DevOps automation tools.

This course covers the skills needed to take advantage of these modern network devices. The course is divided into two parts. Part 1 covers raw concepts and technologies with a focus on Python and Part 2 focuses on automating network devices with Ansible.

This course includes automation of Cisco IOS, Cisco NXOS, Arista EOS, Juniper Junos devices.

Objectives
  • Provide network engineers with an understanding of using Python within the context of network engineering
  • Provide network engineers with an understanding of using Ansible within the context of network engineering including use of YAML and Jinja2 templating
  • Provide an understanding of network APIs, JSON, and YAML
  • Act as a jump start onto a greater network automation journey
Prerequisites

While there are no programming, software/dev, or automation prerequisites, students should have basic familiarity with:

  • Networking concepts
  • Using a text editor such as VSCode, Sublime Text, or vim
  • Navigating the Linux filesystem (creating and viewing files, navigating directories)
  • Knowing how to SSH to a network device from Linux
Course Summary

Part 1 – Network Automation with Python

  • Module 1 – Getting Started with Python for Network Engineers
  • Module 2 – Automating Network Devices Using Python
  • Module 3 – Working With Network Device APIs

Part 2 – Network Automation with Ansible

Course Outline

Part 1 – Network Automation with Python

Module 1 – Getting Started with Python for Network Engineers

Assuming no previous experience with Python, the first day starts with the basics of Python data types, nested objects, and writing simple Python scripts in the complete context of networking.

  • Using the Python Interpreter
  • Understanding the basic Python Data Types
  • Writing Scripts
  • Working with Files
  • Understanding Python Modules
  • Exploring and extracting useful information from deeply nested data

This module starts on Day 1 and finishes on Day 2.

Module 2 – Automating Network Devices Using Python

This module starts by introducing a network automation classic: the Netmiko library. The various operations it enables against network devices are then iterated upon in various scripts, introducing other fundamental programming topics such as conditionals, loops, and functions.

If time permits, bonus topics include a brief introduction to Regular Expressions, a look into TextFSM for parsing raw text, and finally the NAPALM automation library.

  • Connecting to network devices in Python via SSH with the Netmiko library
  • Refactoring code to reduce repetition and improve modularity
    • Conditionals
    • Loops
    • Functions
  • Passing in Arguments from the Command Line
  • Bonus: Introduction to Regular Expressions
  • Bonus: Parsing Raw Text from traditional SSH-based devices (without APIs) using the TextFSM Python library
  • Bonus: Declarative & Intent Driven Network Configuration with NAPALM

This module starts on Day 2 and finishes on Day 3.

Module 3 – Working With Network Device APIs

This module focuses on RESTful and more generic HTTP-Based APIs in addition to getting started with Postman to help with the process of learning how to use any given web API.

  • Introduction to RESTful and non-RESTful HTTP APIs
  • HTTP API Clients and Sandboxes
  • Arista eAPI
  • Cisco NX-API
  • Cisco IOS-XE RESTCONF API
  • Getting Started with Postman
  • Consuming HTTP APIs with Python requests

The students will work with Postman in these labs and, time permitting, they will also use the Python requests library.

This module is on Day 3.

Part 2 – Network Automation with Ansible

At this point in the course, students will understand data types, encoding formats, and APIs, and how to write Python scripts automating the network. In this module, students will build on that knowledge by first learning all about Ansible and YAML, with plenty of practical examples. This introduction demonstrates how Ansible can be used to further simplify workflows by providing an even faster means of getting started with network automation.

This module also covers the use of Jinja within Ansible for configuration templates and reporting, as well as 2 more days of just using Ansible for network automation. As this course has been updated to Ansible 4 (core 2.11), it makes full use of the Content Collections system.

  • Ansible Overview
  • Terminology
  • Introduction to YAML
  • Variable Management
  • Introduction to Jinja Templating
  • Device Templating with Jinja and Ansible
  • Deeper dive into Ansible (conditionals, loops, register, variables, check mode, etc.)
  • Using Vendor Specific Modules (Cisco NXOS and Juniper Junos Ansible modules)
  • Multi-Vendor Network Automation
  • Ansible Core Modules for issuing show commands and making configuration changes
  • Ansible Roles & Creating Abstractions
  • Automating Data Gathering & Documentation
  • Dynamic Inventory Scripts

This module starts late on Day 3 and finishes on Day 5.

Automating Networks with Python I

Course Length: 3-day Bootcamp, 8 hours per day

Level: Beginner

Prerequisites

While there are no programming, software/dev, or automation prerequisites, students should have:

  • Good grasp on networking concepts such as device configuration of interfaces, VLANs, SNMP configuration, and basic routing
  • Ability of the Linux filesystem (creating and viewing files, navigating directories)
  • Be aware of how to use a text editor: SublimeText, nano, vi/vim, notepad++, VSCode
Course Description

In this 3-day course, you will learn about foundational skills as they pertain to network automation and programmability. The network industry is in the midst of change, and one part of that is the operational models and technologies used to manage and operate networks on a day-to-day basis. For over 20 years, the CLI has been the primary means to manage networks. Going forward, we are starting to see more open and programmable network devices emerge – this means having device APIs not only on network switches, but also on SDN controllers in the form of northbound RESTful APIs. This course covers the skills needed to take advantage of these modern network devices. This course will cover raw concepts and technologies with a focus on Python.

Python for Network Engineers
  • Python Interpreter
  • Data Types
  • Conditionals
  • Loops
  • Functions
  • Writing Scripts
  • Passing in Arguments from the Command Line
  • Working with Files
  • Understanding Python Modules
Writing Scripts and Using Network APIs
  • Introduction to Regular Expressions
  • Parsing Raw Text from traditional SSH-based devices (without APIs) using the TextFSM Python library
  • Connecting to network devices in Python via SSH
  • Declarative & Intent Driven Network Configuration with NAPALM
  • Introduction to RESTful APIs
  • Getting Started with Postman
  • Exploring IOS-XE RESTCONF API, Arista eAPI, and NXOS NX-API
  • Using JSON in Python

Automating Networks with Ansible I

Course Length: 3-day Bootcamp, 8 hours per day

Level: Beginner

Prerequisites

While there are no programming, software/dev, or automation prerequisites, students should have:

  • Good grasp on networking concepts such as device configuration of interfaces, VLANs, SNMP configuration, and basic routing
  • Ability of the Linux filesystem (creating and viewing files, navigating directories)
  • Be aware of how to use a text editor: SublimeText, nano, vi/vim, notepad++, VSCode
Course Description

In this 3-day course, you will learn about foundational skills as they pertain to network automation with Ansible. The network industry is in the midst of change, and the operational models and technologies used to manage and operate networks on a day-to-day basis are changing too. For over 20 years, the CLI has been the primary means to manage networks. Going forward, network engineers will be using platforms such as Ansible due to its low barrier to entry.

This course covers the skills needed to get a jump start with Ansible for Network Automation covering data types, data models, and then in depth look at Ansible. Everything in this course is 100% focused on using Ansible to manage network infrastructure.

  • Introduction to Ansible
  • Writing Playbooks
  • Inventory File Management
  • Variable Management
  • Introduction to YAML
  • Network Configuration Templating with Jinja2
  • Managing Network Configurations with Ansible
  • Declarative Configuration Management
  • Issuing Show commands with Ansible
  • Multi-Vendor Network Automation
  • Ansible Roles & Creating Abstractions
  • Advanced Data Collection
  • Create Dynamic Reports
  • Dynamic Inventory

Automating Networks with Ansible II

Course Length: 3-day Bootcamp, 8 hours per day

Level: Intermediate

Prerequisites
  • Working knowledge of Ansible and ability to understand and write Python code.
  • Practical experience using Ansible for network automation is very beneficial in order to make the most out of the topics presented.
  • Basic understanding of REST APIs and familiarity with Linux commands.
Course Description

Automating Networks with Ansible II is a 3-day bootcamp aimed at teaching more advanced topics related to using and extending Ansible in the context of Network Automation. It helps you get started with translating complex workflows into working code and gaining a deeper understanding of what are the next steps after using (and hitting some of the limits of) Ansible and its packaged functionality in your day-to-day automation tasks.

The course starts off with a deep dive into Jinja Built-in Filters, Network Device Text CLI Parsing, and the difficult to master Whitespace management. It then progresses through the Ansible Plugin System, focusing on building Custom Jinja Filters, where multiple use-cases relevant to automating network devices are explored, from data enrichment to comparing operational with intended state. Next up, you will be learning how to write Custom Ansible Modules from scratch, improving your code step by step to achieve a well-designed and functional Ansible module that interacts with an external network device REST API.

To round off the third day, you will explore the latest changes brought by the Ansible Content Collections system (extending functionality through third party code and packaging your own custom filters/modules for distribution) and how to make the most out of the ecosystem of Inventory Plugins (with an emphasis on loading data from multiple sources and leveraging dynamic inventories such as Netbox/Nautobot).

Course Objectives
  • Deepen your understanding of the Jinja templating language, its syntax, and its built-in filters.
  • Learn about the various whitespace management options in Jinja and how to best use them in practice.
  • Understand the role of Text parsers for CLI output and how third-party libraries are integrated within Ansible.
  • Become familiar with the Ansible Plugin System and how it can be extended.
  • Learn how to write custom filters from scratch and integrate them in Ansible for usage in playbooks.
  • Learn how to build custom modules from scratch, using an iterative approach to improve their capabilities and align them with good Ansible module design philosophies.
  • Understand how to use the Ansible Content Collections to install, manage, and package third party Ansible code.
  • Leverage multiple Inventory formats together and be able to use dynamic inventories provided through existing plugins interacting with external systems.

Automating Networks with Python II

Course Length: 3-day Bootcamp, 8 hours per day

Level: Intermediate

Course Overview

In this 3 day course, you will learn more advanced skills as they pertain to network automation and programmability. The network industry is in the midst of change, and one part of that is the operational models and technologies used to manage and operate networks on a day to day basis. For over 20 years, the CLI has been the primary means to manage networks. Going forward, we are starting to see more open and programmable network devices emerge – this means having device APIs not only on network switches, but also on SDN controllers in the form of northbound RESTful APIs.

This course covers the skills needed to take advantage of these modern network devices. This course will cover how to apply fundamental Python constructs.

Objectives
  • Provide network engineers with an understanding of how to apply Python in the increasingly dynamic context of network engineering.  Some of the topics covered will include security, logging, testing, documentation, and performance considerations and best practices.
  • Provide an understanding of Object Oriented Programming with Python as it relates to more advanced network automation programming topics.
Prerequisites

Students should have basic familiarity with:

  • Networking concepts
  • Basic Python data structures, conditionals, loops, functions, scripts, file access, and JSON
  • Using a text editor such as Microsoft VSCode, Sublime Text, or vim
  • Navigating the Linux filesystem (creating and viewing files, navigating directories)
  • Knowing how to SSH to a network device from Linux
Course Outline

The course will be built around a few Python based network automation tools and workflows, introducing and then diving deeper into specific language concepts and constructs.

  • Using and combining libraries like Nornir, NAPALM, Netmiko/Scrapli.
  • Interacting with APIs, be it network device or SoT/Ticketing/ChatOps
  • Python project and package management deep dive
  • Code linting, quality checking, development setup and tooling integrations
  • Logging in Python, Error Handling
  • Building a Web Application using Flask (example: target for webhooks, web GUI for scripts with validation and reporting, SoT aggregation layer etc.)
  • parallelization using Asyncio

Nautobot Plugins

Course Length: 3-day Bootcamp, 8 hours per day

Level: Advanced

Prerequisites
  • Familiarity with Django (required)
  • Course Source of Truth & Nautobot or familiarity with Nautobot, its UI, and general understanding of the Nautobot data models
  • Nautobot Extensibility
Objectives
  • Build a Nautobot app (plugin) that can create custom views, templates, and APIs
  • Create a Nautobot app that only adds content (using existing data) to an existing page
  • Create a Nautobot app that distributes a Nautobot Job
  • Understand the difference between a Nautobot Job and a Nautobot app
  • Understand how permissions can be applied to features and functions within a Nautobot app
Course Description

Nautobot is a network automation platform that allows users to extend Nautobot to meet their unique needs. Going beyond Nautobot extensibility covered in the Nautobot Extensibility course, this course introduces how Nautobot Apps (or plugins) extend the existing functionality of Nautobot. By using Python and Django to extend Nautobot, users can create custom APIs, views, and database models allowing network teams to store any network data they need to drive their network automation initiatives. Beyond storing more network data, Nautobot Apps also can be used to create network automation applications that complement any existing network automation strategy. Using Nautobot Apps to create custom applications saves significant time and effort because users take advantage of all the non-functional features already in Nautobot including login/logout (authentication), APIs and tokens, Git integration, Jobs, and much more. Upon completion of this training course, you will possess the knowledge and skills to write your own application (plugin) to extend Nautobot functionality. Please note: this course is for advanced engineers only; experience with Django is required.

NetBox Plugins

Course Length: 2-day Bootcamp, 8 hours per day

Level: Advanced

Prerequisites
  • Familiarity with Django
  • Course Source of Truth & NetBox or familiarity with NetBox, its UI, and general understanding of the NetBox data models
  • Course NetBox Extensibility
Course Description

NetBox Plugins are a more advanced way to add features to NetBox. They are packaged Django applications that can be installed alongside NetBox to provide custom functionality not present in the core application. Plugins can introduce their own models (database), views, APIs. For example, overlay networks (VxLAN), or FW policies, where there aren’t native models and support, they can easily be added to NetBox via a plugin. A NetBox user may opt to install plugins provided by the community or build their own. Upon completion of this training course you will possess the knowledge and skills to write your own plugin to extend NetBox functionality.

Jinja2 Templating Deep Dive

Course Length: 2-day Bootcamp, 8 hours per day

Level: Intermediate

Prerequisites
  • Good understanding of Ansible, Linux commands, and programming concepts in Python
Course Description

Jinja is one of the most commonly used templating engines within network automation since it is natively built into Ansible (and written for Python). It enables network engineers to codify those existing “templates” or “standards” that are tucked away in MS Word or text files.

This session dives deeper into the Jinja library, covering more complex template logic, whitespace management, and usage of various filters, all within the context of Ansible playbooks and Python scripts. Upon completion of this hands-on workshop, you will be able to create and manage Jinja configuration templates that will be used to define, enforce, and deploy enterprise configuration standards.

Source of Truth and Nautobot Fundamentals

Course Length: 2-day Bootcamp, 8 hours per day

Level: Beginner

Prerequisites
  • Basic networking knowledge, e.g. CCNA Network operations experience, e.g. IP Address Management, Racking, Cabling, etc.
  • Familiarity with network management tools Course Objectives:
  • Understand what a Source of Truth is and the types of data that can be stored in a Source of Truth
  • Understand concepts and terms such as Systems of Record, Authoritative Source of Data, and Single Source of Truth
  • Articulate the difference between operational state (observed) and intended state (desired) data
  • Understand the role a Source of Truth plays within a network automation platform
  • Learn how to Deploy Nautobot, its dependencies, and the Welcome Wizard Application (plugin)
  • Navigate the Nautobot UI and populate Nautobot with Source of Truth data
Course Description

This course introduces fundamental concepts as they relate to Source of Truth from exploring the use of YAML files to using a first-class Source of Truth such as Nautobot. Nautobot is an open source Source of Truth (SoT) application for network environments that helps define what should be both from a physical and logical perspective including defining sites, regions, racks, rack elevations, device types, and also configuration data. As a central component of a Network Automation Platform, it serves as a Source of Truth and includes a device inventory and configuration data that represents the intended state of the network versus the operational state of the network.

Upon completion of this training, you will understand the fundamental design philosophy of Source of Truth, Systems of Record and the benefits of tracking both the desired state and the operational state of enterprise networks, and how you can leverage Nautobot to define your network’s intended state.

Workshops

Each workshop is a 4-8 hour deep dive into a specific automation topic, ranging from beginner to advanced level. Our workshops are structured with a 50/50 split for lecture/lab time for hands-on training and experience.

Source of Truth and Nautobot

Course Length: 4 hours

Level: Beginner

Prerequisites
  • Basic networking knowledge, e.g. CCNA Network operations experience, e.g. IP Address Management, Racking, Cabling, etc.
Course Description

Nautobot is an open source Source of Truth (SoT) application for network environments that helps define what should be both from a physical and logical perspective including defining sites, regions, racks, rack elevations, device types, and also configuration data. As a central component of the Network Automation Platform, it serves as a Source of Truth and includes a device inventory that is intended to represent the desired state of the network versus the operational state of the network. Upon completion of this training, you will understand the fundamental design philosophy of Source of Truth, Systems of Record and the benefits of tracking both the desired state and the operational state of enterprise networks, and how you can leverage Nautobot extensibility features to customize it to your specific requirements.

Getting Started with Linux and Text Editors

Course Length: 4 hours

Level: Beginner

Prerequisites

Eagerness to jump into the world of network automation!

Course Description

This course explores the tools and techniques commonly used by network engineers to achieve their day-to-day work in a Linux environment. It is designed for experienced computer users who have limited or no previous exposure to Linux. Upon completion of this training you should have a good working knowledge of the Linux command line to create and navigate directories, install Linux and Python packages, and explore common text editors such as nano, vim, and VS Code. This course sets engineers up with some of the basic tools required for the following NTC network automation training events, workshops and daily work activities.

Development Environments

Course Length: 4 hours

Level: Beginner

Prerequisites
  • Basic knowledge of common Linux command line tools and familiarity with the Python language and packaging system
Course Description

A development environment in the context of network automation is the sum of all the tools that an engineer has at their disposal: code editors, programming/scripting languages, packaging and third-party libraries, virtual and hardware devices, and supporting software or services like version control.

This session explores the baseline of tools that you can set up on your machine, with live demos using VSCode, various terminals, Git, Windows Subsystem for Linux, Vagrant, Virtual Machines, Python tooling, and Docker. You will also learn how to package your Python code so that it’s easier for others to collaborate on it and ensure that it will execute well in any environment on other machines. This workshop includes hands-on lab exercises to increase proficiency in using these tools in a development environment infrastructure.

Introduction to Jinja Templating within Ansible

Course Length: 4 hours

Level: Beginner

Prerequisites
  • Basic understanding of Ansible, Linux commands, and programming concepts
Course Description

Jinja is one of the most commonly used templating engines within network automation since it is natively built into Ansible (and written for Python). It enables network engineers to codify those existing “templates” or “standards” that are tucked away in MS Word or text files.

This session goes through all the fundamentals of the Jinja Templating language and provides context and practical examples of how it is used within Ansible, mainly for configuration generation and structured data manipulation using filters.

Extending Ansible

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Network Programming & Automation Course or equivalent knowledge of Ansible and Python
  • At least 6 months experience using Ansible for network automation and working with REST APIs is highly recommended
  • Basic knowledge of common Linux command line tools
Course Description

As you progress down the path of Network Automation with Ansible, you create inventory files and write playbooks using existing modules and roles, but not all the functionality you may need is already available in the Ansible code. The next step is learning to extend Ansible through its very flexible plugin system. These important pieces of code augment Ansible’s core functionality, such as adding new modules for new device types, new Jinja filters for parsing show commands and managing data or creating inventory plugins that interface with internal systems. Essentially, Ansible uses plugins to extend what the system is doing under the hood. Upon completion of this full day training course, you will possess the knowledge and hands-on skills to write your own Custom Filters and Modules to extend Ansible functionality.

Cisco Network Services Orchestrator (NSO)

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Basic networking knowledge, e.g. CCNA
  • Basic familiarity with XML
  • Understand the role of YANG
  • Understand how to use Text Editors such as Sublime Text and VSCode
Course Description

This is a one (1) day hands-on course that provides an introduction to using Cisco Network Services Orchestrator (NSO) for network automation with 50% lab time. You’ll learn how to install NSO, configure network devices, and get insight into using templates, services, and services models.

NetBox Extensibility

Course Length: 4 hours

Level: Intermediate

Prerequisites
  • NetBox Intro Workshop or equivalent practical experience
  • Basic understanding of Jinja/Django templating and general programming concepts beneficial
Course Description

NetBox offers several extensibility features for customization of functionality exposed through its graphical web interface. Exclusive of plugins (which have their own dedicated training course), this course covers the capability to create user-defined custom fields and links, webhooks, export templates, and custom reports and scripts. This extensibility can be used for integrations with other systems such as ServiceNow, building custom reports, and ChatOps alerting. Upon completion of this 4-hour training course you will possess the knowledge and hands-on skills to deploy each of these features to extend NetBox functionality.

Collaborative Workflows with Git and GitHub

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Understanding of programming languages and typical development environments, basic Linux commands familiarity
Course Description

Git is a distributed version-control system for tracking changes in source code during software development. Originally designed for coordinating work among programmers, it’s an invaluable tool in many automation workflows, due to its ability to track changes in any set of files.

This session introduces Version Control Systems in the context of Network Automation and then focuses on common Git-based workflows that come up when managing files like Ansible playbooks, YAML data, or Python source code for network automation.

Since collaboration is a key aspect of any tool like Git, the workshop also explores various workflows that allow for multiple people to interact on the same project, in this case with the help of a centralized service like GitHub. The concepts learned here apply fully to other similar platforms like GitLab or Bitbucket.

Upon completion of this full-day training you will have the hands-on experience to use Git for version control of your code and collaborate with others on centralized platforms (leveraging capabilities like code reviews, automated testing, project and issue tracking etc.).

Network Configuration Testing with Batfish

Course Length: 4 hours

Level: Intermediate

Prerequisites
  • Basic knowledge of common Linux command line tools and familiarity with the Python language and packaging system
  • CCNA level networking knowledge
Course Description

Batfish is a network configuration analysis tool. It simply reads in configuration files (“show run”) and then finds errors and guarantees the correctness of planned or current network configurations. It is often used as part of a deployment pipeline (checking configs pre/post change) but can also model and predict paths to give you an indication if traffic were to drop or not be permitted through firewalls. It enables safe and rapid network evolution, without the fear of outages or security breaches. Upon completion of this workshop, you will have the hands-on experience to use Batfish for configuration testing in your daily work environment.

Introduction to Nornir

Course Length: 4 hours

Level: Advanced

Prerequisites
  • Good understanding of programming concepts in Python
  • Basic knowledge of using network automation libraries like Netmiko and NAPALM
  • CCNA level networking knowledge
Course Description

This course explores introductory and intermediate concepts of Nornir, starting with creating an inventory file, and gradually building an inventory with multiple devices and variables that describe them. After focusing on the inventory data from both static and dynamic sources (such as NetBox), the class will build networking tasks to make configuration changes, gather operational data, and pull device facts using the NAPALM and Netmiko modules.

Nautobot Extensibility

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Source of Truth and Nautobot Fundamentals
  • Network Automation with Python (or equivalent Python experience)
  • Familiarity with Jinja2 Templating
Objectives
  • Understand how existing data models can be extended with Config Contexts and Config Context Validators (using JSON Schema)
  • Configure Config Contexts, Custom Fields, Computed Fields, and Relationships to extend the core data model
  • Create Nautobot Jobs to gain insight into the data in Nautobot and perform basic network automation tasks
  • Learn how to add Jobs, Export Templates, and Config Contexts to Nautobot directly from a Git repository
  • Configure webhooks to trigger notifications in Slack and execute Ansible playbooks based on changes occurring in Nautobot
Course Description

As a Source of Truth platform, Nautobot allows users to define the intended state of their network. Going beyond Nautobot’s core Source of Truth data models, Nautobot has many extensibility features that make it an ideal platform to drive network automation. This course introduces Nautobot extensibility features and how they can be used to tailor Nautobot to integrate into almost any environment. Extensibility features covered in this course include Config Contexts, JSON Schema Validation, using Git as a data source, Relationships, Export Templates, Webhooks, Custom Fields, Computed Fields, and Jobs.

Automating Nautobot with Python and Ansible

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Network Programming & Automation Bootcamp or familiarity and experience with Python programming concepts and Ansible Playbooks
  • Source of Truth and Nautobot Fundamentals
Objectives
  • Learn how to use Python to make REST API calls to Nautoobt
  • Navigate the REST API and GraphQL using the built-in browsers such as Swagger docs and GraphiQL, respectively
  • Articulate the value of the Nautobot GraphQL API
  • Compare and contrast the Nautobot REST API and GraphQL
  • Build Python scripts using pynautobot to fetch data from Nautobot
  • Create Ansible playbook(s) that fetch data from Nautobot and use that data to configure network devices
Course Description

Once there is an understanding of Source of Truth and the integral role Nautobot plays within the network automation journey, the next step is getting familiar with Nautobot APIs and how to consume them. This course introduces the Nautobot REST API, GraphQL API, pynautobot, and the Nautobot Ansible collection.

Telemetry Deep Dive

Course Length: 8 hours/1 day

Level: Intermediate

Prerequisites
  • Bite-sized Session, Telemetry and Visibility
Course Description

The class will explore some of the advanced concepts of Telemetry. We will start with reviewing Prometheus and PromQL, then work through various hands-on examples around the various expressions and operations that can be performed to manipulate and aggregate your time series data. It will then move into exploring Grafana dashboarding and look at the various components and methods that can be used to create dashboards and visualize your time series data.

Building a CI/CD Pipeline

Course Length: 8 hours/1 day

Level: Advanced

Prerequisites
  • Course Network Programming & Automation
  • Course Git & Collaborative Workflows
  • Course Network Configuration Testing with Batfish
Course Description

This session builds on a working knowledge of Ansible, Python, Git, Batfish, and CI/CD concepts, and focuses on constructing a CI/CD pipeline for network automation. The pipeline will perform pre-check validation using configuration files and Batfish, and if checks pass, they will be merged into a Git repository. Upon being merged into a repository, you’ll see how a deployment can be triggered along with post-change validation steps ensuring the code, playbooks, and change worked as expected.

Bite-sized Learning

Our bite-size learnings are 1-hour overviews designed to fit into the busy network engineer’s schedule. Each session gives a brief but thorough overview on a network automation topic, platform, or tools.

  • Designing Networks for Automation
  • Telemetry & Visibility
  • Git Fundamentals
  • Schema Validation (JSON Schema)
  • Batfish
  • Introduction to REST APIs (Postman, Curl, API Docs)
  • Code Linting and Formatting
  • Introduction to Data Structures (JSON, YAML, XML)
  • Rundeck
  • Sources of Truth & NetBox/Nautobot
  • Introduction to GraphQL