CCNA Cisco Network Automation Study Guide

Network automation means using software and tools to automatically manage, configure, and monitor network devices. Instead of logging into each device manually, you write code or use tools to handle these tasks at scale.

What APIs Enable

Application Programming Interfaces (APIs) allow different software systems to communicate and exchange data automatically. RESTful APIs are especially important in Cisco environments because they let you control network devices through code. APIs eliminate the need to SSH into devices and type commands manually.

Key Automation Benefits

Network automation delivers real-world advantages:

• Reduces human error in configurations
• Speeds up deployment across many devices
• Enables consistent configurations across infrastructure
• Frees engineers to focus on strategic work instead of repetitive tasks
• Lowers operational costs through efficiency

Infrastructure as Code Approach

Infrastructure as code (IaC) treats network configurations like software code. You version-control configurations, review changes before applying them, and roll back mistakes easily. This practice transforms how teams manage networks.

Essential Automation Frameworks

Ansible uses agentless architecture and YAML syntax for playbooks, making it beginner-friendly. Puppet and Chef are configuration management tools for larger enterprises. The CCNA curriculum focuses on understanding how these tools interact with Cisco devices through APIs and protocols.

Imperative vs. Declarative Automation

Imperative automation focuses on the step-by-step process to achieve a goal. You write code that says "do this, then this, then that." Declarative automation focuses on describing the desired end state and lets the tool figure out how to achieve it. Understanding this distinction helps you choose the right approach for different problems.

Python dominates network automation because it has simple syntax, extensive libraries, and strong community support. You don't need to become a software developer, but you must understand Python fundamentals to write network automation scripts.

Core Python Concepts You Need

Focus on these Python basics:

• Variables and data types (strings, integers, lists, dictionaries)
• Loops and conditionals (if/else statements, for loops, while loops)
• Functions and reusable code blocks
• Working with lists and dictionaries to store and organize data
• Reading and writing files

These foundations enable you to write practical network automation scripts.

Network-Specific Python Libraries

Three libraries are essential for CCNA studies:

1. netmiko: Simplifies SSH connections to Cisco devices and command execution
2. requests: Makes HTTP calls to APIs and handles responses
3. paramiko: Provides secure SSH communications for device connectivity

Netmiko is particularly valuable because it handles SSH authentication and device interaction automatically.

Parsing Output and Templates

TextFSM and Jinja2 help you parse network device output and generate configurations. Jinja2 templating lets you create dynamic configurations based on variables. Instead of writing the same configuration repeatedly, you define it once as a template and fill in different values.

Working with Data Formats

JSON and YAML are standard in modern automation. JSON is human-readable and works with APIs easily. YAML is used extensively in Ansible playbooks and is simpler to read than JSON.

Practical Script Development

Start by writing simple scripts that:

• Connect to network devices
• Retrieve device information
• Parse the output
• Make basic configurations

Progress to more complex tasks like device backups and configuration audits. Use Git version control to track changes and collaborate with teammates.

APIs provide standardized ways for programs to communicate with network devices. Representational State Transfer (REST) is an architectural style that uses HTTP methods to perform operations. Cisco devices increasingly expose REST APIs, making this essential knowledge for network automation.

HTTP Methods in REST

REST uses five main HTTP methods:

1. GET: Retrieves information without changing anything
2. POST: Creates new resources
3. PUT: Completely updates existing resources
4. PATCH: Partially updates resources
5. DELETE: Removes resources

When you interact with Cisco devices like IOS-XE, you'll use these methods to configure and monitor them.

NETCONF and YANG Standards

NETCONF (Network Configuration Protocol) provides a framework for installing, manipulating, and deleting network device configurations over SSH. YANG is a data modeling language that defines the structure of configuration and state data on network devices. These standards enable more reliable configuration management compared to sending raw CLI commands.

NETCOF uses XML-based messages and provides better error handling and transaction support than traditional CLI methods.

Understanding HTTP Status Codes

HTTP responses include status codes that tell you what happened:

• 200: Request succeeded
• 201: Resource created successfully
• 400: Your request had an error (bad syntax or invalid data)
• 401: Authentication failed (missing or invalid credentials)
• 500: Server encountered an error

Recognizing these codes helps you debug automation issues quickly.

Authentication and Security

REST APIs require authentication, typically using:

