Examkin

Capabilities of Configuration Management Mechanisms (Puppet, Chef, Ansible)

24 questions

All types24Multiple choice13Multiple select6Matching5
Question 1Question →

A network engineering team is evaluating configuration management tools to automate Cisco IOS XE switch deployments. The architecture mandates that managed network devices must not require a persistent local management daemon or software agent, and all configuration task execution must be driven from a central control node using native management protocols and human-readable YAML files.

Which of the following operational characteristics correctly describe the selected configuration management tool? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: The framework utilizes a push-based communication model where the control node initiates management sessions directly to target network devices.; Configuration tasks are defined in playbooks and executed across endpoints over standard SSH or NETCONF transport protocols.

Answer

The configuration management mechanism described is Ansible, which uses a push-based communication model from a control node over standard transport protocols (SSH/NETCONF) with YAML playbooks and requires no agent software on target endpoints.
The scenario describes Ansible, which is unique among the three major configuration management tools for being completely agentless on target network devices. Ansible relies on a push-based model where the control node opens standard transport sessions (such as SSH or NETCONF) to execute tasks defined in YAML playbooks.

Step-by-Step Solution

1
Analyze the architectural requirements stated in the scenario.
The requirements specify an agentless architecture, central control node driving execution, native management protocols (SSH/NETCONF), and YAML files.
Identifying these key attributes narrows the tool down to Ansible, distinguishing it from agent-based pull systems like Puppet and Chef.
2
Evaluate the delivery mechanism and transport method of Ansible.
Ansible uses a push model where the control node initiates connections to managed devices using SSH or NETCONF.
Because no persistent agent daemon is installed on managed network switches, Ansible relies on native network management transport protocols.
3
Verify file structure and contrast with alternative mechanisms.
Ansible uses YAML playbooks. In contrast, Puppet uses Puppet DSL manifests over TCP 8140 (pull), and Chef uses Ruby recipes/cookbooks over TCP 443 (pull).
This confirms that options describing push-based execution over SSH/NETCONF and YAML playbooks are correct, while options referring to TCP 8140 pull operations or Ruby cookbooks describe Puppet and Chef.

Key Concept

Ansible Agentless Push Architecture and Protocol Capabilities
Estimated Time:2m 0s
Question 2Question →

A network architect is designing an automated configuration management solution for a large Enterprise network containing hundreds of Cisco IOS XE routers and NX-OS switches. The architecture requirements mandate minimizing device-level software overhead by avoiding persistent agent installations, using standard SSH/NETCONF protocol transport, leveraging YAML-formatted state files, and initiating configuration updates using a push-based model from a control node. Which configuration management tool satisfies all specified requirements, and which operational characteristics define its framework?

Show answer & explanation

Answer: Ansible, because it functions agentlessly over SSH or NETCONF using a push-based model to execute YAML-defined playbooks without requiring client software on managed devices.

Answer

Ansible satisfies all requirements because it operates agentlessly over standard SSH or NETCONF transport, uses a push model initiated by the control node, and defines configuration tasks using YAML playbooks.
The correct answer accurately identifies Ansible's core architectural traits: it is agentless, uses SSH or NETCONF transport protocols, operates on a push model initiated by the administrator/control node, and uses readable YAML-formatted playbooks.

Step-by-Step Solution

1
Analyze architecture requirement 1: Agentless operation over standard transport (SSH/NETCONF).
Ansible is inherently agentless for network devices, using native SSH or NETCONF sessions. Puppet and Chef typically rely on agent-based pull models or agent proxy daemons.
Eliminating agent installation on network switches/routers requires a tool designed for agentless management.
2
Analyze architecture requirement 2: Push-based execution vs Pull-based execution.
Ansible pushes configuration tasks from the control node to target devices upon command. Puppet and Chef nodes default to pulling configuration updates periodically from a central server.
Push models allow immediate targeted deployment from the control system without waiting for agent polling intervals.
3
Analyze architecture requirement 3: Data format / configuration structure.
Ansible uses YAML for its Playbooks. Puppet uses Puppet DSL (Manifests), and Chef uses Ruby DSL (Recipes/Cookbooks).
Matching the specified file format confirms Ansible as the correct mechanism.

