DevNet Associate (DEVASC) v1.0 flashcards

NETCONF Notifications (RFC 5277) provide a publish/subscribe mechanism for network devices to send asynchronous, event-driven messages to subscribed clients. This allows for real-time monitoring and automation based on network events.

• Event-driven communication
• Asynchronous messages from device to client
• Eliminates polling
• Uses <create-subscription> RPC to subscribe

Memory trick: Notifications: No need to ask, the device will tell the task.

The 'pyang -f tree' command is a utility in the pyang tool that displays a YANG module's data model in a human-readable, hierarchical tree format. This output helps engineers visualize and understand the structure of the defined data.

• Visualizes YANG data model.
• Outputs in textual tree format.
• Aids in understanding module structure.
• Used for validation and documentation.

Memory trick: PYANG 'PICTURES' the YANG module as a TREE.

gRPC (gRPC Remote Procedure Call) is an open-source high-performance RPC framework developed by Google. It uses HTTP/2 for transport, Protocol Buffers as the interface definition language and message format, and supports various types of streaming.

• High performance and low latency
• Uses HTTP/2 for transport
• Uses Protocol Buffers for message serialization
• Supports streaming (unary, server, client, bidirectional)

Memory trick: gRPC: Google's Rapid Protocol for Calls.

Ansible is an open-source automation engine that automates software provisioning, configuration management, and application deployment. It is agentless and uses SSH for communication.

• Agentless (uses SSH).
• Push-based configuration.
• Uses YAML for playbooks.
• Strong community and network modules.

Memory trick: ANSIBLE is the ANswer for agentless, network-focused automation.

A YANG notification data model defines the structure and content of asynchronous event notifications and logs that a network device can generate. These models allow for structured, programmatic processing of device events.

• Defines event structure.
• Used for logs and notifications.
• Asynchronous, push-based.
• Enables event-driven automation.

Memory trick: YANG models: 'C'onfig, 'S'tate, 'N'otify, 'R'PC.

ncclient is a Python library that provides an easy-to-use API for client-side interactions with NETCONF servers. It handles the underlying XML-based communication, allowing developers to focus on the NETCONF operations and data.

• Python library for NETCONF
• Simplifies RPC creation and parsing
• Handles XML encoding/decoding
• Supports various NETCONF operations (get, get-config, edit-config)

Memory trick: NCClient: Network Config Client, the Python NETCONF gem.

Terraform is an open-source Infrastructure as Code (IaC) tool for building, changing, and versioning infrastructure efficiently and safely. It uses a declarative configuration language.

• Infrastructure as Code (IaC) tool.
• Declarative configuration language (HCL).
• Manages infrastructure state.
• Supports multiple cloud providers (AWS, Azure, GCP, etc.).

Memory trick: IaC builds infrastructure declaratively and tracks its state.

Terraform is an open-source Infrastructure as Code (IaC) tool by HashiCorp that allows users to define and provision datacenter infrastructure using a declarative configuration language. It supports a multitude of cloud providers and on-premises solutions.

• Declarative configuration (HCL)
• Multi-cloud and hybrid cloud support
• Infrastructure provisioning and management
• State management to track deployed resources

Memory trick: Terraform molds the earth for all clouds.

Ansible is an open-source automation engine that automates software provisioning, configuration management, and application deployment. It is known for its simplicity, agentless architecture, and use of YAML for playbooks.

• Agentless (uses SSH/API)
• Idempotent operations
• YAML-based playbooks
• Jinja2 templating for configurations

Memory trick: Ansible: Agentless, No Stress, Just Playbooks.

Managing and provisioning computer data centers through machine-readable definition files, rather than physical hardware configuration or interactive configuration tools.

• Defines infrastructure declaratively.
• Enables version control and automated deployment.
• Reduces manual errors and increases efficiency.

Memory trick: Think of building a digital city with a blueprint, not by hand.

The NETCONF :candidate capability indicates support for a candidate configuration datastore. This datastore serves as a staging area where configuration changes can be prepared, validated, and then committed atomically to the running configuration, providing transactional integrity and implicit rollback on error.

• Enables a separate candidate configuration datastore
• Allows staging of multiple configuration changes
• Supports atomic commit to running configuration
• Provides transactional integrity (all or nothing)

Memory trick: Candidate's commitment is atomic, or it's back to the start.

