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!
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.
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.
While there are no programming, software/dev, or automation prerequisites, students should have basic familiarity with:
Part 1 – Network Automation with Python
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.
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.
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.
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.
This module starts late on Day 3 and finishes on Day 5.
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.
While there are no programming, software/dev, or automation prerequisites, students should have:
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.
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).
While there are no programming, software/dev, or automation prerequisites, students should have:
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
Writing Scripts and Using Network APIs
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.
Students should have basic familiarity with:
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.).
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.
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.
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.
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.
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.
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.
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.
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.
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!
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)
Share details about yourself & someone from our team will reach out to you ASAP!