• API keys or tokens
• Basic authentication (username and password)
• OAuth for more complex environments

Never hardcode credentials in scripts. Use configuration files or environment variables to store sensitive information securely.

Constructing API Requests

JSON payloads are commonly used in REST API requests and responses. Learning to construct proper JSON structures is essential. Use tools like Postman or curl to test API requests before writing Python scripts. This visual approach helps you understand request and response structures clearly.

Different automation tools serve different purposes. Understanding their strengths helps you choose the right tool for your situation.

Ansible: Agentless Automation

Ansible uses SSH to connect to devices and run tasks defined in playbooks written in YAML format. The agentless architecture means you don't install software on target devices, making deployment simpler and more secure.

Ansible playbooks contain:

• Plays: Target specific hosts and define what to do
• Tasks: Individual actions like running commands or copying files
• Roles: Organized, reusable playbooks with templates and variables

Variables enable dynamic configuration. Jinja2 templating adds conditional logic and loops. Ansible includes network modules for Cisco devices:

• ios_command: Executes commands on IOS devices
• ios_config: Manages device configurations
• ios_facts: Gathers device information automatically

Ansible is beginner-friendly and widely adopted, making it the recommended starting point for CCNA studies.

Puppet: Agent-Based Configuration Management

Puppet uses agents installed on target systems. You describe the desired state in a declarative language, and the agent works to achieve it. Puppet agents regularly check for configuration updates from a central server. This pull-based model works well for large enterprise environments where you need autonomous compliance checking.

Puppet has a steeper learning curve than Ansible but provides powerful capabilities for complex environments.

Chef: Code-Based Configuration Management

Chef uses Ruby-based recipes and cookbooks to define configurations. Like Puppet, Chef uses agents and a pull-based model. Teams with strong Ruby programming backgrounds often prefer Chef. However, it requires more infrastructure and expertise to implement effectively.

Push-Based vs. Pull-Based Models

Understand the key differences:

• Push-based (Ansible): Control server sends commands to devices
• Pull-based (Puppet, Chef): Agents on devices request updates from server

Push-based tools like Ansible are faster for quick deployments. Pull-based tools are better for ensuring continuous compliance in large environments.

Terraform for Infrastructure as Code

Terraform is increasingly used for infrastructure as code, allowing you to define network topology and device configurations in a declarative language. It works across multiple cloud and on-premises platforms.

Effective preparation requires both conceptual understanding and hands-on practice. Combine multiple study methods to engage different learning styles and build lasting knowledge.

Build a Structured Study Plan

Allocate study time proportionally to exam weight. Network automation typically comprises 15 to 20 percent of the CCNA exam. Spend roughly 40 percent of your network automation time on hands-on labs and 60 percent on concepts and practice questions. Start with foundational concepts before moving to practical implementation. Gradually increase difficulty as your knowledge grows.

Use Flashcards Strategically

Flashcards excel at memorizing:

• API methods and HTTP status codes
• Python syntax and common functions
• Tool-specific commands (Ansible module names, Puppet syntax)
• YAML and JSON structure examples
• Key concepts and definitions

Review flashcards during short study sessions when you have limited time. Space out reviews over weeks to strengthen long-term memory.

Set Up Hands-On Labs

Practical experience is non-negotiable. Options include:

• Cisco DevNet Sandbox: Free access to real Cisco devices
• GNS3: Run Cisco IOS images in virtual environments
• Virtual machines: Use VirtualBox or VMware for isolated environments
• Cisco Modeling Labs: Advanced simulation platform

Start with simple tasks and increase complexity gradually. Document everything you learn.

Practice Writing Automation Code

Write Python scripts that connect to devices, retrieve information, and make configurations. Start simple and build complexity. Test API calls using Postman before coding them in Python. This visual approach clarifies request and response structures.

Supplement with Multiple Resources

Engage different learning styles:

• Read official Cisco documentation and certification guides
• Watch tutorials and webinars from experienced engineers
• Join online communities and forums to ask questions
• Review practice exams to identify weak areas
• Create your own reference guides

Manage Your Time and Review Effectively

Practice time management during studies. Allocate time based on topic complexity and your background. Review weak areas frequently to build confidence. Take practice exams to familiarize yourself with question formats. Remember that network automation constantly evolves, so continued learning beyond certification adds career value.