gRPC is a high-performance, open-source universal RPC framework that uses HTTP/2 for transport and Protocol Buffers for data serialization, making it highly efficient for streaming telemetry data.

• Uses HTTP/2 for multiplexed, persistent connections.
• Leverages Protocol Buffers for efficient data serialization.
• Suitable for high-frequency, real-time data streaming.
• Supports various programming languages.

Memory trick: Imagine a super-fast data pipeline for monitoring your network's pulse.

Streaming Telemetry is a network monitoring approach where devices continuously push real-time operational data to a collector. It offers higher granularity, lower latency, and better scalability than traditional polling methods like SNMP.

• Continuous data push (pub/sub model)
• Real-time and high-frequency data
• Uses protocols like gRPC, NETCONF notifications
• Ideal for large-scale, dynamic environments

Memory trick: Stream your data, catch the real-time drama.

In RESTCONF, the HTTP GET method is used to retrieve configuration data, operational state data, or specific resources from a network device.

• Uses standard HTTP GET method.
• Retrieves data from the device.
• Non-modifying operation.
• Part of RESTCONF's CRUD operations.

Memory trick: RESTCONF maps CRUD to HTTP verbs.

A Network Orchestrator is a software platform that coordinates and manages complex, multi-step automation workflows across disparate network devices, services, and domains. It integrates various automation tools and systems to achieve end-to-end automation.

• Coordinates complex workflows
• Integrates multiple automation tools
• Manages end-to-end processes
• Provides centralized control and visibility

Memory trick: The Orchestrator conducts the automation symphony.

SaltStack uses a master-minion architecture where a central 'Salt Master' communicates with 'Salt Minions' running on managed devices to execute commands and enforce configuration state.

• Master-minion model
• Uses ZeroMQ for high-speed communication
• State enforcement and command execution
• Scalable for large infrastructures

Memory trick: Many Minions Master the Salt.

YANG (Yet Another Next Generation) is a data modeling language used to define the structure, syntax, and semantics of configuration and state data, remote procedure calls (RPCs), and notifications for network devices.

• Vendor-agnostic standard for network data modeling.
• Defines data hierarchy, types, and constraints.
• Used by protocols like NETCONF and RESTCONF.
• Enhances interoperability and automation.

Memory trick: Think of YANG as the blueprint for network data, ensuring everyone speaks the same language.

In Zero-Touch Provisioning (ZTP), DHCP (Dynamic Host Configuration Protocol) is used by new network devices to obtain an IP address and discover the location of a provisioning server (e.g., TFTP, HTTP) via DHCP options, which then provides initial configuration or software images.

• Assigns IP address.
• Provides network configuration.
• Uses DHCP options (e.g., 67, 150).
• Points device to provisioning server.

Memory trick: DHCP is the 'DOORway' for ZTP to get network access and find its config.

YANG (Yet Another Next Generation) is a data modeling language used to define the structure and semantics of configuration, state data, RPCs, and notifications for network devices.

• Data modeling language (IETF RFC 6020, 7950).
• Defines structure and semantics of network data.
• Used with NETCONF and RESTCONF.
• Modular and extensible.

Memory trick: YANG models network data's structure and meaning.

SaltStack (Salt) is an open-source, event-driven automation and configuration management platform known for its high scalability, speed, and master-minion architecture.

• Master-minion architecture.
• High-speed communication (ZeroMQ).
• Event-driven automation.
• Supports state management and remote execution.

Memory trick: Scaling configuration needs speed, master-minion, and event-driven power.

A NETCONF operation used to retrieve configuration data and operational state information from a device.

• Retrieves data from the running configuration and operational state.
• Returns data in a structured, machine-readable format (e.g., XML).
• Does not modify the device configuration.

Memory trick: NETCONF is like a remote control for network devices; each button does something specific.

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is human-readable and easy for machines to parse and generate, making it a popular choice for web APIs.

• Human-readable, text-based.
• Easy to parse and generate.
• Widely used with RESTful APIs.
• Supports data structures (objects, arrays).

Memory trick: API data formats vary by readability, verbosity, and efficiency.

A workflow orchestrator is a system that manages and automates complex sequences of tasks (workflows) across multiple systems, often in an event-driven manner.

• Manages complex, multi-step workflows.
• Often event-driven (triggers actions based on events).
• Integrates various automation tools and systems.
• Enables automated remediation and self-healing.