Key Concept

Core architectural differences between Ansible (agentless, push, SSH/NETCONF, YAML), Puppet (agent-based/pull, TCP 8140, Puppet DSL), and Chef (agent-based/pull, TCP 443, Ruby DSL).
Estimated Time:1m 30s
Question 3Question →

A network administrator needs to select a configuration management tool to automate Cisco router configurations. The organization mandates an agentless architecture that executes playbooks over standard SSH or NETCONF connections without installing software on target devices. Which tool satisfies this requirement?

Show answer & explanation

Answer: Ansible

Answer

Ansible meets the requirement because it operates using an agentless architecture and executes playbooks over SSH or NETCONF.
Ansible uses an agentless architecture that does not require host agent software. It pushes configurations to network devices over standard management protocols such as SSH or NETCONF using structured YAML playbooks.

Step-by-Step Solution

1
Identify key requirements from the scenario.
The requirement calls for an agentless configuration tool that uses SSH/NETCONF transport and playbooks.
Network appliances often cannot support third-party agent daemons natively.
2
Evaluate candidate configuration management tools.
Ansible is agentless and uses YAML playbooks over SSH/NETCONF, whereas Puppet and Chef primarily rely on client agents.
Comparing tool architectures identifies Ansible as the match for agentless requirements.

Key Concept

Agentless vs Agent-Based Configuration Management Architecture
Estimated Time:45s
Question 4Question →

Which automation tool uses an agentless architecture to push network configurations to managed devices over SSH?

Show answer & explanation

Answer: Ansible

Answer

Ansible is the configuration management tool that operates using an agentless model and relies on SSH to push configurations to network devices.
The option selecting Ansible is correct because Ansible operates in an agentless fashion using SSH (or NETCONF/RESTCONF) to push YAML-defined configurations (Playbooks) directly from a control workstation to target network switches and routers.

Step-by-Step Solution

1
Identify the key operational requirements in the question: agentless architecture and SSH push mechanism.
The target tool must not require agent software on network routers/switches and must use standard SSH transport.
Cisco network devices often run proprietary operating systems (such as IOS XE) where installing third-party agent software is difficult or unsupported.
2
Evaluate Ansible against these requirements.
Ansible uses Playbooks written in YAML, runs centrally on a control node, and connects to target devices over SSH without installing any agent on the target.
Ansible's native design is inherently agentless and push-based.
3
Evaluate Puppet and Chef against these requirements.
Both Puppet and Chef rely primarily on client/agent software installed on managed hosts to pull configurations periodically.
Puppet uses Manifests/Puppet Agent and Chef uses Recipes/Chef Client.

Key Concept

Agentless Configuration Management with Ansible
Estimated Time:45s
Question 5Question →

A network security team is establishing firewall rules to allow a newly selected configuration management tool to operate between a centralized master server and enterprise network devices. The security policy permits target nodes to periodically initiate encrypted outbound connections over TCP port 8140 to pull declarative configuration manifests written in a native domain-specific language (.pp). Which configuration management mechanism and operational model match these technical requirements?

Show answer & explanation

Answer: Puppet, using an agent-based pull model where target devices initiate communication to fetch manifests from the master server.

Answer

Puppet, using an agent-based pull model where target devices initiate communication to fetch manifests from the master server.
Puppet utilizes an agent-based pull model where managed devices (or proxy agents) periodically connect to the Puppet Master over TCP port 8140 to pull compiled configuration catalogs derived from Puppet DSL manifest files (.pp).

Step-by-Step Solution

