Cisco CCNA Automation

Every API and automation tool exchanges structured data. You compare JSON, XML and YAML, learn which is used where, and parse each into Python data structures so you can pull out exactly the field you need.

• JSON syntax and nesting
• XML elements, attributes and namespaces
• YAML and why configuration files favor it
• Comparing the three formats for one dataset
• Parsing JSON and XML into Python
• Validating data before using it

You build A parser that converts one device inventory between JSON, XML and YAML.

Automation code is shared code, so it needs history and structure. You track work in Git, branch and merge without losing changes, resolve conflicts, and organize a project with design patterns that keep it readable.

• Commits, history and the staging area
• Branching, merging and pull requests
• Resolving merge conflicts
• Remote repositories and collaboration
• Model-view-controller and observer patterns
• Structuring a Python project into modules

You build A Git repository with a branching history, a resolved conflict and a clean project layout.

Code that touches the network has to be trusted before it runs. You write unit tests first and code second, compare Agile, Waterfall and DevOps ways of working, and see where each fits an infrastructure team.

• Unit tests with a Python test framework
• Test-driven development: red, green, refactor
• Mocking an API or a device in tests
• Waterfall, Agile and Lean compared
• DevOps and the idea of continuous improvement
• Code review as a quality step

You build A tested module whose unit tests were written before the code.

Most platforms expose a REST API, and reading one is a core skill. You learn how URLs, methods, headers, bodies and status codes fit together, what idempotence means, and how to build a request from documentation.

• Resources, URLs and HTTP methods
• Headers, query strings and request bodies
• Status codes and what they tell you
• Idempotence and safe methods
• Reading API documentation and Swagger or OpenAPI pages
• Trying requests with Postman or curl

You build A saved collection of requests that exercises every method of a public API.

Turn tested requests into automation. You script calls with the requests library, handle token and OAuth authentication, page through large results, respect rate limits, and receive events with webhooks.

• Making requests and parsing responses in Python
• Basic, token and OAuth authentication
• Pagination and rate limiting
• Retrying safely after an error
• Webhooks: receiving events from a platform
• Keeping credentials out of your code

You build A Python client that pages through an API, handles errors and receives a webhook.

Automation is only as good as your picture of the network under it. You cover MAC and IP addressing, VLANs, routing and the control and data planes, DHCP and DNS, and port numbers, then look at how latency and limits change an application’s behavior.

• MAC and IP addressing
• VLANs and routing at a glance
• DHCP, DNS and ports
• Control plane and data plane
• Bandwidth, latency and application behavior
• Firewalls, NAT and load balancers

You build A diagram of how one API call travels from your script to a device and back.

Devices can be managed by data models instead of screen scraping. You read YANG models, send NETCONF and RESTCONF requests, and understand how model-driven telemetry differs from polling.

• Why data models replace the command line for automation
• Reading a YANG module
• NETCONF operations over SSH
• RESTCONF requests and payloads
• Streaming telemetry compared with SNMP polling
• Picking between NETCONF, RESTCONF and CLI

You build A script that reads and changes an interface setting using RESTCONF.

Cisco ships controllers and cloud platforms that expose APIs and SDKs. You work with Meraki, Catalyst Center and Webex, then learn how to approach the documentation of an unfamiliar compute or security platform.

• The Meraki dashboard API and its Python library
• Catalyst Center: authentication, devices and sites
• Webex: bots, messages and meetings through the API
• Compute and security platform APIs in outline
• Finding and using an SDK
• Choosing between a controller API and a device API

You build A Webex bot that reports network device status pulled from a controller API.

Containers package an application with everything it needs. You write a Dockerfile, build and run images, publish ports, attach storage, and connect containers over Docker networks.

• Images, containers and registries
• Writing a Dockerfile
• Running, stopping and inspecting containers
• Ports, volumes and environment variables
• Docker networks and how containers find each other
• Keeping images small and clean

You build A containerized Python service with its own Dockerfile and a published port.

Shipping automation should be as repeatable as running it. You compare ways to deploy an application, read a pipeline definition, and see how build, test and deploy stages catch mistakes before they reach production.

• Bare metal, virtual machine, container and serverless
• Blue-green, canary and rolling deployments
• Continuous integration and continuous delivery
• Reading a pipeline file stage by stage
• Automated tests as a pipeline gate
• Rolling back a bad release

You build A pipeline that tests a script, builds its image and deploys it on a merge.

Automation holds powerful credentials, so its security matters. You learn the threats that web applications and APIs face, including those the OWASP list describes, how to handle secrets, and how encryption protects data in transit.

• Injection and cross-site scripting
• Broken authentication and access control
• Secrets: environment variables and vaults
• Encrypting data in transit with TLS
• Dependency risks and scanning
• Least privilege for automation accounts

You build A security review of a sample app that finds and fixes four weaknesses.

Describe infrastructure in files and let tools apply it. You read Ansible playbooks, Terraform plans and Bash scripts, see what Cisco NSO adds for network services, and use simulation to test changes safely.

• The idea behind infrastructure as code
• Ansible inventories, modules and playbooks
• Terraform providers, plans and state
• Cisco NSO and service models in outline
• Bash for glue tasks
• Testing in a simulated network before production

You build An Ansible playbook that configures a lab device and a check that it worked.

Join code, APIs, containers and pipelines into one working solution. You pick a real network task, script it, test it, package it, secure it and ship it through a pipeline.

• Choosing a task worth automating
• Designing the script and its data flow
• Writing tests and the container image
• Securing credentials and access
• Shipping through a pipeline and monitoring the result

You build A complete automation project in Git, containerized, tested and deployed by pipeline.