Memory trick: Events trigger workflows orchestrated to remediate.

ncclient is an open-source Python library that implements a client for the NETCONF protocol, simplifying programmatic interaction with NETCONF-enabled network devices.

• Python library for NETCONF client.
• Handles XML parsing and serialization.
• Manages NETCONF sessions (SSH).
• Provides methods for RPC operations (get, get-config, edit-config).

Memory trick: ncclient connects Python to NETCONF's XML.

Protocol Buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data. They are smaller, faster, and simpler than XML or JSON for data interchange.

• Efficient data serialization format.
• Language-neutral, platform-neutral.
• Used extensively with gRPC.
• Defined using .proto files.

Memory trick: gRPC's fast data is packed in Protobuf.

YANG (Yet Another Next Generation) is a data modeling language used to define the structure, semantics, and constraints of configuration data, state data, RPCs, and notifications for network devices.

• Defines schema for network configurations.
• Used with NETCONF and RESTCONF.
• Standardized by IETF.
• Language-agnostic.

Memory trick: YANG models the NETwork's CONFiguration structure.

A NETCONF operation that checks the syntax and semantics of configuration data in a specified datastore (e.g., candidate) against device rules without applying the changes.

• Requires the ':validate' capability to be advertised by the device.
• Used to preemptively identify configuration errors.
• Does not modify the device's running configuration.

Memory trick: Think of drafting an email and spell-checking it before hitting send.

The `get()` method for Python dictionaries returns the value for the specified key if the key is in the dictionary. If the key is not found, it returns a specified default value (or `None` if no default is provided) instead of raising a `KeyError`.

• Syntax: `dictionary.get(key, default_value=None)`.
• Useful for preventing `KeyError` exceptions when accessing potentially missing keys.
• Increases the robustness and error handling of Python scripts.

Memory trick: Get keys safely, or get a default.

RESTful APIs use standard HTTP methods (verbs) to perform operations on resources. Each method has a specific semantic meaning that aligns with CRUD (Create, Read, Update, Delete) operations.

• GET: Retrieves representations of a resource (Read).
• POST: Submits data to a specified resource, often causing a change in state or creation of a resource (Create).
• PUT: Updates an existing resource or creates a new one if it doesn't exist (Update/Create).
• DELETE: Removes a specified resource (Delete).

Memory trick: GET, POST, PUT, DELETE: The CRUD of the web.

A DVCS allows every developer to have a full copy of the project's history, enabling local commits, robust branching, and easy collaboration without requiring constant access to a central server.

• Each developer has a complete repository clone.
• Commits are initially local, then pushed to a remote.
• Facilitates offline work and complex branching strategies.

Memory trick: VCS: Version Changes Saved for Collaboration.

An Activity Diagram is a behavioral UML diagram that illustrates the flow of control in a system. It models the sequence of actions and decisions, showing how activities are ordered and how they can be parallelized or branched.

• Represents the dynamic aspects of a system.
• Useful for modeling workflow and business processes.
• Shows execution paths, decision points, and concurrent activities.
• Helps in understanding complex logic and identifying bottlenecks.

Memory trick: Activities show the A-to-Z flow.

To remove duplicates from a Python list while preserving the original order, one common efficient technique involves iterating through the original list, adding each element to a new list only if it has not been encountered before (tracked efficiently using a set).

• Direct conversion to `set` and back to `list` loses order because `set` is unordered.
• The technique: create an empty result list and an empty `seen` set.
• Iterate through the original list: if an item is not in `seen`, add it to both the result list and the `seen` set.
• This approach leverages the fast lookup time of sets (`O(1)` on average) while maintaining list order.

Memory trick: List for order, Set for speed, combined for unique order.

Recursion is a programming technique where a function calls itself to solve a problem. It typically involves a 'base case' to stop the recursion and a 'recursive step' that calls the function with a modified input to move closer to the base case.

• Essential for solving problems that can be broken down into smaller, self-similar subproblems.
• Requires a clear base case to prevent infinite loops (stack overflow).
• Can sometimes be less efficient than iterative solutions due to function call overhead.
• Often used in algorithms like tree traversals, mergesort, and quicksort.

Memory trick: Recursion: Repeat, recurse, reach the base.

A Python function is a block of organized, reusable code that performs a specific task. Functions improve code modularity, reusability, and readability.