1
Analyze the network traffic pattern and port requirement in the scenario.
The requirement specifies outbound connections initiated by nodes over TCP port 8140.
Puppet Master and agent communications default to TCP port 8140, whereas Chef uses TCP port 443 and Ansible uses SSH (TCP port 22).
2
Evaluate the file type and language described in the scenario.
Declarative manifests using .pp files correspond to Puppet DSL.
Puppet uses Puppet DSL stored in manifests (.pp files), Ansible uses YAML playbooks (.yml), and Chef uses Ruby DSL recipes (.rb).
3
Determine the operational direction (push vs. pull) and agent reliance.
Nodes periodically initiating outbound requests to fetch configurations represents a pull-based agent architecture.
Puppet operates predominantly on an agent-based pull model where the managed node requests its compiled catalog from the master.

Key Concept

Puppet Architecture and Operational Characteristics (Agent-Based, Pull Model, TCP 8140, Manifests)
Question 6Question →

A network engineer is evaluating configuration management mechanisms for enterprise network automation. Which TWO statements accurately describe the operational capabilities and architecture of Ansible? (Select two.)

Select all that apply

Show answer & explanation

Answer: It operates using an agentless architecture, communicating with managed devices over standard protocols such as SSH or NETCONF.; It uses YAML-formatted files known as Playbooks to define configuration tasks and desired states.

Answer

The correct statements are those identifying Ansible's agentless architecture over SSH/NETCONF and its usage of YAML-formatted Playbooks for configuration automation.
Ansible is defined by its agentless operational model (connecting over SSH, NETCONF, or REST APIs) and its use of YAML-formatted Playbooks to define configuration tasks. These traits eliminate the need to install and maintain client-side agent daemons on network devices.

Step-by-Step Solution

1
Analyze Ansible's communication model
Ansible executes commands remotely without installing client agent software on target network nodes, leveraging standard protocols such as SSH and NETCONF.
Agentless operation simplifies network management because routers and switches often run closed operating systems where agent installation is restricted.
2
Identify Ansible's data structures and configuration files
Ansible leverages human-readable YAML syntax structured into Playbooks.
YAML Playbooks describe the target host inventories, task modules, and parameters sent from the central control node to managed devices.

Key Concept

Operational capabilities and architecture of Ansible vs Puppet and Chef
Estimated Time:1m 0s
Question 7Question →

A network automation engineer is selecting configuration management tools for an enterprise infrastructure overhaul. Match each configuration management mechanism or artifact on the left with its corresponding operational model, transport mechanism, and configuration language characteristics on the right.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef
Ansible Playbook

Matches

Show answer & explanation

Answer

Ansible matches with the agentless push model using SSH/NETCONF and YAML; Puppet matches with the agent-based pull model communicating over TCP 8140 using Puppet DSL manifests; Chef matches with the agent-based pull model communicating over TCP 443 using Ruby DSL recipes; Ansible Playbook matches with the YAML-encoded file mapping host inventory groups to task executions.
Each automation mechanism exhibits specific architectural and transport signatures. Ansible uses an agentless push architecture over SSH/NETCONF with YAML files (Playbooks). Puppet uses an agent-based pull model communicating over TCP port 8140 with Puppet DSL manifests. Chef uses an agent-based pull model communicating over TCP port 443 (HTTPS) with Ruby DSL recipes.

Step-by-Step Solution

1
Analyze Ansible's core architecture and communication method.
Ansible is agentless, uses an active push model, relies on SSH/NETCONF for network devices, and uses YAML formatting.
Eliminates the requirement to install local daemon agents on network switches and routers.
2
Analyze Puppet's operational model, transport ports, and configuration structure.
Puppet defaults to an agent-based pull model, communicates with a central master over TCP port 8140, and uses Puppet DSL manifests.
Agents periodically poll the Puppet Master to pull catalog updates and maintain state enforcement.
3
Analyze Chef's operational model, transport ports, and configuration structure.
Chef uses an agent-based pull model, communicates with the Chef server over TCP port 443 (HTTPS), and utilizes Ruby DSL recipes/cookbooks.
Chef Client runs periodically on target nodes to pull recipes from the server.
4
Identify the role and structure of an Ansible Playbook.
An Ansible Playbook is the YAML document containing plays, host specifications, and task lists executed by Ansible.
Distinguishes the tool framework (Ansible) from its execution file artifact (Playbook).

