Cisco CCIE Automation

Pipelines are where automation becomes dependable. You manage branching and review in Git, design pipeline stages for linting, testing and deployment, and diagnose both failing pipelines and slow ones.

• Branching, rebasing and merge strategies
• Pull request review for infrastructure code
• Pipeline stages, runners and artifacts
• Caching and parallelism for faster pipelines
• Reading logs to troubleshoot a failing pipeline
• Finding performance bottlenecks in a pipeline
• Promotion between environments

You build A multi-stage pipeline with tests and promotion, plus a record of faults you fixed in it.

Expert automation often means building the tools yourself. You write REST services with a Python framework, build command-line tools with proper arguments, and consume APIs you have never seen before.

• Designing a REST API for network tasks
• Building a service with a Python web framework
• Request validation and error responses
• Writing command-line tools with argument parsing
• Reading unfamiliar API documentation and consuming it
• Testing a service and a tool

You build A REST service and companion command-line tool that expose one network task.

Model-driven management begins with the model. You read YANG, generate valid NETCONF and RESTCONF payloads from it, handle errors and edge cases, and validate payloads before they touch a device.

• Reading YANG: containers, lists, leaves and types
• Generating payloads from a model
• NETCONF operations and datastores
• RESTCONF requests and encoding choices
• Validating a payload before sending it
• Interpreting and handling error replies

You build A payload generator that builds and validates configuration from a YANG model.

Ansible at expert level means reusable, tested roles. You structure roles and collections, template configuration, handle idempotence on network devices, and test playbooks before they run on real equipment.

• Role and collection structure
• Variables, precedence and inventory design
• Jinja templating for device configuration
• Network resource modules and idempotence
• Error handling and rescue blocks
• Testing roles in a lab

You build A tested Ansible role that configures a feature on multiple device types.

Terraform manages what exists, not just what you add. You write modules, manage state safely across a team, plan and apply change with review, and combine Terraform with other tools.

• Providers, resources and data sources
• Writing and versioning modules
• Remote state and locking
• Reading a plan critically
• Handling drift and importing resources
• Terraform inside a pipeline

You build A Terraform module for a network service, applied through a reviewed pipeline.

NSO turns service intent into device change across a multi-vendor network. You model a service in YANG, map it to device configuration with templates and code, and test deployment, rollback and conflict handling.

• NSO architecture: services, devices and the database
• Network element drivers and onboarding devices
• Writing a service model in YANG
• Service templates and Python service code
• Dry runs, commit and rollback
• Reconciling out-of-band device changes

You build An NSO service package that provisions one network service across two devices.

Devices expose many ways to be driven. You script IOS XE with Python and SDKs over NETCONF, RESTCONF and the command line, compare their trade-offs, and build resilient device clients.

• Choosing a device interface for a task
• Python SDKs for device access
• Configuration and state retrieval over NETCONF
• RESTCONF clients in Python
• Handling timeouts, locks and failures
• Parsing device output into structured data

You build A device client library that reads state and applies configuration using two interfaces.

Automation that changes the network must also prove the result. You build testbeds, write pyATS tests that check state before and after change, and wire them into your pipeline.

• Testbed files and device connections
• Parsers and structured state
• Writing test cases and test jobs
• Pre- and post-change comparison
• Reading results and reports
• Using tests as a pipeline gate

You build A pyATS job that verifies a configuration change and fails the pipeline when it breaks intent.

Telemetry replaces polling with streams. You design subscriptions, choose periodic or on-change delivery, pick transport and encoding, and consume the stream in a collector you write.

• Telemetry architecture and data paths
• Dial-in and dial-out subscriptions
• Periodic against on-change updates
• Encoding and transport options
• Selecting paths from a YANG model
• Writing a simple collector
• Troubleshooting a silent subscription

You build A telemetry subscription and collector that stores interface metrics and flags anomalies.

Automation services ship as containers. You write efficient Dockerfiles, compose multi-service applications, understand and debug Docker networking, and deploy to Kubernetes with its core objects.

• Dockerfile design: layers, size and caching
• Docker Compose for multi-service applications
• Docker networks, DNS and published ports
• Troubleshooting container networking
• Kubernetes pods, deployments and services
• Configuration and secrets in Kubernetes
• Diagnosing a failing deployment

You build A multi-service application running under Compose and deployed to a Kubernetes cluster.

Automation holds the most powerful credentials on the network. You apply secure coding practice, create certificate requests with OpenSSL, obtain and refresh OAuth2 tokens, and manage secrets so none ever sit in code.

• OWASP risks as they apply to automation services
• Input validation and safe handling of untrusted data
• Generating keys and certificate signing requests with OpenSSL
• OAuth2 grant types and token handling
• Secrets management in code, containers and pipelines
• Auditing an automation service for weaknesses

You build A hardened automation service using certificates, OAuth2 tokens and a secrets store.

Agents are becoming a way to operate infrastructure. You expose network actions through an MCP server, build an agent that uses them, and design the limits, approvals and tests that keep it safe.

• Agent architecture: model, tools, memory and loop
• Building an MCP server around network tasks
• Designing tools with narrow, safe permissions
• Authentication and authorization for agent actions
• Testing and evaluating agent behavior
• Audit logging and human approval points

You build An MCP server and agent that perform a read-only diagnosis and request approval for any change.

Join every skill in one solution. You design the platform, build services and automation, containerize and secure it, validate it with tests and telemetry, and deploy it through a pipeline.

• Designing the platform and its interfaces
• Building services, playbooks and models
• Containerizing and securing the solution
• Validating with tests and telemetry
• Deploying and troubleshooting through the pipeline

You build A complete network automation platform, deployed by pipeline and verified with tests and telemetry.