Curriculum Library

Curriculum Library

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!

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

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.

  • 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

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

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

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.

Source of Truth & Nautobot Fundamentals Course Length : 2-day Bootcamp, 8 hours per day Level : Beginner

  • 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

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.

Automating Networks with Ansible I Course Length : 3-day Bootcamp, 8 hours per day Level : Beginner

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

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

  • 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.

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).

  • 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 I Course Length : 3-day Bootcamp, 8 hours per day Level : Beginner

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

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 Python II Course Length : 3-day Bootcamp, 8 hours per day Level : Intermediate

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.

  • 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.

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

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

  • 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

  • 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

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

  • 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

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

Good understanding of Ansible, Linux commands, and programming concepts in Python

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.

Introduction to Telemetry: Data Collection, Dashboarding and Alerts Course Length : 2.5 day course, 8 hours per day Level : Beginner to Intermediate

  • Familiarity with Docker and basic Python skills
  • Basic networking knowledge, e.g., CCNA network operations experience, e.g., IP address management, rack, cabling, etc.
  • Familiarity with network management tools and protocols such as SNMP is beneficial

  • Understanding of Telegraf components and configuration
  • Telegraf Deployment and management methods
  • Metrics data normalization for SNMP and gNMI ingested data
  • Basic network dashboard development with Grafana
  • Basic alerting rules with PromQL and Alertmanager

Package V starts with an in-depth one-day introduction to telemetry and monitoring capabilities from a data collection perspective. We will understand fundamental concepts of monitoring technologies, such as SNMP and gNMI, and how they relate to different network vendors. We then move to the introduction of Telegraf as an agent to learn how it can be used to gather meaningful metrics from your system. We then move to a one-day workshop focused on the understanding of data normalization and enrichment, where we will discover how Nautobot can help us enrich our metrics. And finally, we focus on storing, visualizing, and alerting based on metrics we have collected, normalized, and enriched so far with Prometheus and Grafana.

At the end of these sessions, students will be able to apply their knowledge and skills to build their own Telegraf agents to collect, normalize, and enrich metrics from network infrastructure and be able to visualize and alert on it.

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.

Getting Started with Linux and Text Editors Course Length : 4 hours Level : Beginner

Eagerness to jump into the world of network automation!

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

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

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.

Introduction to Jinja Templating within Ansible Course Length : 4 hours Level : Beginner

Basic understanding of Ansible, Linux commands, and programming concepts

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

  • 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

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

  • 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

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

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

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

Understanding of programming languages and typical development environments, basic Linux commands familiarity

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

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

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

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

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

  • Source of Truth and Nautobot Fundamentals
  • Network Automation with Python (or equivalent Python experience)
  • Familiarity with Jinja2 Templating

  • 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

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

  • Network Programming & Automation Bootcamp or familiarity and experience with Python programming concepts and Ansible Playbooks
  • Source of Truth and Nautobot Fundamentals

  • 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

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

Bite-sized Session, Telemetry and Visibility

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.

Implementing CI/CD for Network Automation Course Length : 8 hours/1 day Level : Advanced

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

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.

Prometheus Stack Course Length : 1-day Workshop, 8 hours per day Level : Advanced

  • YAML – intermediate level
  • Python – basic level
  • Docker and containers – basic level
  • Basic understanding of networking concepts (CCNA level) and database concepts

  • Understand the semantics of PromQL
  • Evaluate the Telegraf, Prometheus, Grafana (TPG) stack for the needs of a network  production monitoring environment
  • Write advanced queries in PromQL
  • Apply telemetry design ideas to network monitoring problems
  • Deploy a complete stack with TPG for a realistic monitoring scenario

This is a deep dive in one of the most prevalent telemetry stacks for network monitoring, theTPG stack (Telegraf, Prometheus, Grafana). This is a stack of choice for network engineers because of the richness and extensibility of Telegraf plugins, the scalability of Prometheus for large data collection, and the user experience of Grafana dashboards specializing in depicting time series.