Key Concept

Capabilities and Architectural Differences of Network Configuration Management Tools (Ansible, Puppet, Chef)
Question 8Question →

An enterprise network engineering team is evaluating configuration management mechanisms to automate switch provisioning across a campus infrastructure. The network security policy strictly mandates that the selected tool must not require client agent software installation on target devices, must execute configuration pushes on-demand directly from a centralized control node over standard secure transport protocols, and must utilize YAML formatting for configuration code files. Which tool and architectural combination satisfies all specified security and operational requirements?

Show answer & explanation

Answer: Ansible operating with an agentless push architecture using SSH or NETCONF transport and YAML playbooks

Answer

Ansible operating with an agentless push architecture using SSH or NETCONF transport and YAML playbooks
The correct option accurately reflects Ansible's core architecture. Ansible is strictly agentless, requiring no software installation on network nodes. It relies on a centralized push execution model over standard management protocols such as SSH or NETCONF and uses human-readable YAML files structured as playbooks.

Step-by-Step Solution

1
Analyze the constraint requiring no client agent installation on target network switches.
Identifies Ansible as an agentless tool, eliminating traditional agent-based models like Puppet and Chef.
Ansible communicates with network nodes without installing specialized client software by leveraging native protocols like SSH and NETCONF.
2
Analyze the operational direction requirement (on-demand central push vs. client pull).
Confirms Ansible uses a push architecture where the control node initiates configuration deployment.
Puppet and Chef natively operate on a pull model where managed agents poll the master server periodically.
3
Evaluate the file format requirement specified in the policy (YAML).
Validates that Ansible uses YAML for its Playbooks.
Puppet uses its proprietary Puppet DSL (or Ruby), and Chef uses Ruby DSL for recipes and cookbooks.

Key Concept

Capabilities and Operational Models of Configuration Management Tools (Ansible vs. Puppet vs. Chef)
Question 9Question →

A network security policy requires that all configuration management operations across remote branch routers strictly prevent inbound session initiation from central management servers to remote devices. Outbound HTTPS traffic on TCP port 443 initiated by target devices toward the central server is permitted. Which configuration management tool natively meets these architectural constraints while utilizing Ruby-based files to define system state?

Show answer & explanation

Answer: Chef, because it uses an agent-based pull architecture operating over TCP port 443 and defines configurations using Ruby DSL recipes.

Answer

Chef natively operates using an agent-based pull architecture over TCP port 443 (HTTPS) and relies on Ruby-based recipes contained within cookbooks to define device configuration states.
Chef employs an agent installed on managed devices that initiates outbound communication to the central Chef Server over TCP port 443 (HTTPS) to pull its configuration state. Configurations in Chef are authored using a Ruby-based Domain-Specific Language (DSL) organized into recipes and cookbooks, perfectly matching both the port and architectural requirements.

Step-by-Step Solution

1
Analyze the operational direction constraint (inbound vs. outbound).
Since security policies prohibit inbound sessions initiated by the central server, the configuration management system must use a pull-based architecture where the managed node initiates outbound connections.
Chef and Puppet both natively use agent-based pull models, while Ansible primarily uses a push model (where the control node initiates SSH/NETCONF inbound to managed nodes).
2
Evaluate the required transport port and configuration definition language.
Chef client agents initiate outbound HTTPS requests to the Chef server over standard TCP port 443 and parse configuration definitions written in Ruby DSL (recipes/cookbooks). Puppet typically uses TCP port 8140 for agent-master pull communications.
Identifying both the network protocol/port and the underlying formatting language isolates Chef as the correct tool.

Key Concept

Configuration Management Tools Architecture and Capabilities (Ansible vs. Puppet vs. Chef)
Question 10Question →

Match each configuration management tool on the left with its corresponding operational traits, communication protocols, and file terminology on the right.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef

Matches

Show answer & explanation

Answer

Ansible matches with the agentless push architecture using YAML Playbooks over SSH/NETCONF. Puppet matches with the pull model using Puppet DSL Manifests over TCP port 8140. Chef matches with the pull model using Ruby-based Recipes and Cookbooks over TCP port 443.
Ansible is distinct for its agentless push model using SSH and YAML Playbooks. Puppet operates via an agent pull model requesting Manifests over TCP 8140. Chef operates via an agent pull model fetching Ruby-based Recipes and Cookbooks over HTTPS (TCP 443).

Step-by-Step Solution

1
Identify the agent requirement and transport protocol for each tool.
Ansible is agentless (SSH/NETCONF), while Puppet (TCP 8140) and Chef (TCP 443) require client agent software.
Agentless operation is a unique distinguishing operational characteristic of Ansible.
2
Determine the data encoding format or domain-specific language (DSL) used by each tool.
Ansible uses YAML, Puppet uses Puppet DSL, and Chef uses Ruby-based DSL.
File formats directly map to tool-specific terminology and structures.
3
Associate file names and operational direction with each tool.
Ansible uses Playbooks (Push), Puppet uses Manifests (Pull), and Chef uses Recipes/Cookbooks (Pull).
Matching push vs pull and configuration artifact naming establishes complete tool identification.

Key Concept

Capabilities and Architectural Traits of Configuration Management Tools (Ansible, Puppet, Chef)
Question 11Question →

An automation architect is designing a centralized configuration enforcement system for enterprise infrastructure. The system must operate on a pull-based model, where client agents periodically query a master server over TCP port 8140 using code files called manifests. Which configuration management mechanism is being described?

Show answer & explanation

Answer: Puppet

Answer

Puppet
Puppet uses an agent-based, pull model where managed nodes run an agent that periodically requests configuration manifests from the Puppet master server over TCP port 8140.

Step-by-Step Solution

1
Identify the key attributes mentioned in the scenario
The requirements specify a pull-based agent model, communication on TCP port 8140, and configuration files defined as manifests.
These specific operational parameters distinguish Puppet from other configuration management tools.
2
Compare against configuration management tools
Puppet natively uses Puppet DSL manifests and client agents querying the server over TCP port 8140 (HTTPS). Ansible is agentless using SSH/NETCONF and YAML playbooks. Chef uses Ruby recipes over TCP port 443.
Matching all operational parameters uniquely identifies Puppet.

Key Concept

Operational characteristics of Puppet (Agent/Pull, TCP 8140, Manifests)
Question 12Question →

A network administrator is evaluating configuration management tools to automate network parameter deployments across enterprise switches and routers. Which of the following statements correctly describe the architectural capabilities and operational traits of Ansible? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: It operates using an agentless architecture, executing commands over SSH or NETCONF directly on target network devices.; It uses a push model where configuration playbooks written in YAML are sent from a central control node to managed devices.

Answer

Ansible operates using an agentless architecture over standard protocols like SSH/NETCONF, and it uses a push-based model executing YAML playbooks from a central control node.
Ansible is distinguished by its agentless operational design and push configuration model. Configurations are defined using human-readable YAML Playbooks on a central control machine and pushed directly to network devices over standard management protocols such as SSH and NETCONF.

Step-by-Step Solution

1
Identify Ansible's software architecture requirement on target devices.
Ansible is agentless and does not require third-party software agents running on managed network devices.
Ansible communicates directly via native management protocols such as SSH or NETCONF.
2
Determine the communication flow direction and data structure used by Ansible.
Ansible uses a push model and formats playbooks using YAML.
The control node initiates connection to managed nodes and pushes configuration changes specified in YAML Playbooks.

Key Concept

Capabilities and Architectural Differences of Configuration Management Mechanisms (Ansible vs. Puppet vs. Chef)
Estimated Time:1m 0s
Question 13Question →

