Cisco CCNP Automation

Python and REST are the common ground of every tool you will use. You structure automation code, call APIs with authentication and error handling, and write clients that survive timeouts and bad responses.

• Structuring a Python automation project
• REST requests with authentication
• Pagination, retries and rate limits
• Parsing and validating responses
• Reusable API client classes
• Logging and exit codes for scripts

You build A reusable Python client for a network controller API, with error handling.

Data models give configuration a stable shape. You read YANG models, build RESTCONF requests to read and change device configuration, and compare this approach with CLI and controller APIs.

• YANG models as the contract with a device
• RESTCONF methods and URL structure
• JSON and XML payloads from a model
• Reading and changing interface and routing data
• Handling errors and partial failures
• When RESTCONF is the right interface

You build A script that configures a set of interfaces over RESTCONF from a data file.

Ansible turns a change into a repeatable playbook. You build inventories, use network collections and Jinja templates, organize work into roles, and protect secrets with Ansible’s vault.

• Inventories, groups and variables
• Network modules and collections
• Jinja templates for configuration
• Roles and project layout
• Check mode and dry runs
• Encrypting secrets with Ansible Vault

You build An Ansible role that renders and applies a standard configuration across a lab.

Terraform tracks what exists and what should. You write configurations with providers and modules, read plans before applying, manage state carefully, and know where Terraform fits beside Ansible.

• Providers, resources and variables
• Plan, apply and destroy
• State files and remote state
• Modules for repeatable patterns
• Importing existing infrastructure
• Terraform and Ansible in one workflow

You build A Terraform module that builds a small network service and shows its plan.

Automation is only as accurate as its data. You model devices, addresses and VLANs in one authoritative system, and drive configuration and checks from it instead of from spreadsheets.

• What a source of truth holds and why
• Modeling devices, sites, IP space and VLANs
• Reading and writing it through an API
• Rendering configuration from its data
• Detecting drift from the intended state
• Keeping the data trustworthy over time

You build A source of truth for a lab that generates device configurations through templates.

Network changes deserve the same discipline as software. You work with branches and merge requests, write GitLab pipelines that lint, test and deploy, and debug a pipeline that fails.

• Branching strategies for infrastructure code
• Merge requests and review
• Pipeline stages, jobs and runners
• Variables, secrets and artifacts in a pipeline
• Reading logs to debug a failing pipeline
• Approvals and protected environments

You build A GitLab pipeline that lints, tests and deploys a network change after approval.

Test changes before they touch production. You build virtual topologies in Cisco Modeling Labs, package automation services in containers, and run several of them together with Docker Compose.

• Building a virtual topology in Cisco Modeling Labs
• Driving a lab from code
• Dockerfiles for automation tools
• Docker Compose for multi-service setups
• Networking between containers
• Using a lab inside a pipeline

You build A virtual lab and Compose stack that a pipeline spins up to test a change.

You cannot trust automation you cannot watch. You subscribe to model-driven telemetry, structure your own logs so they can be searched, and decide what an automated system must record about every change it makes.

• Model-driven telemetry subscriptions
• Dial-in and dial-out telemetry compared
• Structured logging for automation code
• Log levels, retention and correlation
• Recording who or what changed what
• Alerting on failed automation runs

You build A telemetry subscription and structured log that together audit an automated change.

A change is finished when it is proven. You write pyATS tests that capture state before and after, parse device output into data, compare the two, and fail a pipeline when the network does not match intent.

• Testbeds and connecting to devices
• Parsing command output into structured data
• Pre-change and post-change snapshots
• Diffing network state
• Writing test cases and reading results
• Running validation inside CI

You build A pyATS job that snapshots a lab before and after a change and reports differences.

Automation holds the keys to the network. You manage TLS certificates for API endpoints, keep secrets out of code, validate inputs, and apply least privilege to the accounts automation uses.

• TLS for API endpoints and certificate chains
• Creating, installing and renewing certificates
• Secrets management in code and pipelines
• Input validation and injection risks
• Least privilege for automation accounts
• Scanning dependencies and images

You build A hardened automation service with managed certificates and no secrets in its repository.

AI writes code and recommends changes quickly, and sometimes wrongly. You weigh the risks of AI-generated automation, review it as you would a stranger’s pull request, and check the accuracy of an AI recommendation before acting on it.

• What AI code assistants do well and badly
• Security and licensing risks in generated code
• Reviewing AI-written automation
• Testing generated code before trusting it
• Checking the accuracy of AI recommendations
• Policy for AI use in change processes

You build A review record for one AI-generated script, with the defects found and fixed.

Language models can operate tools if you give them a safe interface. You build an MCP server that exposes network actions, connect an LLM-based conversational agent to it, and limit what it may do.

• What the Model Context Protocol provides
• Designing tools an agent can call safely
• Building an MCP server for network queries
• A conversational agent built on an LLM
• Read-only against change-capable tools
• Approvals, logging and evaluation of agent actions

You build An MCP server and chat agent that answer network questions and ask approval before any change.

Combine tools, data, pipeline and validation into one working platform. You model the network, automate its configuration, test the change, validate it live and operate it with logs and alerts.

• Modeling the network and choosing tools
• Building automation from the source of truth
• Testing in a lab and in the pipeline
• Validating and monitoring after deployment
• Documenting and handing over the platform

You build A complete change-through-pipeline workflow on a lab network, with tests and monitoring.