• Defined using the `def` keyword.
• Can accept zero or more arguments (inputs).
• Can return a value using the `return` statement.
• Promotes the DRY (Don't Repeat Yourself) principle.

Memory trick: Functions make code flow like a well-oiled machine.

A Version Control System (VCS) is a system that records changes to a file or set of files over time so that you can recall specific versions later. It enables collaboration among multiple developers and maintains a complete history of revisions.

• Tracks every modification made to the codebase.
• Allows multiple developers to work on the same project concurrently.
• Facilitates merging changes and resolving conflicts.
• Enables reverting to previous versions of the code.

Memory trick: VCS: Version Changes Saved.

A `try/except` block in Python is used for error handling. Code that might raise an exception (runtime error) is placed inside the `try` block. If an exception occurs, the `except` block catches it, allowing the program to handle the error and continue execution.

• Prevents script crashes due to unexpected errors.
• Can catch specific types of exceptions.
• Includes optional `else` (if no exception) and `finally` (always executes) blocks.
• Essential for creating robust and fault-tolerant applications.

Memory trick: Try to run, except when errors come, then handle.

Agile software development is a group of development methodologies based on iterative and incremental development, where requirements and solutions evolve through collaboration between self-organizing, cross-functional teams.

• Emphasizes individuals and interactions over processes and tools.
• Focuses on working software over comprehensive documentation.
• Prioritizes customer collaboration over contract negotiation.
• Values responding to change over following a plan.

Memory trick: Agile: Always Getting Iterative, Learning, Evolving.

The Git rebase command is used to integrate changes from one branch onto another by moving or combining a sequence of commits to a new base commit. A common workflow is to rebase a feature branch onto an updated `main` (or `develop`) branch to incorporate the latest changes while maintaining a linear project history.

• Always rebase your feature branch ONTO the target branch (e.g., `git rebase main`).
• Rewrites the commit history of the feature branch.
• Avoid rebasing branches that have already been pushed to a shared remote repository.
• Helps maintain a clean, linear, and easy-to-read project history.

Memory trick: Rebase: Re-aligns Base for a Smooth, Straight path.

The `tenacity` library provides a general-purpose retry decorator for Python functions, enabling robust error handling with strategies like exponential backoff and jitter.

• Decorator-based retry mechanism.
• Supports exponential backoff, jitter.
• Configurable retry conditions and stop strategies.

Memory trick: Tenacity helps you 'tenaciously' retry until success.

The `requests.post()` method in Python is used to send POST requests, typically for creating new resources. When provided with the `json` parameter (a Python dictionary), it automatically serializes the dictionary into a JSON formatted string and sets the `Content-Type` header to `application/json`.

• Used for creating new resources on a server.
• Accepts a `json` parameter (Python dict) for automatic serialization.
• Automatically sets `Content-Type: application/json` header.

Memory trick: Python's 'requests' library makes web interactions both easy and robust, like ordering pizza online.

Storing API keys directly in client-side code (e.g., JavaScript) is a major security vulnerability as it exposes the keys to public view, allowing unauthorized access and misuse of the API.

• Client-side code is publicly viewable.
• Exposes keys to malicious actors.
• Leads to unauthorized API access.
• API keys should be stored on the server-side or securely transmitted.

Memory trick: Never expose your API key to the client's 'eyes'.

An OpenAPI path parameter is a variable part of the URL path, enclosed in curly braces, used to identify a specific resource or collection within the API.

• Part of the URL path.
• Enclosed in curly braces `{}`.
• Used to identify specific resources.

Memory trick: Path parameters map to locations in the URL.

The Authorization HTTP header is used to carry authentication credentials (like API keys, bearer tokens) from the client to the server to prove identity.

• Carries authentication credentials.
• Commonly prefixed with 'Bearer' for tokens.
• Crucial for authenticated API requests.

Memory trick: Authorization is the 'key' to access.

In the Python `requests` library, custom HTTP headers are sent using the `headers` parameter, which takes a dictionary of header names and values.

• Uses `headers` parameter.
• Parameter expects a dictionary.
• Essential for custom API keys or specific content types.

Memory trick: Requests: Headers are for 'head' information.

The HTTP POST method sends data to the server to create a new resource. It is often used when submitting forms or uploading files.

• Creates a new resource.
• Data is sent in the request body.
• Results in a change on the server.

Memory trick: CRUD operations map directly to HTTP verbs.