An enterprise network operations team is standardizing its automation framework for campus switches. The technical requirements specify that configuration definitions must be written using Ruby domain-specific language (DSL) organized into cookbooks, and managed devices must execute a local daemon that periodically pulls state definitions from a central server over HTTPS. Which configuration management tool natively meets these specifications?

Show answer & explanation

Answer: Chef

Answer

Chef natively matches the requirement of using Ruby domain-specific language (DSL) cookbooks and an agent-based pull model over HTTPS.
Chef utilizes an agent-based architecture where managed nodes run the Chef client daemon. This daemon periodically contacts the central Chef server over HTTPS (TCP port 443) to pull configuration state rules written in Ruby DSL, organized into recipes and cookbooks.

Step-by-Step Solution

1
Analyze the configuration language requirement
Identified Ruby domain-specific language (DSL) and cookbooks, which are unique to Chef.
Ansible uses YAML playbooks, Puppet uses Puppet DSL manifests, and Chef uses Ruby DSL recipes and cookbooks.
2
Analyze the operational and transport architecture
Identified an agent-based pull model using HTTPS.
Chef client daemons installed on managed systems periodically pull updated configuration details from the Chef server over HTTPS (TCP port 443).

Key Concept

Configuration Management Mechanism Traits (Chef vs Puppet vs Ansible)
Question 14Question →

An engineer is organizing the network automation architecture for an enterprise deployment. Match each configuration management framework to the combination of operational architecture, primary transport protocol, and configuration file format it utilizes.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef

Matches

Show answer & explanation

Answer

Ansible pairs with the agentless push model using SSH/NETCONF and YAML playbooks. Puppet pairs with the agent-based pull model using TCP port 8140 and Puppet DSL manifests. Chef pairs with the agent-based pull model using TCP port 443 and Ruby DSL recipes.
Each tool is correctly matched based on its core architecture: Ansible is agentless (push, SSH/NETCONF, YAML), Puppet relies on agents over TCP 8140 (pull, Puppet DSL manifests), and Chef relies on agents over TCP 443 (pull, Ruby DSL recipes).

Step-by-Step Solution

1
Identify the operational mode and file type for Ansible.
Ansible does not require software agents on managed nodes; it pushes configuration over SSH/NETCONF using YAML files.
Ansible relies on standard management protocols natively supported on network devices.
2
Identify the operational mode, port, and file type for Puppet.
Puppet agents periodically pull configuration state over TCP port 8140 using manifests compiled in Puppet DSL.
Puppet uses a dedicated master-agent communication port (8140) and standard manifest files.
3
Identify the operational mode, port, and file type for Chef.
Chef client agents pull cookbooks/recipes written in Ruby DSL over HTTPS (TCP port 443).
Chef relies on standard Web HTTPS communication between nodes and the Chef Server.

Key Concept

Configuration Management Mechanism Capabilities (Ansible vs Puppet vs Chef)
Question 15Question →

A network administrator must select a configuration management framework to automate configuration updates on enterprise Cisco IOS XE routers. The network security policy strictly prohibits installing third-party software packages or background client daemons directly on network device operating systems. Which configuration management tool fulfills this operational requirement by using an agentless architecture over standard transport protocols such as SSH?

Show answer & explanation

Answer: Ansible

Answer

Ansible is the correct choice because it functions agentlessly over SSH or NETCONF without installing client software on managed network nodes.
Ansible utilizes an agentless architecture. It connects to network devices using native management protocols (such as SSH, NETCONF, or RESTCONF) and pushes configuration changes directly. Because no persistent agent software or daemon needs to be installed on target network devices, it complies fully with restrictive security policies.

Step-by-Step Solution

1
Analyze the operational constraint specified in the requirement.
The requirement mandates an agentless configuration tool that does not require client daemon installation on the router operating system.
Security directives prevent modifying the underlying network operating system image with third-party daemons.
2
Evaluate the architectural models of the configuration management tools.
Ansible uses an agentless push model via SSH/NETCONF, while Puppet, Chef, and SaltStack traditionally use agent daemons running locally on managed nodes.
Ansible executes playbooks remotely and parses device output without needing local agent software.