The training includes three parts: Prometheus Query Language (PromQL), advanced Grafana dashboarding, and alerting. It starts with the basics of PromQL and then works towards advanced queries, including statistical functions, aggregation, and filtering. Hands-on problem-solving exercises are given with a cloud-based Prometheus server where the queries can be tested. The basics of dashboards as code using Grafana are discussed at the second part of the training along with some advanced visualizations and Grafana configurations. Lastly, we will be leveraging our PromQL skills to create meaningful alerts using Alertmanager. Troubleshooting techniques to detect connectivity and configuration issues in the stack will be demonstrated. A recap project is given to the students where they configure a full TPG stack, retrieve data, and create specific graphs.

Influx Stack Course Length : 1-day Workshop, 8 hours per day Level : Advanced

  • YAML – intermediate level
  • Python – basic level
  • Docker and containers – basic level
  • Basic understanding of networking concepts (CCNA level) and database concepts

  • Understand the concepts and pros and cons of Influx deployment models of OSS vs Enterprise
  • Evaluate the Telegraf, Influx, Grafana (TIG) stack for the needs of a network production monitoring environment
  • Learn beginner and advanced queries with Flux
  • Create dashboards in Grafana
  • Understand Kapacitor and its use for aggregations and alerting
  • Deploy a complete stack with TIG for a realistic monitoring scenario

This course is a deep dive into one of the leading telemetry stacks for observability. With both open-source and enterprise offerings, along with a powerful ETL component, it can easily be deployed to successfully monitor millions of metrics per second. The plugin richness of Telegraf coupled with the user experience of Grafana to display metrics allows Network Engineers to replace aging technology and explore their networks with powerful correlation and alerting methods that will help with the most important metric: mean time to resolve.

The training includes four parts: Influx OSS or Enterprise, Flux query language, Grafana dashboarding, and Kapacitor. We start by exploring the pros and cons of choosing Open Source or Enterprise. Next up, we learn about the Flux query language by leveraging it to retrieve metrics followed by more in-depth examples using basic statistics and aggregations. Then we learn about dashboards as code using Grafana. Finally, we will touch on Kapacitor and its power as an ETL component for alerting and aggregation. Troubleshooting techniques will be demonstrated to detect connectivity and configuration issues in the stack. A recap project is given to the students where they configure a full TIG stack, retrieve data, and create specific graphs.

Elastic Stack Course Length : 1-day Workshop, 8 hours per day Level : Advanced

  • YAML – intermediate level
  • Python – basic level
  • Docker and containers – basic level
  • Basic understanding of networking concepts (CCNA level) and database concepts

  • Understand the concepts of the Elastic stack
  • Evaluate the Telegraf, Elasticsearch, and Kibana (TEK) stack for the needs of a network production monitoring environment
  • Learn how to perform data queries in KQL 
  • Create dashboards in Kibana
  • Deploy a complete stack with TEK for a realistic monitoring scenario

This course is a deep dive into one of the most widely deployed observability solutions, built on the proven ELK Stack to converge metrics, logs, and traces, delivering unified visibility and actionable insights.

The training includes four parts: Understanding of the Elastic Stack and their Observability solution and seeing the capabilities offered in their OSS and Enterprise solution. Next, we move into setting up Telegraf to send telemetry data to Elasticsearch and understand the inner workings of the network agent. Then we move to understanding how data is stored in Elasticsearch and how we can query in Kibana via KQL. Lastly, we showcase dashboards creations for a realistic monitoring scenario on Kibana.

By the end of this course, the student will be able to understand the basic concepts of the Elastic Stack, and with the knowledge acquired on the data collection and normalization phase, be able to create meaningful dashboards for Network Infrastructure Operations.

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!

Contact Us

Bite-Sized Learning

5+ years of experience in IP networking technologies

Telemetry & Visibility

Git Fundamentals

Schema Validation (JSON Schema)

Batfish

Code Linting and Formatting

Introduction to Data Structures (JSON, YAML, XML)

Rundeck

Sources of Truth & NetBox/Nautobot

Introduction to REST APIs (Postman, Curl, API Docs)

ntc img
ntc img

Contact Us to Learn More

Share details about yourself & someone from our team will reach out to you ASAP!