Key Concept

Agentless vs. Agent-Based Configuration Management Architectures
Estimated Time:1m 0s
Question 16Question →

A network automation engineer is selecting a configuration management tool for a enterprise network environment. The organizational policy mandates an agentless architecture that uses SSH or NETCONF for transport, executes configuration tasks defined in YAML files from a centralized control machine, and pushes updates directly to managed switches and routers without installing persistent client daemons. Which configuration management tool satisfies these operational requirements?

Show answer & explanation

Answer: Ansible

Answer

Ansible is the configuration management tool that fulfills the requirement for an agentless architecture utilizing SSH/NETCONF transport, YAML configuration files (playbooks), and a push execution model.
Ansible is uniquely designed as an agentless configuration management system that communicates directly with managed devices via native transport mechanisms such as SSH or NETCONF. It uses human-readable YAML syntax for its configuration files (playbooks) and follows a push model where the control node initiates configuration changes on managed nodes.

Step-by-Step Solution

1
Analyze the operational requirements provided in the scenario.
Identified key requirements: Agentless model, SSH/NETCONF transport, YAML definition files, push-based execution from control node.
Matching specific architectural traits determines the correct configuration management framework.
2
Evaluate Ansible against the identified criteria.
Ansible requires no software agent on managed nodes (agentless), uses standard SSH/NETCONF for communication, defines configurations using YAML playbooks, and pushes updates from the control node.
Ansible's architecture directly aligns with all required criteria.
3
Compare against Puppet and Chef architectures.
Puppet and Chef both primarily rely on installed client agents on managed nodes, a pull model of communication, and specific domain-specific languages (Puppet DSL and Ruby DSL respectively).
Puppet and Chef fail the agentless and YAML push requirements.

Key Concept

Ansible Architecture (Agentless, Push Model, SSH Transport, YAML Playbooks)
Question 17Question →

A network operations team is preparing to automate configuration backups and interface descriptions across Cisco IOS XE switches without installing background agent daemons on the managed devices. Which operational characteristics specifically distinguish Ansible from Puppet and Chef in this deployment scenario? (Select two.)

Select all that apply

Show answer & explanation

Answer: It uses an agentless architecture that relies on transport protocols such as SSH or NETCONF to manage target devices.; Playbooks are formatted using YAML and executed via a push-based operational model from a central control node.

Answer

Ansible is distinguished by its agentless architecture utilizing SSH/NETCONF for communication and its push-based deployment model using YAML-formatted Playbooks.
Ansible operates without needing software agents installed on network nodes. It utilizes standard SSH or NETCONF sessions to push configurations directly to switches and routers, relying on Playbooks formatted in YAML.

Step-by-Step Solution

1
Analyze Ansible's agent architecture and transport method.
Ansible communicates with managed devices natively using SSH, NETCONF, or RESTCONF without requiring agent software running on target switches.
Cisco network devices frequently operate closed operating systems where installing third-party agent daemons is impractical or unsupported.
2
Analyze Ansible's data syntax and execution workflow.
Ansible uses human-readable YAML for Playbooks and operates via a push mechanism driven by the Ansible control node.
Puppet and Chef rely primarily on pull-based agent models that periodically fetch state updates from a master server using DSL environments (Puppet DSL or Ruby).

Key Concept

Architectural differences between Ansible (Agentless, Push, SSH/YAML) versus Puppet and Chef (Agent-based, Pull, DSLs).
Estimated Time:1m 30s
Question 18Question →

Match each network configuration management framework on the left to its corresponding operational architecture, primary transport protocol, and native template file type on the right.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef

Matches

Show answer & explanation

Answer

Ansible matches with the agentless SSH/NETCONF push framework using YAML Playbooks. Puppet matches with the agent-based TCP 8140 pull framework using declarative DSL Manifests. Chef matches with the agent-based TCP 443 pull framework using Ruby-based Cookbooks and Recipes.
Ansible uses an agentless architecture using SSH or NETCONF to push YAML Playbooks to target devices. Puppet uses an agent-based pull architecture over TCP 8140 using Puppet DSL Manifests. Chef uses an agent-based pull architecture over TCP 443 using Ruby Cookbooks and Recipes.

Step-by-Step Solution

1
Analyze Ansible's deployment model and communication method.
Ansible is agentless, uses push execution over SSH/NETCONF, and structures tasks in YAML Playbooks.
Ansible connects directly to targets without requiring specialized client software running on network switches or routers.
2
Analyze Puppet's communication port and file format.
Puppet uses an agent-based pull model communicating over TCP port 8140 using Manifest files written in Puppet DSL.
Puppet agents periodically check in with the Puppet Master over port 8140 to pull and enforce desired state.
3
Analyze Chef's communication port and configuration structures.
Chef uses an agent-based pull model communicating over HTTPS (TCP port 443) using Cookbooks containing Recipes written in Ruby.
Chef Client nodes poll the Chef Server securely over port 443 to download required recipes.

Key Concept

Operational attributes, transport protocols, and configuration file formats of Ansible, Puppet, and Chef
Question 19Question →

A network engineer is implementing automated switch deployment across multiple enterprise branch locations. The organization's security policy strictly forbids installing persistent software agents on network devices and requires that configuration changes be pushed directly from a central management station over standard SSH sessions using YAML-based playbooks. Which configuration management tool satisfies all of these requirements?

Show answer & explanation

Answer: Ansible

Answer

Ansible satisfies all specified requirements because it operates using an agentless, push-based model that executes automation tasks over standard SSH using YAML-formatted playbooks.
Ansible utilizes an agentless architecture that communicates directly with target network nodes over SSH or NETCONF. It operates on a push-based model where configurations are executed immediately using human-readable YAML playbooks.

Step-by-Step Solution

1
Analyze the operational constraints provided in the scenario
Identified four primary requirements: Agentless architecture (no endpoint software installation), push execution model, transport via SSH, and playbooks written in YAML format.
Comparing network constraints to standard automation framework characteristics determines tool compatibility.
2
Evaluate configuration management tools against the criteria
Ansible utilizes SSH for connection (agentless), pushes configuration updates from a control node, and formats playbooks in YAML. In contrast, Puppet and Chef rely on client agents executing periodic pull requests with Ruby-based DSLs or custom manifests.
Ansible is designed specifically to support agentless network infrastructure automation over native protocols.

Key Concept

Capabilities and architectural differences of Configuration Management mechanisms (Ansible vs Puppet vs Chef)
Question 20Question →

A network administrator is evaluating configuration management tools to streamline the provisioning of Cisco IOS XE switches across an enterprise network. Which of the following statements correctly describe the operational capabilities and characteristics of Ansible compared to Puppet and Chef? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Ansible operates using an agentless architecture that communicates with network devices via SSH or NETCONF.; Ansible configuration templates and playbooks are authored using human-readable YAML syntax.

Answer

Ansible uses an agentless push model communicating over SSH or NETCONF and relies on YAML-formatted playbooks.
Ansible features an agentless architecture that communicates with managed network devices using SSH or NETCONF and uses YAML formatting for defining configuration playbooks.

Step-by-Step Solution

1
Analyze transport and software requirements for Ansible
Ansible is agentless and uses SSH or NETCONF to manage network devices.
Unlike traditional server automation tools, network switches often cannot host custom agent software, making Ansible's agentless approach well-suited for network hardware.
2
Identify the file format and configuration structure used by Ansible
Ansible configurations (playbooks) are written in YAML.
Puppet uses Puppet DSL (Manifests) and Chef uses Ruby DSL (Recipes/Cookbooks), while Ansible standardizes on YAML structure.

Key Concept

Operational characteristics and capabilities of Ansible vs. Puppet and Chef
Page 1 / 2Next