Connectivity Template

By receiving and analyzing connectivity templates, the system automatically identifies and applies them to qualified application points in computer networks, solving the complexity of manual network configuration and achieving efficient network management and configuration.

CN114553689BActive Publication Date: 2026-11-17APSTRA INC
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
CN202111405526.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2020-11-25
Filing Date
2021-11-24
Publication Date
2026-11-17
Estimated Expiration
2041-11-24

AI Technical Summary

Technical Problem

In existing technologies, network configuration requires complex and inefficient manual operations, especially when adding, removing or modifying network devices, which requires frequent integration and configuration changes, leading to increased complexity in network management.

Method used

By receiving the identifier of the connectivity template, the network design is automatically analyzed to identify qualified application points, and the connectivity template is applied to the specified application points to configure the computer network, achieving automated configuration using the processor and memory.

Benefits of technology

It reduces the complexity and inefficiency of network configuration, improves the efficiency of network device management and configuration, and supports unified management and dynamic changes of equipment from different vendors.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN114553689B_ABST
    Figure CN114553689B_ABST
Patent Text Reader

Abstract

This application relates to connectivity templates. It receives an identifier of a connectivity template to be applied to a design of a computer network. The network design is automatically analyzed to identify qualified application points in the network design where the connectivity template is eligible to be applied. It receives a designation of one or more specified application points from the identified qualified application points to which the connectivity template is to be applied. The connectivity template is applied to the designated one or more specified application points from the identified qualified application points to configure the computer network.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Cross-citation of related applications

[0002] This application claims the benefit of U.S. Application No. 17 / 104,804, filed November 25, 2020, the entire contents of which are incorporated herein by reference. Technical Field

[0003] This disclosure relates to connectivity templates, and more specifically, to methods and systems for using connectivity templates. Background Technology

[0004] Configuring a network typically requires network administrators to manually configure network components to create the desired network. For example, network administrators may often have to manually configure each of many network switches, servers, storage devices, and other network equipment to create the desired network configuration. When adding, removing, or modifying network equipment and solutions, the entire integration and configuration may need to be modified again. Manually monitoring this type of network also adds complexity and inefficiency. Therefore, there is a need for more efficient configuration, management, and monitoring solutions for network equipment and solutions. Summary of the Invention

[0005] This disclosure describes a method comprising receiving an identifier of a connectivity template to be applied to a design of a computer network; automatically analyzing the design of the network to identify qualified application points in the network design to which the connectivity template is eligible to be applied; receiving a designation of one or more designated application points to which the connectivity template is to be applied among the identified qualified application points; and applying the connectivity template to the designated one or more designated application points among the identified qualified application points to configure the computer network.

[0006] Furthermore, this disclosure describes a system comprising: a processor configured to: receive an identifier of a connectivity template to be applied to a design of a computer network; automatically analyze the design of the network to identify qualified application points to which the connectivity template in the network design is eligible to be applied; receive designations for one or more designated application points to which the connectivity template is to be applied among the identified qualified application points; and apply the connectivity template to the designated one or more designated application points among the identified qualified application points to configure the computer network; and a memory coupled to the processor and configured to provide instructions to the processor. Attached Figure Description

[0007] Various embodiments of the invention are disclosed in the following detailed description and accompanying drawings.

[0008] Figure 1 This is a diagram illustrating an implementation of a network management environment.

[0009] Figure 2This is a diagram illustrating an implementation of the management server.

[0010] Figure 3 This is a flowchart illustrating an implementation of a process for configuring a computer network using a connectivity template.

[0011] Figure 4 This is a flowchart illustrating an implementation of the process for applying connectivity templates.

[0012] Figure 5 This is a diagram illustrating an implementation of a user interface for creating new connectivity templates.

[0013] Figure 6 This is a diagram illustrating an implementation of a user interface for selecting a connectivity template to apply.

[0014] Figure 7 This is a diagram illustrating an implementation of a user interface for applying connectivity templates.

[0015] Figure 8 This is a diagram illustrating an implementation of nodes and edges that may be included in a graph model.

[0016] Figure 9A This is a diagram illustrating an implementation of a network device.

[0017] Figure 9B This is a diagram illustrating an implementation of a portion of the graphical model.

[0018] Figure 9C and Figure 9D This is an example of a trigger pattern.

[0019] Figure 10 Examples of model diagrams (e.g., in Python format) used for graph models are shown.

[0020] Figure 11 This is a flowchart illustrating an implementation of a process for verifying an existing computer network.

[0021] Figure 12 This is a flowchart illustrating an implementation of a process that uses a graph model to automatically configure computing infrastructure.

[0022] Figure 13 This is a flowchart illustrating an implementation of the process for invoking a callback function.

[0023] Figure 14 This is a flowchart illustrating an implementation of the agent creation process.

[0024] Figure 15 This is a flowchart illustrating an implementation of the process for detecting and responding to anomalies.

[0025] Figure 16 This is a flowchart illustrating an implementation of the process used to generate a validation model.

[0026] Figure 17 This is a flowchart illustrating an implementation of a process for detecting state parameters.

[0027] Figure 18 This is a flowchart illustrating an implementation method for processing the analysis and verification report. Detailed Implementation

[0028] This invention can be implemented in various ways, including as a process; an apparatus; a system; a component of matter; a computer program product embodied on a computer-readable storage medium; and / or a processor, such as a processor configured to execute instructions stored on and / or provided by memory coupled to the processor. In this specification, these implementations or any other form of the invention may be referred to as techniques. Generally, the order of steps of the disclosed process is variable within the scope of this invention. Unless otherwise stated, components such as processors or memory described as being configured to perform tasks can be implemented as general-purpose components temporarily configured to perform tasks at a given time or as specific components manufactured to perform tasks. As used herein, the term "processor" refers to one or more devices, circuits, and / or processing cores configured to process data such as computer program instructions.

[0029] The following detailed description of one or more embodiments of the invention, illustrated by the accompanying drawings, provides the principles of the invention. The invention has been described in conjunction with these embodiments, but is not limited to any particular embodiment. The scope of the invention is limited only by the claims, and the invention encompasses many alternatives, modifications, and equivalents. Numerous specific details and accompanying drawings are set forth in the following description to provide a full understanding of the invention. These details are provided for illustrative purposes, and the invention may be practiced according to the claims, which do not set forth some or all of the details. For clarity, well-known technical information in the art related to the invention has not been described in detail, so that the invention is not unnecessarily obscured.

[0030] In some implementations, one or more connectivity templates are used to configure the network. For example, unlike configuring each individual port between network devices in the network, the same connectivity template can be applied to multiple different application points of devices with similar connectivity requirements. Based on where the connectivity template is applied, the configuration / functions specified by the template are automatically applied to the specific appropriate application point to achieve a version implementation of the template configuration / functions for that specific application point. For example, a user applies a connectivity template that enables Border Gateway Protocol (BGP) communication to an application point of a device, and it is automatically implemented wherever the correct behavior of enabling BGP applications is required. Thus, the user can implement the desired application model specified by the connectivity template by applying the template to the application points of the network device. This allows the network device to be initially modeled as a general-purpose device without having to model it as a specific type of device (e.g., without having to define it as a network switch, firewall, load balancer, server, etc.), and allows the functionality / configuration of the template applied to the application point of the device to define how the device operates.

[0031] Users can apply functional templates to the connectivity of general-purpose devices without adhering to specific, rigid network designs, rather than worrying about the rigid functionality of network devices categorized for a particular device. This frees users from industry-standard reference network designs and allows them to easily implement custom designs without repetitive manual configuration changes. For example, a reference network design might restrict device role-based configuration by disallowing routing sessions with server-type devices, as this is typically done with external router-type devices. However, users can achieve this using connectivity templates applied to general-purpose devices (e.g., virtualized external routers running on servers).

[0032] Furthermore, the intent behind an application at a specific application point is automatically determined, and related administrative and management functions are automatically executed based on that intent. For example, telemetry and verification are automatically configured to automatically verify settings and monitor for any errors.

[0033] In some implementations, connectivity templates are defined using one or more primitives, where each primitive is an atomic network operation (e.g., L2 interface creation, IP address allocation, etc.) that can be stacked / utilized together based on networking principles. Each primitive performs a low-level action (e.g., a single atomic operation) on the networking device (e.g., creating a subinterface on a port). For example, lower-level primitives are stacked / utilized to build higher-level connectivity templates. Constraints regarding how primitives can be structured / stacked together based on networking principles can be enforced during template creation. For example, each primitive may be a type applicable only to a specific type of target (instances of targets: ports, Virtual Routers and Forwarders (VRFs), route instances, etc.) to limit the use / stacking of primitives to what is permissible in networking principles. In the example, the subinterface type of the primitive can only be applied to network ports. Furthermore, users can create new connectivity templates based on one or more existing connectivity templates to reuse and augment the defined primitive stack.

[0034] In some implementations, an identifier of a connectivity template to be applied to the design of a computer network is received. For example, a provided connectivity template or a custom-built connectivity template is selected for application by the user in the network design. An example of a computer network design is the specification of physical connections between physical devices in the computer network, which is configured with a software layer to enable the computer network. The network design is automatically analyzed to identify eligible application points where the connectivity template can be applied. For example, a particular connectivity template may only be applicable to a certain type of application point, and based on the specific configuration / functionality of the connectivity template, the locations in the computer network design where the connectivity template is eligible to be applied are identified. By indicating constraints on where specific connectivity templates can be applied, risk or errors are reduced and ease of use is increased. A specification of one or more designated application points from the identified eligible application points to which the connectivity template is to be applied is received, and the connectivity template is applied to the designated specific application points from the identified eligible application points to configure the computer network for deployment.

[0035] In various implementations, connectivity templates are utilized within the context of intent-based networking. Computer networks, networks, computing infrastructure, and other similar terms (e.g., those associated with enterprise data center infrastructure) are becoming increasingly complex, and the need for tools to effectively manage these networks is paramount. Intent-based networking (IBN) has been widely recognized as an effective way to comprehensively manage computing infrastructure. IBN solutions typically involve providing a set of IBN tools to the computer network (e.g., ...). Figure 1The management server 102 is used, and the same IBN tools are subsequently used to manage the entire lifecycle of the computer network. In some implementations, at least a portion of the network can be established and / or managed via intents that can be specified as declarative requirements. For example, declarative requirements express the desired configuration of network components without specifying precise local device configurations and control flows. By utilizing declarative requirements, what should be achieved is specified, rather than how it should be achieved. Declarative requirements can be contrasted with imperative instructions that describe the exact device configuration syntax and control flows required to implement the configuration. By utilizing declarative requirements instead of imperative instructions, the burden on users and / or user systems to determine the exact device configurations required to achieve the user / system's desired results is reduced. For example, when utilizing various types of devices from different vendors, specifying and managing the exact imperative instructions used to configure each device in the network is often difficult and cumbersome. As new devices are added and devices fail, the types and kinds of devices in the network can change dynamically. Managing various types of devices from different vendors to configure devices using different configuration protocols, syntaxes, and software versions is often difficult to achieve in a cohesive network. As a result, the management and configuration of network devices become more efficient by requiring only users / systems to specify declarative requirements that define the expected results applicable to various types of devices.

[0036] Figure 1 This diagram illustrates an implementation of a network management environment. Management server 102 is connected to data storage 104, network device 106, and network device 108 via network 110. In some implementations, management server 102 provides intent-based networking (IBN) tools. In some implementations, management server 102 provides network configuration, monitoring, and management solutions. For example, a user can utilize solutions provided at least in part by management server 102 to configure the network, configure network devices, calculate operational status expectations, monitor network attributes or operational status, monitor network devices, automate tasks, or otherwise manage network devices. In the illustrated embodiment, management server 102 is used to manage at least network devices 106 and 108. Management server 102 processes / executes agents (e.g., agent execution functions triggered when a portion of the graph representation matches a specified triggering graph representation mode corresponding to the agent). In some implementations, management server 102 is specialized custom hardware. In some implementations, management server 102 is used to configure hardware network switches.

[0037] In some implementations, management server 102 facilitates interaction with users to receive and provide desired requirements, specifications, and status updates. For example, users utilize user interfaces (e.g., network interfaces, application interfaces, command-line interfaces, graphical interfaces, application programming interfaces (APIs), configuration file interfaces, etc.) provided directly and / or remotely (e.g., via a display, wired connection, network, etc.). In some implementations, users interact with management server 102 to provide the specification and application of connectivity templates. In some implementations, using the user interface, users can at least partially provide high-level requirements specifying the desired configuration of the desired network / device and / or receive information about the status of the devices / components of the desired network and / or about the implementation status of the desired configuration requirements. In some implementations, management server 102 selects a processing agent from among multiple processing agents (e.g., triggered by a pattern matching at least a portion of a graphical representation) to fulfill / complete the desired network requirements. In some implementations, users access the agent via an application programming interface (API) (e.g., a RESTful API). For example, information can be accessed and managed via the API using HTTP methods (e.g., GET, PUT, POST, DELETE, etc.). Status and resources can be referenced using the same resource identifier (URI). Declarative requirements can be specified in one or more selected states / levels across multiple phases / levels. In some implementations, the user specifies one or more constraints (e.g., resources, policies, etc.) for the desired network configuration.

[0038] In some implementations, at least a portion of the computing infrastructure used to implement declarative requirements is represented as a graphical model / representation of computing infrastructure elements, including computing infrastructure nodes and computing infrastructure boundaries. Examples of data associated with each node in the graphical representation include: identifiers, node types (e.g., server, switch, interface, rule, policy, etc.), descriptive labels (e.g., a description of the node), tags, and other attributes (e.g., one or more key-value pairs). Examples of data associated with each boundary in the graphical representation include: identifiers, boundary types (e.g., managed interface, managed, etc.), source nodes connected by the boundary, target nodes connected by the boundary, descriptive labels (e.g., a description of the boundary), tags, and other attributes (e.g., one or more key-value pairs).

[0039] When a change in the graphical representation of a computing infrastructure element is detected, it is determined whether the change affects any triggering graphical representation patterns. If the change affects the triggering pattern, the change is notified to the processing agent associated with the affected triggering pattern. For example, a processing agent may declaratively author a set of one or more triggering patterns with associated callback functions. Each agent's function may perform some of the processing required to generate the configuration and deployment of the computing infrastructure. For example, the callback functions of various agents may perform semantic validation, collect telemetry and execution data, and / or detect anomalies during execution. In various implementations, the callback function includes code to be executed. This paradigm can support any programming language used to author callback functions.

[0040] In various implementations, whenever a corresponding trigger pattern for a graphical representation element of an agent is "added," "updated," and / or "deleted" in the relevant portion of the graphical representation, the system invokes the agent's callback. Therefore, each agent can process a subset of the graphical model / representation relevant to its own objective and will not be invoked for changes unrelated to it. In various implementations, each processing agent focuses only on the portion of the graphical representation relevant to the business logic it implements. Agents do not need to track all changes to the graph; they only need to re-execute portions of their business logic based on incremental changes to the graphical representation portions of interest. By implementing all processing related to the computing infrastructure as agents of the graphical model, the computing infrastructure can be optimized and scaled independently of any complex central processing unit, given the decentralization of processing agents.

[0041] Therefore, an agent encoded in the manner described above can incrementally perform its duties. In some implementations, upon startup, the agent evaluates its inputs and outputs and performs initial processing to ensure that the inputs and outputs satisfy constraints defined in its business logic. This initial processing may involve processing multiple components of a graphical representation that match a trigger pattern defined by the agent. After the initial startup processing, the agent reaches a steady state. In the steady state, the agent may choose to react only to incremental changes in the graphical representation relevant to its business logic and perform incremental processing on such changes above the steady state.

[0042] In some implementations, a trigger pattern for a processing agent specifies an identifier for a graphical representation element describing at least a portion of the graphical representation of interest, and an associated processing function is executed when the trigger pattern matches a portion of the graphical representation of interest or no longer matches a previously matched portion of the graphical representation. Pointers to graphical representation elements included in the matched portion may be provided to the called functions of the agent to allow the called functions to utilize / modify the associated graphical representation elements. In some implementations, an API is provided to allow modification and use of the graphical representation via the API. Execution of the API invokes one or more associated agents to perform the necessary processing required to achieve the desired results of the API call. In some embodiments, telemetry data collected during the use and execution of the computing infrastructure is mapped to corresponding graphical representation elements to provide (e.g., visually) a representation of the telemetry data in a graphical representation format.

[0043] This paradigm supports any programming language used for authoring agents. Code execution is efficient because each piece of code can only be explicitly associated with a portion (e.g., a small portion) of the graph representation of interest and is invoked only when necessary. Agents are also modular because each agent can have any number of rules, each with a callback function, thus cleanly separating code along the boundaries of the triggering pattern. It is also scalable because there can be multiple agent instances and multiple systems to send changes to agents of interest. This enables publish / subscribe communication mechanisms based on real-time state (e.g., non-messages) implemented on top of graph-based real-time queries, thus enabling reactions to incremental graph changes and triggering incremental processing. The system's asynchronous, reactive nature allows for system scaling. Support for new features offered by modern infrastructure platforms can be easily added (e.g., by adding new agents). In some implementations, components of the system communicate in response to changes in intent.

[0044] Management server 102 implements and manages various graphical representation processing agents. In some implementations, the agents provide device requirement instructions to various devices in the managed network and receive status information from them. For example, using desired network requirements, the agents can determine individual device requirements to fulfill those requirements. In some implementations, multiple different successive processing stages / levels can be utilized when translating desired network requirements into device requirements. Network requirements can be specified for any of the different processing stage levels. For example, network requirements can be specified at the most general and highest levels and / or at lower and more specific stages / levels. Each processing stage / level can translate input declarative requirements into output declarative requirements, which can then be used as input declarative requirements for the next subsequent lower processing stage / level. For each processing stage / level, the agent can combine the input declarative requirements with one or more constraints (e.g., available resources, policies to be followed, etc.) to determine the output declarative requirements. By being able to provide the desired declarative network requirements for any selected stage / level from multiple different processing stages / levels, users are given the option to adjust the level / amount of control they require when configuring the network. For example, a network administrator who wants to quickly establish a default-configuration network can specify declarative requirements at the highest stage / level, while a network administrator who wants to establish a more customized and specific network can specify declarative requirements at a lower stage / level. In some implementations, each processing stage / level performs a different function. For example, one processing stage / level can determine the logical connectivity in its output declarative requirements, another processing stage / level can determine the physical connectivity in its output declarative requirements, and yet another processing stage / level can determine the wiring diagram in its output declarative requirements.

[0045] In different implementations, any number of agents can exist. Each agent can perform the same and / or different functions that can be triggered by one or more associated trigger patterns. In some implementations, agents coordinate and perform verification of the service being run. For example, the expected configuration of the received desired network / device service can be used to generate one or more device verification models for one or more devices being utilized. Each device verification model can identify one or more parameters to be verified / detected for a specific device used to verify the model. Device verification models are different from device requirements provided to devices to configure the devices to fulfill device requirements. For example, device requirements are provided to configure / set up the devices to provide services, while device verification models are provided to verify the status and / or configuration of the service. In some implementations, in response to a device verification model, a status report is received from the corresponding device identifying the status of one or more parameters identified in the verification model. The agent can then aggregate and analyze one or more status reports to determine whether the service has been correctly implemented / configured and / or is operating correctly.

[0046] Various processing agents can perform processes to create, implement, validate, and / or modify graphical representations. Each agent is associated with one or more triggering graphical representation patterns of the agents that will trigger them, and when a graphical representation is created or modified due to initial specification and / or due to processing by another agent that modifies the graphical representation, it determines whether the change affects any triggering pattern. If the change affects a triggering pattern, the change is notified to the processing agents associated with the affected triggering pattern. For example, a processing agent can declaratively author it using a set of one or more rules with associated callbacks. Each agent's callback functions and business logic functions can execute parts of the processing required to generate the configuration and deployment of the computing infrastructure. For example, the callback functions of various agents can perform semantic validation, collect telemetry and execution data, and / or detect anomalies during execution.

[0047] In some implementations, these agents work together to efficiently analyze the desired network configuration and identify and recognize the devices that will be used to implement the received network requirements. Assume the L3 Clos network requirements specify 6 backbone network switching devices and 32 leaf network switching devices. In total, the agents will identify and recognize 38 devices that will need to be configured to implement the desired Clos network. For each device to be utilized, the agents will determine the individual device requirements for implementing the desired Clos network. For the L3 Clos network example, the following is an example of device requirements for one of the 38 different device requirements.

[0048] Character = Main Branch

[0049] IP address = 10.0.0.3

[0050] ASN=1000

[0051] Neighbors = [(Leaf-1, 10.0.0.7, 1010), (Leaf-2, 10.0.0.15, 1011), ... (Leaf-32, 10.0.0.176), 1042]

[0052] Status = Validated

[0053] The aforementioned equipment requirements specify that, within a Clos network, a network switching device will be a backbone switch with a BGP router identifier defined as IP address 10.0.0.3 and ASN 1000. Leaf switches connected to this backbone switch, along with their IP addresses and ASNs, have also been identified.

[0054] In some implementations, the agent is configurable / customizable. For example, users can modify, extend, and / or configure the trigger patterns and / or callback function handling performed by the agent. The agent can be configured / customized via an interface such as an API.

[0055] In the example shown, one or more processing agents executed by network device 106 receive device requirements for network device 106, and one or more processing agents executed by network device 108 receive device requirements for network device 108. Each of these agents can generate and / or implement / execute native hardware instructions that configure device requirements for its associated individual network device.

[0056] In some implementations, an agent hosted by network device 106 receives a device verification model for network device 106, and an agent hosted by network device 108 receives a device verification model for network device 108. Each of these agents can determine one or more status parameters to be reported to verify the corresponding device verification model and collect / detect the determined status parameters. Each agent can then provide a status report of the collected / detected status parameters to another agent processing the verification of the provided service. In some implementations, each agent reports information about the status, operation, and / or other information of its associated device. Different agents can then collect and process the reported information to report that information and / or perform response actions. For example, when an agent provides a status update on its associated device being overloaded, another agent (e.g., hosted by management server 102) can add a new device to the network to offload processing and / or move the processing tasks of the overloaded device to another network device. The collected status information can be provided by the agents as a report and / or action request.

[0057] In various embodiments, data storage 104 stores data for a graphical model / representation. Data storage 104 may be included in a networked storage service. In the illustrated embodiment, a proxy accesses data storage 104 via network 110. In some embodiments, data storage 104 is connected to management server 102 via a non-shared connection. In various embodiments, data storage 104 includes... Figure 1 In any of the components shown. For example, data storage 104 may be included in management server 102. Data storage 104 may include a server that manages the data stored in data storage 104. Examples of data storage 104 include databases, highly available storage, distributed storage, cloud storage, data servers, or any other type of data storage.

[0058] Network devices 106 and 108 can be any type of device connected to network 110. Examples of network devices 106 and 108 include servers, network switches, network routers, cache servers, storage devices, hypervisor switches, virtual routers, load balancers, firewalls, network infrastructure devices, virtual network devices, software devices, software components, or any type of computer or network device, whether physical or virtual. In various implementations, the agent shown is a software and / or hardware component included in the respective component. Examples of network 110 include one or more of the following: direct or indirect physical communication connections, mobile communication networks, the Internet, intranets, local area networks, wide area networks, storage area networks, and any other form of connection that links two or more systems, components, or storage devices together. Other communication paths may exist and have been simplified. Figure 1 An example is provided to clearly illustrate the instance.

[0059] Although it has been shown Figure 1 The diagram shows a single example of many components to simplify the illustration, but it may contain... Figure 1 Additional examples of any of the components shown. For example, any number of management servers, storage, and network devices can exist. Management server 102 can be a server cluster, and storage 104 can be distributed storage. Any number of agents can exist. A single server / device can include any number of agents. Although Figure 1 The example shown illustrates each agent included / installed in its respective associated system component, but agents can be included on different servers / devices. For example, a single agent can be assigned to processing across multiple network devices. It is also possible for... Figure 1 Components not shown. In some embodiments, Figure 1 Each resource (e.g., each agent, server, and network device) can belong to a domain. For example, resources belonging to the same domain are interoperable and can work together to perform network configuration and / or management tasks. In some implementations, each resource may belong to only one domain, and interoperability for network configuration and / or management tasks is only guaranteed within the same domain. A resource may belong to multiple domains. Multiple domains can be used to manage a single network. Figure 1 The components shown can be components of one or more domains. Figure 1 Any component shown can be a physical or virtual component.

[0060] Figure 2 This is a diagram illustrating an implementation of a management server. The management server 200 can be used to implement... Figure 1The management server 102. In the example shown, the management server 200 includes an agent manager 202 and agents 204, 206, and 208. In different implementations, the management server includes 60, 200, 1000, or any suitable number of agents. Agents may include trigger patterns and corresponding callback functions invoked when the trigger pattern is present. As shown, agent 208 is associated with trigger pattern 210 and callback function 212.

[0061] In some implementations, a central software component (such as agent manager 202) tracks all changes to the network configuration by tracking changes in a graphical representation of the network configuration, wherein the graphical representation precisely represents the real-time state of the network. In some implementations, agent manager 202 includes a query engine. As shown, agent manager 202 receives input from distributed data storage 214. In some implementations, the graphical representation of the network configuration is stored in distributed data storage 214. Input may include the current network configuration graph (e.g., the graphical representation of the network configuration). In some implementations, agent manager 202 compares the current state of the network configuration graph with the previous state of the network configuration graph to determine changes in the graph. In some implementations, agent manager 202 detects the impact of the graphical representation on a portion of the trigger pattern or agent. If the network configuration graph has changed, agent manager 202 may notify only the relevant agents of the change. In different implementations, the relevant agents are determined based on their trigger patterns (e.g., whether a change in the graph affects an agent's trigger pattern). For example, a publish-subscribe model may be utilized, where agents subscribe to changes in the graph that affect trigger patterns associated with the agents. In some implementations, instead of a central change recording component, an agent is invoked based on a trigger pattern.

[0062] Different actions may need to be performed based on the network configuration graph. In different implementations, changes in the graph result in collecting state from devices, deleting links, creating nodes, or any other appropriate action. Actions can be performed via callback functions. In some implementations, a query for a specific trigger pattern runs once. After a trigger pattern is specified, the associated agent can be notified of changes in the graph only if its trigger pattern matches in the graph model. In some implementations, real-time querying and graphical representation allow the system to be robust and scalable. In some implementations, the framework of the system remains unchanged; agents, nodes, or edges are added to implement new features.

[0063] In the example shown, the agent provides input to the distributed data storage 214. When the associated callback function is invoked, the agent may cause a change in the network configuration. This change may be stored in the network configuration graph. In some implementations, if applicable, the agent updates the graphical representation based on the processing result of the agent callback function.

[0064] Figure 3 This is a flowchart illustrating an implementation of a process for configuring a computer network by applying connectivity templates. Figure 3 The method can be derived from Figure 1 Management server 102 and / or Figure 2 The management server 200 is executed.

[0065] At 302, a specification of the physical design of the computer network is received. The physical design of the computer network specifies the physical connections between one or more physical network devices (e.g., network pods, racks, spine nodes, leaf nodes (e.g., routers, switches, servers, firewalls, load balancers, etc.) and the interfaces and sub-interfaces of the devices). In some implementations, the physical design specifies that at least one of the network devices included in the design is a general-purpose device. This allows network devices to be initially modeled as general-purpose devices without specifying or configuring them as a particular type of device (e.g., without defining them as network switches, firewalls, load balancers, servers, etc.), and allows the functionality / configuration of templates applied to the application points of the devices to define how the devices operate. In some implementations, the user uses a graphical user interface to instantiate user interface objects representing network devices connected by specified lines, which represent connections between corresponding network devices. In some implementations, the specification of the physical design of the computer network is represented using a graphical model / representation of computing infrastructure elements that include edges representing nodes representing physical devices and nodes representing connections between physical devices.

[0066] In some implementations, the specification of the physical design of the computer network is generated at least partially automatically. For example, the user provides declarative requirements and / or identifiers that reference the network design, and the intent and / or identifiers referencing the design are automatically translated into a specification of the physical design of the computer network.

[0067] While the physical design of a computer network specifies the presence of physical devices and the physical connections between them, these devices need to be configured to enable routing and other network functions to establish / enable the desired functional computer network. Endpoint templates can be used to specify at least a portion of these configurations to build the desired network stack.

[0068] At position 304, a specification of a connectivity template is received. A connectivity template allows a user to specify the desired configuration to be applied to any future application point, and the template can be reapplied to any number of eligible application points to achieve the desired configuration on the target application points. For example, the same template can be applied to multiple application points to attach them to the same virtual network. Thus, instead of repeatedly configuring the same configuration individually for many different application points, the configuration can be specified once and simply applied to all different application points. Examples of application points to which connectivity templates can be applied include any communication attributes of a connection between two devices. Specific examples of application points include ports, port channels, device ports, device port channels, subinterfaces, routing instances, routing / security zone instances, and any Internet Protocol (IP) interface (e.g., any IP address of the interface, Switched Virtual Interface (SVI) IP address, loopback IP address, etc.). Configurations that can be specified in the applied connectivity template include any configurations used to establish, define, manage, or modify any attributes of the application point. Specific examples of connectivity templates include templates for operations such as: creating sub-interfaces, establishing IP addresses, adding to a specified virtual network, establishing route instances, adding routing policies, establishing new static routes, enabling bridging protocol data unit protection, and enabling PortFast.

[0069] In some implementations, one or more primitives are used to specify a connectivity template, where each primitive is an atomic network operation (e.g., L2 interface creation, IP address allocation, etc.) that can be stacked / utilized together based on networking principles. Each primitive performs a low-level action (e.g., a single atomic operation) on the network device (e.g., creating a subinterface on a port). For example, lower-level primitives are stacked / used to build higher-level connectivity templates. Constraints can be enforced based on networking principles during template creation, regarding how the set of primitives can be structured / stacked together. For example, each primitive is a type applicable only to a specific type of target (examples of targets: ports, Virtual Routers and Forwarders (VRFs), routing instances, etc.) to limit the use / stacking of primitives to the extent permitted by networking principles. In an embodiment, primitives of the subinterface type can only be applied on network ports. Additionally, users can create new connectivity templates based on one or more existing connectivity templates to reuse and expand the defined primitive stack.

[0070] Connectivity templates can be selected from a provided library of connectivity templates. For example, a built-in library of connectivity templates is provided to the user, who can select a template for application from the library. Connectivity templates can be custom-built by the user. For example, a user can create a new connectivity template by specifying the configuration to be executed when applying the template. New connectivity templates can be built using one or more existing connectivity templates to allow the reuse and expansion of an existing stack of primitives of existing connectivity templates. For example, a user can create a new connectivity template that specifies the use of one or more existing connectivity templates (e.g., a user concatenates instances of existing connectivity templates together to create a new connectivity template). In one specific embodiment, a user can build a hypervisor configuration template that includes multiple instances of existing templates for attaching to various different virtual networks. To allow for general flexibility in connectivity templates, a template can be specified to request one or more configuration parameters from the user when it is created, configured, and / or applied. For example, specific parameters (e.g., VLAN ID, IP address, etc.) of the configuration to be applied to the template can be requested from the user based on the context and / or where the template is applied. In some implementations, one or more tags may be associated with a connectivity template, and when the template is applied to an application point, the application point is tagged with one or more tags from the connectivity template. These tags can then be used to tag, classify, filter, describe, and / or search application points.

[0071] In some implementations, when a connectivity template is created, configured, and / or applied, the connectivity template requests one or more configuration parameters from the user. For example, specific parameters (e.g., VLAN ID, IP address, etc.) of the configuration to be applied to the template may be requested from the user based on the context and / or where the template is applied.

[0072] Primitives (such as those that can be used directly as connectivity templates or as component templates to create new connectivity templates) are subinterface creation templates. This template can only be applied to application points such as device ports or device port channels. When applied, the template prompts the user to enter a Virtual LAN (VLAN) identifier (e.g., a value from 1 to 4094) and a routing / security zone. For the applied application point, a subinterface is created in the specified routing / security zone with the specified VLAN identifier. Automatic validation is performed to verify that no other existing subinterface has the same VLAN identifier.

[0073] Another example of a primitive (e.g., that can be used directly as a connectivity template or as a component template to create new connectivity templates) is the IP interface creation template. This template can only be applied to application points such as device ports or device port channels. When applied, the template requests some type of user input (e.g., allowing the user to select an IPv4 network, IPv6 network, local IPv6 link, or unnumbered IPv4 (from loopback)), prefix length (e.g., the IP prefix / mask with the maximum length depending on the selected type), and allocation scheme (e.g., required for IPv4 and IPv6 network types) to allow the user to choose between "manual" or "from an available resource pool" and / or IP address (e.g., manually required for the allocation scheme). For the application point, an IP address is assigned to the interface of the application (e.g., a specific IP address + prefix specified in the template or an idle IP address + prefix automatically determined from a generic system link pool). Validation is automatically performed to verify that the newly assigned IP prefix does not overlap with any other IP prefixes defined in the same routing / security zone. In some implementations, this template supports client resource groups.

[0074] Another example of a primitive (e.g., one that can be used directly as a connectivity template or as a component template to create a new connectivity template) is a virtual network membership template. This template can only be applied to application points such as device ports or device port channels. When applied, the template prompts the user to enter the identifiers of one or more virtual networks to which the application point is to be added (e.g., all virtual networks are tagged by default, but a maximum virtual network can be untagged). For example, a list of existing virtual networks is provided along with corresponding descriptions and VLAN identifiers (e.g., for local VLAN types), and / or the user can search for the desired virtual network by name or identifier (e.g., a specific number or range). The application point is added to the desired virtual network. Validation is automatically performed to determine if the connectivity template conflicts with another connectivity template that may already be applied to the application point (e.g., only one untagged virtual network per application point port).

[0075] Another example of a primitive (such as one that can be used directly as a connectivity template or as a component template to create new connectivity templates) is the route instance template. This template can only be applied to any Internet Protocol (IP) interface (e.g., any IP address of the interface, Switched Virtual Interface (SVI) IP, Loopback IP, etc.). When applied, the template prompts the user to enter an identifier for whether to use Border Gateway Protocol (BGP) or Open Shortest Path First (OSPF) to establish the route instance. Based on the selected protocol, additional configuration is requested from the user. For example, if BGP is selected, the user can choose between unnumbered BGP, BGP P2P + Remote Autonomous System Number (ASN) and peer address (the user can also choose to define the external router for ASN and loopback), or BGP from Switched Virtual Interface (SVI) / Loopback + Remote ASN and peer point. Users can also choose between IPv4, IPv6, or IPv4+IPv6 home type. For the applied application point, appropriate authentication is performed automatically, and the specified route instance is established.

[0076] Another example of a primitive (such as one that can be used directly as a connectivity template or as a component template to create new connectivity templates) is a routing policy template. This template can only be applied to application points that have routing instances. When applied, the template requests user input for the routing policy. For the applied application point, appropriate validation is automatically performed, and the specified routing policy is established.

[0077] Another example of a primitive (such as one that can be used directly as a connectivity template or as a component template to create new connectivity templates) is the static route template. This template can only be applied to application points that have a routing / security zone instance. When applied, the template prompts the user to enter the IP prefix and next-hop address. For the application point to which it is applied, appropriate validation is performed automatically, and the specified static route is established.

[0078] Another example of a primitive (such as one that can be used directly as a connectivity template or as a component template to build new connectivity templates) is the BPDUGuard template. This template can only be applied to application points such as device ports or device port channels. No user input is required for this template. Appropriate validation is automatically performed for the applied application point, and bridging protocol data unit protection is enabled.

[0079] Another example of a primitive (such as one that can be used directly as a connectivity template or as a component template to build new connectivity templates) is the PortFast template. This template can only be applied to application points such as device ports or device port channels. No user input is required for this template. Appropriate validation is performed automatically for the applied application point, and PortFast is enabled.

[0080] At 306, instructions are received regarding the application of a connectivity template in the physical design of the computer network, and the indicated application is implemented. The user indicates where the connectivity template will be applied in the physical design of the computer network. For example, via a graphical user interface, the user selects one or more devices and / or application points of the devices to which connectivity is applied in the design. Different connectivity templates can only be applied to a specific type of application point. For example, based on the configuration / functionality of a connectivity template, it can only be applied to a certain type of application point and cannot be applied to other types of application points. In some implementations, the user interface automatically indicates the objects / locations to which the connectivity template in the physical design of the computer network is eligible to be applied to prevent the user from applying the template to an inapplicable application point. A connectivity template can be one of multiple connectivity templates applied to various parts of the design of the computer network. More than one connectivity template can be applied to the same application point. In some implementations, if connectivity templates applied to the same application point conflict with each other, an error message is provided and / or the user is automatically prevented from applying subsequent connectivity templates that would cause a conflict to the same application point. When application points are applied to an entire device in the network design, the connectivity template is applied to all application points of the device that can be configured by that connectivity template.

[0081] When a connectivity template is applied to an application point, the application point's attributes are established, defined, managed, and / or modified based on the configuration specified by the template. The connectivity template dynamically adapts to the application point's type, network location, context, and / or any other existing attributes. For example, changes made by the connectivity template can be dynamically made based on the type, network location, context, and / or any other existing attributes of the application point to which the connectivity template is being applied.

[0082] In some implementations, the intent of a connectivity template's application is automatically determined, where appropriate, for use in intent-based networking. For example, the intent of a connectivity template's application can be automatically determined based on which connectivity template is applied to which application point. Rules, analytics, and / or machine learning models can be used to determine the intent (e.g., declarative requirements) associated with the template application based on the template's type and / or other attributes and network attributes, context, templates for other applications, or assigned tags or other attributes of the application point to which the template is applied. Based on this intent, additional configurations beyond those explicitly specified in the template can be applied to achieve the desired intent. Therefore, related administrative and management functions can be automatically performed based on intent. For example, the configuration required to collect appropriate telemetry data from appropriate devices / data sources can be automatically implemented to automatically verify / monitor the implementation and functionality of the connectivity template's application intent.

[0083] In some implementations, determining intent includes using and / or building an intent-based network model as a graphical representation (see, for example, see...). Figures 8 to 10 In some implementations, template configuration information can be transmitted to the graphical representation to complete the graphical representation at the appropriate location within the graphical representation. For example, Figure 8 The nodes and edges in the graphical representation shown include multiple properties, such as labels and various attributes, and the corresponding attributes of the applied point are used to determine the intent and / or add / modify based on the connectivity template.

[0084] At point 308, a change in the applied connectivity template or a change in the application point where the connectivity template has been applied is detected, and in response, the configuration of the computer network is automatically updated using the applied connectivity template.

[0085] In some implementations, when an existing connectivity template is modified, the instance applying the connectivity template is updated to reflect the new modification. This allows primitives applied in multiples to be centrally managed at the template level. For example, a user can make changes to an existing connectivity template, and those changes are automatically implemented at the application points where the template was previously applied. This allows user changes to be automatically propagated without requiring the user to reapply the changed template to all appropriate application points. In one specific embodiment, for a routing policy with a list of route maps and route import / export rules shared across multiple different BGP peers, the routing policy can be defined once in the connectivity template and applied to multiple route instances, with centralized management via the template.

[0086] In some implementations, when the underlying network or application point to which the applied template has been modified, the configuration previously made based on the connectivity template is automatically updated based on the modification of the underlying target application point. For example, when an application point moves from one network location context to another, the connectivity template already applied to the application point automatically adapts to the new network location context by reconfiguring the template for the application point to be applied to the new network location context. In one specific embodiment, the applied connectivity template automatically adapts to movement from a local VLAN to a newly established Virtual Extended Local Area Network (VXLAN).

[0087] An example of a connectivity template is one that enables BGP peering sessions toward floating IP addresses. This template allows application points in the network architecture to automatically adapt to floating IP addresses (e.g., migrating to a different network architecture) without requiring manual network architecture updates, thus allowing virtual machine servers to move between different switches across a network without manual reconfiguration. For example, this template specifies a BGP relationship with a floating / moving endpoint. When a move to a new switch is detected (e.g., via information from the hypervisor), a reconfiguration is automatically performed, including changes to the telemetry data source to the new switch. This can be achieved by applying the template's routing instance and routing policies to Virtual Network Switched Virtual Interface (SVI) IP addresses that exist on multiple devices (e.g., rationalizing where they should be applied and determining their existence across multiple destinations) and providing BGP sessions on multiple devices while maintaining only one active session at a time (e.g., as specified by the hypervisor manager).

[0088] Figure 4 This illustrates one implementation of the process for applying connectivity templates. Figure 3 Execution in method 306 Figure 4 At least a part of it.

[0089] At position 402, a selection of one or more connectivity templates to be applied to the computer network design is received. In some implementations, a library of one or more available connectivity templates is provided, and the user selects one or more connectivity templates from the library to apply to the computer network design. For example, the user examines the selection box near the connectivity template to be applied to the network design. The user is also able to create new connectivity templates, modify any existing connectivity template, or clone an existing connectivity template for further customization.

[0090] At 404, the network design is analyzed to determine eligible application points in the network design where each of one or more connectivity templates can be applied. For example, the network design, including physical devices and connections between devices, has been specified (e.g., connections organized as network pods, which include racks, spine nodes, and leaf nodes including interfaces and sub-interfaces), and for each selected template to be applied, eligible application points in the physical design of the network where the selected connectivity template can be applied are automatically determined. Connectivity templates are typically only suitable for application of a certain type of application point. For example, based on the configuration / functionality of a connectivity template, it may only be applicable to one type of application point and not to others. To prevent users from applying connectivity templates to unqualified application points, all possible application points in the network design where connectivity templates can be applied are pre-determined to indicate constraints before the user selects an application point to apply the template.

[0091] The types of application points to which a connectivity template can be applied can be determined based on the specifications / configurations / functionality of the connectivity template and / or the component connectivity templates that make up the connectivity template. For example, if a connectivity template is composed of other connectivity templates, then the intersection of the set of application point types and the applicable component connectivity template is determined to identify the types of application points applicable to all component connectivity templates. Furthermore, the intersection of the types of application points applicable to any attribute / configuration of the connectivity template is determined to identify the types of application points applicable to all template attributes / configurations.

[0092] Once the types of application points to which each selected connectivity template can be applied are determined, the network design is searched / analyzed to identify each application point in the network design that matches the eligible types of each selected connectivity template. Thus, for each selected connectivity template to be applied, a list of each application point in any type of network design to which the template is eligible for application can be determined.

[0093] At 406, a designation is received for one or more of the determined qualified application points to which one or more connectivity templates are to be applied. In some implementations, for each selected connectivity template, the user interface provides a list of suitable application points, and the user selects an application point from the provided list for applying the selected connectivity template. For example, if a template is to be applied to an application point, the user selects a checkbox next to that application point.

[0094] Figure 5 This is a diagram illustrating an implementation of a user interface for creating new connectivity templates. In some implementations, in Figure 3 Utilizing 304 Figure 5 The user interface 502 shown is used to construct new connectivity templates. User interface area 504 lists existing connectivity templates (including primitives) to be used to construct the new connectivity template. When the "Use" link for one of the existing connectivity templates is selected, an instance of the corresponding connectivity template is instantiated for use in the new template. User interface area 506 shows a graphical flow visualization of the component connectivity templates used to construct the new template, their application order, and the relationships between them. User interface area 508 shows input fields where the user can enter configuration parameters for the component connectivity templates.

[0095] Figure 6 This is a diagram illustrating an implementation of a user interface for selecting a connectivity template to apply. In various implementations, Figure 6 The user interface 602 shown is in Figure 3 304 and / or Figure 4The 402 section is used to indicate the connection template to be applied. The user interface 602 displays a list of available connection templates (including primitives), and the user can check the box next to the connection template that the user wants to apply. In addition, the user can also perform actions to edit, copy, or delete the corresponding connection template via the provided buttons.

[0096] Figure 7 This is a diagram illustrating an implementation of a user interface for applying connectivity templates. In various implementations, in... Figure 3 306 and / or Figure 4 Utilizing in 406 Figure 7 The user interface 702 shown is used to apply connectivity templates to the desired application points. It has been determined that... Figure 6 The user interface 702 selects eligible application points in the network design for connectivity templates. The user interface 702 displays a hierarchical list of elements in the network design. Furthermore, for each selected connectivity template chosen for an application (e.g., named "VLAN10" and "VLAN20"), a checkbox is displayed in the row of the application point in the corresponding column of the connectivity template if the corresponding template is applicable to the corresponding application point. If no checkbox is displayed, the corresponding template cannot be applied to the corresponding application point. The user can select the appropriate checkbox to apply the corresponding template to the corresponding application point. The user interface 702 also displays labels assigned to the corresponding application points. These labels can be used to search for application points and determine the intent associated with the application of a connectivity template to an application point.

[0097] Figure 8This is a graph illustrating implementations of nodes and edges that can be included in a graph model. In some implementations, the graph model of the computing infrastructure consists entirely of nodes and edges. All nodes can share the same structure, and edges share the same structure. In the example shown, node 800 includes several properties, including identifier (ID), type, tag, label, and attribute. In some implementations, the ID includes a unique identifier, such as a string or integer. The ID can be used to identify a node in the graphical representation and distinguish it from other nodes and edges. In some implementations, the type describes the immutable type to which the node is classified. The type can be a string. In various implementations, a node is a type of server, switch, policy, rule, user, or any abstract concept. In some implementations, the tag is a user-friendly title used to identify the node. The tag can be a string. For example, if a node is of type server and it is a third server present in the network, then the node can be tagged as "Server 3". In some implementations, the label is a flexible identifier used to group network components together. For example, users use labels to encode groups that cannot be grouped based on type. Labels can be used to encode groups that are not available in the graphical representation associated with the graphical representation. Tags can be used to group subsets of nodes of the same type, groups of edges of different types, or any combination of nodes and edges. Tags can be in a user-friendly format, such as strings (e.g., "high_availability_servers"). In some implementations, attributes include node properties or data associated with a node. In some implementations, attributes include a list of key-value pairs of any data expected to be associated with a node. For example, attributes may include information related to computer memory size or server speed. Characteristics may include telemetry data.

[0098] As shown, edge 802 includes multiple properties, including ID, type, tag, label, source, destination, and attribute. In some implementations, the edges in the graphical representation of the network configuration include the same properties (e.g., ID, type, tag, label, attribute) as the nodes in the graphical representation, with the source and destination added.

[0099] In some implementations, the ID includes a unique identifier, such as a string or integer. The ID can be used to identify edges in the graphical representation and distinguish them from other nodes and edges. In some implementations, the type describes the immutable type to which the edge is categorized. The type can be a string. In various implementations, the edge is a type of "link," "interface," "hosted," "applied to," or any abstract concept. In some implementations, the label is a user-friendly caption used to identify the edge. The label can be a string. For example, an edge might be labeled "hosted (host_on)" because the edge is of the "hosted" type. In some implementations, the tag is a flexible identifier used to group network components together. For example, users use tags to encode groups that cannot be grouped based on type. Tags can be used to encode groups that are not available in the graphical representation associated with the graphical representation. Tags can be used to group subsets of edges of the same type, groups of nodes of different types, or any combination of nodes and edges together. Tags can be in a user-friendly format, such as a string (e.g., "open_connections"). In some implementations, attributes include properties of the edge or data associated with the edge. In some implementations, attributes include a list of key-value pairs expected to be associated with the edge. For example, attributes may include information related to computer memory size or server speed. Attributes may include telemetry data.

[0100] In some implementations, edges are directional and represent relationships between two nodes. In some implementations, the source refers to the source / originating node of the edge and the destination refers to the destination / target node of the edge. The source and destination can consist of strings referencing nodes in the graphical representation. For example, the source and destination of an edge in the graph model can include the ID of a node existing in the graph model. Edges can represent a unidirectional relationship between two nodes. Multiple edges can exist between two nodes. For example, a switch node (e.g., a node of type "switch") can have a relationship with a hosted interface node (from the switch node to the interface node), while an interface node can have a "hosted_on" relationship with the switch node (from the interface node to the switch node). As shown, edge 802 is directional, where node 800 is its source and its destination is the node it points to. In a network configuration graphical representation, each edge can have source and destination nodes.

[0101] In some implementations, not all properties (e.g., ID, type, label, etc.) need to be specified during node or edge creation. Default properties can be used. For example, given a source and a destination, the edge type can be inferred. In some implementations, the edge type is inferred based on the node types of the source and destination. In some implementations, IDs and labels are generated randomly and / or automatically. For example, when creating a node of type "server", the label can be incremented to "server_1", "server_2", etc., to label the node. Attributes can be determined based on type. The default setting for labels can include no label.

[0102] In some implementations, graphical representation allows for the flexible representation of various concepts while the structure of graphical elements remains static. Graphical representation can allow for robust and scalable systems. For example, a policy-type node can include attributes describing a policy as using a specific resource pool. A "policy_applies_to" type edge, with a "policy" type node as the source and a "switch" type node as the target, represents a policy implemented on a switch. An agent with a trigger pattern of a "policy_applies_to" type edge, along with a "policy" type source node and a "switch" type target node, can invoke an agent to implement the policy if, in a part of the graphical representation, the pattern of the "policy_applies_to" type edge matches the "policy" type source node and the "switch" type target node.

[0103] In some implementations, telemetry data collected during the use and execution of the computing infrastructure is mapped to corresponding graphical elements to (e.g., visually) provide a representation of the telemetry data in a graph model format. In some implementations, the attributes of nodes or edges include telemetry data collected from the device. For example, this may include transmitted / received traffic volume, the number of errors, fan speed, temperature, the number or type of control processes running, or any other suitable operational data. In some implementations, the graph model is updated using real-time telemetry data. Users can access telemetry information or other information in the network configuration graph using a query language (e.g., GraphQL). In some implementations, the telemetry information is read-only. Telemetry data may be stored in a key-value format, where the key includes parameters (e.g., fan speed) and the value includes measured parameter values ​​(e.g., fan speed in revolutions per millisecond).

[0104] Graphical representations can change as requirements change and attributes associated with graphical representation elements are updated. In some implementations, changes to the graphical representation are detected and it is determined whether the change affects a triggering graphical representation pattern. For example, processing agents performing processing may each be associated with one or more trigger patterns that trigger the processing of associated agents. If a detected change affects a processing agent's trigger pattern, the change can be reported to the agent associated with the trigger pattern. Each agent may be associated with a trigger pattern that identifies a portion of the graphical representation of interest that will trigger the agent's processing. If the graphical representation includes at least a portion that matches an agent's trigger pattern (e.g., a change in declarative requirements alters a portion of the graphical representation that matches a trigger pattern specified for an agent), a processing function of the matched agent can be invoked to allow the processing function to perform processing associated with the matched portion of the graphical representation.

[0105] Figure 9A This is a block diagram illustrating an implementation of a network device. Two switches are shown. In some implementations, the two switches may be connected via a cable between them. In some implementations, the example shown represents a network configuration desired by the user. For example, it may be intended to specify two switches with a cable connecting them. As shown, switch 900 is labeled "Spine 1" and switch 902 is labeled "Leaf 1". As shown, the interface of switch 900 is labeled "Ethernet 1 / 1" and the interface of switch 902 is labeled "SWP".

[0106] Figure 9B This is a diagram illustrating an implementation of a portion of a graphical model. In some implementations, the graphical model portion represents... Figure 9A The network device configuration. Node 904 is of type "switch", labeled "Spine 1", and indicates... Figure 9A The switch is 900. Node 926 is of type "switch", labeled "Leaf 1", and indicates... Figure 9A The 902 switch.

[0107] The node 908 shown is of type "interface" and labeled "Ethernet 1 / 1". Edges 906 and 910 describe the relationship between the Ethernet 1 / 1 node (908) and the spine 1 node (904). Edge 906, of type "host_interfaces", has node 904 as the source node and node 908 as the destination node. Edge 910, of type "host_on", has node 908 as the source node and node 904 as the destination node. Node 920 is of type "interface" and labeled "swp1". Edges 924 and 928 describe the relationship between the leaf 1 node (926) and the swp1 node (920). Edge 924 of type "hosted" has node 920 as the source node and node 926 as the destination node. Edge 928 of type "hosted interface" has node 926 as the source node and node 920 as the destination node.

[0108] Node 914 is of type "link" and labeled "spineToLink". This node relates to the interfaces of spine 1 and leaf 1 nodes. Edges 912 and 916 describe the relationship between Ethernet 1 / 1 nodes and spineToLink nodes. Edge 912, of type "link", has node 908 as the source node and node 914 as the destination node. Edge 916, of type "interface", has node 914 as the source node and node 908 as the destination node. Edges 918 and 922 describe the relationship between SWP1 nodes and spineToLink nodes. Edge 922, of type "link", has node 920 as the source node and node 914 as the destination node. Edge 918, of type "interface", has node 914 as the source node and node 920 as the destination node.

[0109] Figure 9C This is an example of a trigger pattern. The example illustrates a trigger pattern expressed in a programming language (e.g., Python). In the example shown, a specific combination and order of nodes and edges is defined. Trigger patterns can be defined using any suitable programming language. In some implementations, the example shown describes... Figure 9B This is part of the graph model shown. For example, the description of "node(type='switch')" at 960. Figure 9B Node 904, at position 962, describes ".out('hostedinterfaces')". Figure 9B The edge at 906, and the description of ".node('interface')" at 964. Figure 9B Node 908.

[0110] The trigger pattern shown defines, for example, the trigger pattern as follows: Figure 9B As shown from the left ( Figure 9B Node 904) to the right ( Figure 9B The output relationship of node 926 is not described, but rather... Figure 9B The output relationship is shown from right to left. For example, the trigger pattern only describes... Figure 9B This is a portion of the graphical model shown. In some implementations, in Figure 9B If the shown graph model part is detected in the graph model, added to the graph model, modified in the graph model, or deleted from the graph model, the agent associated with the shown trigger pattern is invoked.

[0111] Figure 9D This is an example of a trigger pattern. In some implementations, one or more associated data structures are specified in the trigger pattern. Tag attributes (e.g., tag properties of nodes or edges) can be used to specify one or more associated data structures. In some implementations, a callback function associated with the trigger pattern is invoked by referencing a data structure specified in the trigger pattern (e.g., by a tag). For example, if a portion of a network configuration graph matches an agent's trigger pattern, a path to a specific node or edge can be provided to the agent. In some implementations, a specific node or edge exists in a portion of the graph model that matches the trigger pattern. A reference or path to a specific node or edge can be used to invoke the agent's callback function, thereby allowing the function to be implemented on the specific node or edge. For example, the callback function may include a tag in the callback function that matches a tag in the trigger pattern. The tag allows the callback function to perform an action on a node or edge in the graph model where the node or edge in the graph model matches a node or edge marked in the trigger pattern. The use of graph model and tag properties allows for easy passing of references to data structures. In some implementations, multiple references to multiple data structures are used to invoke the callback function.

[0112] In the example shown, at 980, the trigger pattern is defined as "node(type='switch', label='local_device')". In some implementations, if a portion of the graphical representation matches the trigger pattern, the node matching the node defined at 980 is labeled as "local_device". A callback function associated with the agent associated with the trigger function can be defined using "local_device" as input. When the callback function is invoked, a reference to the node in the graphical representation that matches the node defined at 980 can be passed to the callback function.

[0113] Figure 10An example of a model diagram (e.g., in Python format) for a graph model is shown. In some implementations, the graph model of a network has associated graph model diagrams. Valid nodes, edges, and relationships between nodes and edges can be defined in the diagram. For example, only nodes of type 1 are allowed to share edges with nodes of type 2. Invalid relationships or nodes can invoke callback functions. For example, a callback function can provide an error to the user or discard the last received intent change. The diagram can be domain-specific; different diagrams may exist for different network architectures.

[0114] Model diagram 1000 is written in Python, but it can be implemented using any computer language. This example illustrates a graph model diagram of a typical leaf-spine network architecture. The disclosed system can treat the various design diagrams as opaque and operate only at the primitive model, which includes only nodes and relationships. As shown, model diagram 1000 describes the allowed data types and values. As shown, 1020, 1022, 1024, and 1026 include the relationships allowed under this diagram. For example, edges of type "composite_of" must have a source node of type "link" and a destination node of type "link"; edges of type "part_of" must have a source node of type "link" and a destination node of type "link"; and edges of type "host_interfaces" must have a source node of type "system" and a destination node of type "interface".

[0115] Figure 11 This is a flowchart illustrating an implementation of a process for verifying an existing computer network. In some implementations, this process is performed by... Figure 1 Management server 102 Figure 2 Management server 200 or Figure 4 The management server 402 executes. In some implementations, in Figure 5 Execution in 508 Figure 11 At least a portion of the processing.

[0116] At 1102, telemetry information associated with the existing computer network is received. Examples of the received telemetry information include information related to device operating status and connectivity, as well as information for filling in telemetry service diagrams (see, for example, [link to relevant documentation]). Figure 9B Information such as hostname, LLDP, BGP, interface, MLAG, VLAN, VRF, and multicast details. Additional examples of received telemetry information include a list of devices, their connections, their roles, port roles, IP addresses, subnets, virtual networks, autonomous system numbers, etc. In various implementations, telemetry information is provided by devices installed on network equipment (e.g., Figure 1 Agent collection on network devices 106 and 108.

[0117] At 1104, constraints associated with the existing computer network are received. Examples of constraints include implicit constraints and user-specified constraints. In different implementations, implicit constraints are based on and are inherent to the reference network type. For example, in an L3 Clos (leaf ridge) design (see, for example, [link to relevant documentation]). Figure 9A In this case, each leaf must be connected to every ridge, unlike other reference network types. Another example of implicit constraints is in L3 Clos (leaf-ridge) and Layer 2 designs, where virtual network subnets must be unique across existing computer networks within a given VRF domain. In different implementations, user-specified constraints are specific to a given network because they are specified by the user. For example, in an L3 Clos (leaf-ridge) design, user-specified constraints could be structurally symmetric (e.g., each leaf should have the same number and / or speed of uplinks to each ridge). Another example of user-specified constraints is high availability in Layer 2 designs (e.g., see...). Figure 9B (Comparison and related descriptions of non-high availability variants and high availability variants of the Layer 2 design).

[0118] At point 1106, the consistency of the intent-based network model of the existing computer network is evaluated based on the received telemetry information and the received constraints. In some implementations, the intent has some constraints when inferring the intent (e.g., requiring a certain device to have a specified role, setting up a certain device connection, etc.). This information can be relied upon during verification. In various implementations, an error is raised if the received telemetry indicates a violation of the received constraints. For example, in an L3 Clos (leaf-ridge) design, an error is raised if the received telemetry regarding connectivity indicates a violation of the implicit constraint connecting each leaf to each ridge. This could happen if a leaf has only 3 links to 4 ridges (e.g., due to a lack of physical cables or a faulty cable). Similarly, an error is raised if user-specified constraints (e.g., structural symmetry) are violated based on the received telemetry. In some implementations, Figures 16 to 18 The verification process is used, at least in part, to verify existing computer networks.

[0119] In some implementations, the user provides information for verification. This information can be provided before verification (e.g., via...). Figure 4The information is provided before the verification of the discovery activation interface. In some implementations, such information can be requested and received during verification. In some implementations, when collecting IP address telemetry information, it is not possible to determine whether they are in the correct range, the correct subnet, etc., solely from the IP addresses. Therefore, the user may need to provide this information as part of the verification. For example, when overlapping IP address spaces are detected via telemetry, the IP addresses may be incorrect but may be correct depending on the user's intent (e.g., when isolated to a separate domain, the IP addresses may need to be reused). For IP addresses, user-specified constraints may include that all structure links are in the specified subnet. Regarding racks, racks may be single-leaf or double-leaf (e.g., a double-leaf rack has a set of links between them). Rack design may include constraints (e.g., the connections between servers on the rack may have constraints). Oversubscription (e.g., the ratio of traffic fed into the leaf to the structure bandwidth) may also be subject to constraints used during verification.

[0120] Figure 12 This is a flowchart illustrating an implementation of a process for automatically configuring computing infrastructure using a graphical model. In some implementations, the process... Figure 1 Management server 102 Figure 2 Management server 200 or Figure 4 The implementation is carried out in management server 402. At 1200, an intent is received. The intent includes the desired computing infrastructure configuration. The intent may specify the desired services, reference architecture, and / or network requirements. In some implementations, the intent is the result of a change in business rules or operational state initiated by the network operator (e.g., a network component is disabled). At 1202, the computing infrastructure is represented as a graphical representation. In some implementations, business rules and policy elements are also represented in the graphical representation. For example, the intent may be processed to determine the graph of nodes and edges when the intent is implemented. In some implementations, network devices are represented by nodes, and relationships between devices are represented by edges. In various implementations, policies, rules, interfaces, summary information, or any other appropriate network configuration information are represented in the graph via nodes and edges. Where the intent indicates a change to the existing network configuration, the intent may be processed and represented as a change to the existing graphical model (e.g., by modifying, deleting, or adding nodes or relationships). Where the intent is the first indication of a network intent, a new graphical model may be created based on the intent. In some implementations, the network is not deployed until sufficient configuration parameters are indicated in the intent. For example, network devices can be configured but cannot be connected online.

[0121] At 1204, a portion of the graphical representation of a trigger pattern affecting the agent is detected. For example, the agent may be associated with a specific trigger pattern of interrelated nodes and edges. In some implementations, the trigger pattern is written in a programming language (e.g., Python, PERL, Java, etc.). The trigger pattern may describe a portion of the graphical model. In some implementations, the trigger pattern defines attributes (e.g., type, attribute, or label) of a node or edge. In some implementations, the trigger pattern defines a specific type of node and edge, and defines how nodes and edges are associated with each other in a particular configuration. A change in the graphical representation may cause a specific pattern to appear in a graphical representation that was not previously present, invoking the agent associated with that specific pattern. For example, the agent may be invoked based on the detection of a specified chain of nodes and relationships of a specific type and in a specific order indicated by the pattern. In some implementations, the trigger pattern associated with the agent matches at least a portion of the graphical representation before the graphical representation changes, and the change in the graphical representation modifies (e.g., changes or deletes) a portion of the graphical representation that previously matched the trigger pattern. This may cause the agent to be invoked in response to the detection that a matched portion of the graphical representation has been modified. For example, the pattern can specify a particular configuration for two specific types of linked nodes, and the pattern is detected in the graphical representation. Changes to the properties of any node in the graphical representation that belongs to the graphical portion matching the pattern can invoke a callback function associated with the pattern. In another example, the removal of any element used to match a trigger pattern in a portion of the graphical representation can invoke a delegate associated with the trigger pattern.

[0122] At 1206, the callback function of the invoked agent is called. In some implementations, the agent is associated with a trigger pattern and a callback function. Upon detection of the agent's trigger pattern, the agent is invoked, and the callback function associated with the agent is called. The callback function executes a command (e.g., to achieve at least a portion of an intent). For example, the graphical model is updated, and the network device is configured by a callback function triggered by a detected change in the appropriate portion of the graphical representation associated with the trigger pattern. In some implementations, a publish-subscribe model for the trigger pattern and callback function enables incremental implementation of changes in network configuration.

[0123] At 1208, if applicable, the graphical representation is updated based on the processing result of the proxy callback function. In some implementations, the callback function causes modification, addition, or deletion of nodes or edges in the graphical representation. The graphical representation is updated based on any changes caused by the proxy callback function. In some implementations, changes to the graphical representation caused by the callback function invoke one or more additional callback functions. In some implementations, the graphical representation accurately represents the network configuration at any given time. Changes to the network configuration can be implemented by modifying the graphical representation, wherein modifying the graphical representation triggers the proxy to execute the change's callback function.

[0124] Figure 13 This is a flowchart illustrating an implementation of the process for invoking a callback function. In some implementations, the process is implemented... Figure 12 1204 and 1206. In some embodiments, the processing is performed by... Figure 2 The agent manager 202 is implemented. At 1300, it is determined whether the graph has changed. The graph may change based on a received intent or based on a invoked callback function. In some implementations, a change in the graph caused by one agent triggers another agent. If the graph has not changed, the process is complete. In some implementations, this process is repeated while the network is active (e.g., configuration is required). If the graph has changed, at 1302, it is determined whether the change in the graph affects one or more agents.

[0125] In some implementations, a change to the graphical representation invokes the agent if a portion of the graphical representation associated with a trigger pattern of the agent is detected in the graphical representation, added to the graphical representation, updated in the graphical representation, or removed from the graphical representation. In some implementations, if a change in the graphical representation causes a portion of the graphical representation to match a specific trigger pattern, the portion of the graphical representation that matches the specific trigger pattern is detected or added to the graphical representation, wherein that portion of the graphical representation previously did not match the specific trigger pattern. For example, if existing nodes and edges in the graph are modified to make a portion of the graph match a specific trigger pattern, the portion of the graphical representation that matches the specific trigger pattern is detected in the graphical representation. If a new graphical portion matching the specific trigger pattern is added to an existing graphical representation, the portion of the graphical representation that matches the specific trigger pattern is added to the graphical representation.

[0126] In some implementations, if a change in the graphic representation modifies a node or edge within a portion of the graphic representation that previously matched a specific trigger pattern, the portion of the graphic representation that matched the trigger pattern in the graphic representation is updated, and that portion continues to match the specific trigger pattern after the change.

[0127] In some implementations, when a change in the graphical representation modifies a portion of the graphical representation that previously matched a trigger pattern, the portion of the graphical representation associated with the trigger pattern is deleted from the graphical representation such that the portion no longer matches the trigger pattern. For example, nodes or edges can be deleted from the portion of the graphical representation that previously matched a trigger pattern, nodes or edges in the portion of the graphical representation that previously matched a trigger pattern can be changed (e.g., changing attributes such as type), or the portion of the graphical representation that previously matched a trigger pattern can be deleted entirely.

[0128] If the changes in the graph do not affect one or more agents, the processing is complete. If the changes in the graph affect one or more agents, a callback function is invoked at 1304. For example, one or more callback functions associated with one or more agents are invoked. In some implementations, the callback function provides an indication of whether a portion of the graph representation associated with the trigger pattern is detected in the graph representation, added to the graph representation, updated in the graph representation, or removed from the graph representation. In some implementations, different callback functions are invoked based on this indication to perform different actions based on the indication. For example, if a specific node relationship pattern is added to the network configuration graph, the callback function allocates resources (e.g., assigns an IP address to a node of type "link"). If the pattern is removed, the callback function removes the resource request for that node.

[0129] Figure 14 This is a flowchart illustrating an implementation of the agent creation process. In some implementations, agents are created to execute callback functions based on trigger patterns. Multiple agents, each tracking different trigger patterns, can work together to appropriately configure the network based on changes in the graphical model of the computing infrastructure. In some implementations, a modular approach using individual agents improves the efficiency of handling changes in intent.

[0130] In some implementations, a pre-created set of agents is associated with a specific network architecture (e.g., a leaf-spine architecture). For example, a set of agents and patterns can be associated with a network having a leaf-spine architecture. Each network architecture type may have a corresponding set of patterns and agents. In some implementations, patterns or agent sets are customized for the network. Characteristics can be added to the network configuration system by creating or modifying agents. For example, the system can be easily extended by adding agents through written logic.

[0131] The example shown illustrates the process of creating an agent. At 1400, a trigger pattern is defined. A trigger pattern can include a portion of the graphical model of the computing infrastructure. An agent can be triggered by any aspect of the graph, such as edges, nodes, attributes, or network configuration. In some implementations, an agent includes multiple trigger patterns. In some implementations, each agent has a single trigger pattern. An agent can inject its trigger pattern as a query into a management server (e.g., Figure 1The query engine in the management server 102. At 1402, a callback function is defined. In some implementations, the callback function defines the action to be taken based on a trigger pattern. For example, an agent may be associated with a trigger pattern of a node of type "link" and a callback function that assigns an IP address. In the case that a node of type "link" is added to the graphical model, the agent may cause the callback function to assign an IP address. In some implementations, the callback function takes nodes or edges of the graphical model as input. For example, the function may be executed at least in part based on nodes or edges in the portion of the graphical model that match the trigger pattern.

[0132] In some implementations, the agent includes a set of callback functions. For example, different functions can be performed based on whether a portion of the graphical model associated with the trigger pattern is added to, modified, or removed from the graphical model (e.g., whether a portion of the graphical model is changed to match the trigger pattern, whether the properties of edges or nodes in the portion of the graphical model that matches the trigger pattern are changed, or whether the portion of the graphical model that matches the trigger pattern is changed to no longer match the trigger pattern). The agent can store multiple functions, where these functions are performed based on the type of change to the portion of the graphical model associated with the trigger pattern (e.g., "added," "modified," or "removed"), the type of the changed data structure, the location of the changed data structure, the reference to / path to the data structure, or any other factor. For example, a trigger pattern may include nodes of a type device with edges of a type link connecting them to nodes of the type link. One callback function may define the action to be performed if the properties of a node of the type device are changed, while another callback function may define the action to be performed if a node of the type link is removed. In cases where the trigger pattern definition includes a pattern of two nodes of the same type, different callback functions can be invoked based on which node is changed.

[0133] Agents can play different roles when configuring a network. In some implementations, a resource allocation agent is associated with a trigger pattern representing one or more network elements that require resource allocation when those elements are present in the network. Callback functions associated with the resource allocation agent can perform actions to allocate the resources required by one or more network elements. For example, the network configuration pattern can be modified to add a cable to the network. A resource allocation agent associated with a trigger pattern created to add a cable can be invoked. A callback function associated with the resource allocation agent can be invoked to trigger the allocation of the resources required for the cable.

[0134] In some implementations, an agent is used to determine whether changes in a graph are consistent with a graph pattern associated with the graph. A semantic validation agent can determine whether a graph is ready for downstream processing based on the graph pattern. Changes may be inapplicable if the graph does not meet the rules stated in the graph pattern. For example, a device configuration cannot be rendered if the IP address is unassigned or invalid. For example, a semantic validation agent can be associated with a trigger pattern of the "instantiated_by" edge type. The graph pattern may indicate that an edge of type "instantiated_by" must have a source node of type "virtual_network" and a target node of type "vn_instance". The semantic validation agent can be triggered when an edge of type "instantiated_by" is added to the graph model. The associated callback function of the semantic validation agent can determine whether the source node of the edge is of type "virtual_network" and whether the target node of the edge is of type "vn_instance". An error message can be provided to the user if the source and target nodes do not have the expected types as defined in the graph pattern.

[0135] In some implementations, once a trigger pattern is detected, the agent performs checks associated with that trigger pattern. For example, the agent performs checks on edges and nodes surrounding a "switch" type node to ensure the required nodes and edges are present. In some implementations, the agent issues an alert or adjusts the network configuration if a network component operates in an unwanted manner. For example, the agent may associate a trigger pattern with the attributes of a "server" type node. If a change in a node's attributes indicates that a server is operating at high temperature, the associated callback function of the telemetry data agent may be invoked to shut down the server associated with the "server" type node.

[0136] Figure 15 This is a flowchart illustrating an implementation of an anomaly detection and response process. In some implementations, the system is used to collect network telemetry data, analyze the network, and respond appropriately in a closed loop. Anomalies, operational signals, impact analysis, or any other suitable information can be extracted from the raw telemetry data. For example, detecting an outage of a service, device, or functional component (e.g., via telemetry data) can subsequently identify affected consumers or identify and collect additional telemetry data as needed. Based on this analysis, appropriate actions can be taken to notify affected parties or correct the anomaly.

[0137] At 1510, a portion of the graphical representation is determined to match the trigger pattern. In some implementations, the trigger pattern defines a set of managed network elements, wherein these managed network elements are monitored for anomalies. For example, the trigger pattern may include a set of links traversed by traffic belonging to a specific virtual network of a specific tenant. At 1512, aggregate attributes of the set of network elements are calculated. In various implementations, standard deviation, minimum, maximum, average, or any suitable statistic or attribute is calculated. For example, the most recent historical time series of traffic on each link may be created and run through a watermark aggregator to determine the number of links that have been running for more than 30 seconds at over 80% utilization. At 1514, conditional logic is applied to the results to detect anomalies. In some implementations, predefined conditional logic includes thresholds for aggregate attributes (e.g., maximum or minimum values), and anomalies are detected based on these thresholds in the event of anomalies in the calculated aggregate attributes. For example, an anomaly may occur if more than 5% of the links in a set have been running for more than 30 seconds at over 80% utilization. At 1516, additional telemetry data is collected based on the anomalies. For example, a complete set of tenants that contributed to the traffic on the set of links may be identified. At point 1518, identify the party affected by the anomaly. For example, other virtual networks and tenants affected by the anomaly can be identified. At point 1520, take appropriate action based on the anomaly. For example, traffic can be redirected to different links, or affected tenants can be requested to reduce link utilization.

[0138] In some implementations, closed-loop telemetry collection, analysis, and response processing are automated. In some implementations, the aggregation properties of the group of network elements are continuously monitored based on time intervals (e.g., calculated every five seconds).

[0139] In some implementations, an agent is associated with a trigger pattern that defines a set of managed network elements. In some implementations, the trigger pattern also defines attributes of that set of managed network elements. For example, "transmitted_bytes" refers to the number of bytes transmitted and is an attribute of a "link" type node. The agent's associated trigger pattern specifies the number of transmitted bytes traversed by traffic belonging to a specific virtual network for a specific tenant by specifying the "transmitted_bytes" attribute of a set of links. In some implementations, a function is executed based on the attributes specified in the trigger pattern to calculate aggregate attributes. For example, an agent associated with a trigger pattern that specifies the "transmitted_bytes" attribute of a specified set of nodes of type "link" may be associated with a callback function that determines the percentage of links (within the set of specified nodes of type "link") that have been running for more than 30 seconds at over 80% utilization.

[0140] In some implementations, an agent is associated with a set of functions that calculate aggregate attributes of managed elements, apply conditional logic to the aggregate attributes, detect anomalies, and store anomalous data (e.g., information about the existence of an anomaly or information about details of the anomaly, such as the percentage of links running for more than 30 seconds at over 80% utilization) in a graphical representation. For example, a callback function might determine if the percentage of links running for more than 30 seconds at over 80% utilization exceeds a threshold. If the percentage exceeds the threshold, an anomaly is determined, and the anomalous data is stored. For example, the anomalous data might be stored as a node attribute (e.g., "aggregated_traffic" as an attribute of a node of type "link," referring to the percentage of links running for more than 30 seconds at over 80% utilization). In some implementations, the anomalous data triggers an additional agent. For example, an additional agent might be associated with a trigger pattern for the "aggregated_traffic" attribute of a set of links that traverse a specific virtual network belonging to a specific tenant. The additional agent might trigger additional telemetry. For example, a function associated with an additional agent might be defined as identifying a complete set of tenants contributing to traffic on that set of links. In some implementations, a separate agent is associated with a trigger pattern that specifies a set of affected parties. For example, the trigger pattern might specify a tenant with a virtual network hosting endpoints on servers connected via links where aggregated traffic exceeds a threshold (e.g., a "tenant" type node sharing an edge with a node of type "virtual_network," where the "virtual_network" type node shares an edge with a node of type "endpoint," where the "host_on" type node shares an edge with a node of type "server," where the "server" type node shares an edge with a node of type "link," where the "link" type node has the attribute "aggregated_traffic"). The separate agent can perform the associated functions that alert the tenant.

[0141] In some implementations, aggregate properties (e.g., as node properties) are saved regardless of whether an anomaly is detected. Callback functions triggered based on aggregate properties may include conditions (e.g., the function will not be invoked if the aggregate property value is not determined to be an anomaly).

[0142] In some implementations, 1512, 1514, 1516, 1518, and 1520 are represented in the graphical representation. In some implementations, the workflow of processing stages (e.g., the steps described at 1512, 1514, 1516, 1518, and 1520) is represented in a directed acyclic graph. In some implementations, each step is represented as a node. The order of the illustrated flow can be represented via directional edges. For example, a node of type "process_step" may include information about the aggregation properties of computational network elements and may have a directed edge pointing to another node of type "process_step" that includes information about applying conditional logic to the aggregation properties, such that the aggregation property computation step is performed before the conditional logic step. In some implementations, the workflow of processing stages (e.g., the steps described at 1512, 1514, 1516, 1518, and 1520) is represented as part of the graphical representation and as part of the graphical representation of the computing infrastructure. In some implementations, the sequence of steps is represented in a separate graph.

[0143] Agents can subscribe to graphical elements representing stages and react to them by performing desired processing. In some implementations, agents are associated with trigger patterns of graphical elements representing processing stages or steps. In some implementations, agents have associated callback functions that perform processing defined or parameterized by the graphical elements. For example, in the case of requesting data analysis on a specified node of type "link", a series of nodes of type "process_step" originating from the specified node of type "link" can be created. This series of nodes can include a single chain. For example, an edge pointing from the specified node of type "link" can be created, and the specified node of type "link" can be connected to a subsequently created node of type "process_step", wherein the newly created node of type "process_step" has node attributes describing a formula for calculating aggregate properties. After creating a node of type "process_step" with node attributes describing a formula for calculating aggregate properties, a new edge pointing from the aggregate property calculation node can be created, and the aggregate property calculation node can be connected to a subsequently created node of type "process_step" with node attributes including a threshold. In some implementations, the creation of a node of type "process_step" causes an agent associated with a trigger pattern of a specified node of type "process_step" to be triggered. Nodes of type "process_step" can be created one at a time, triggering agents in the desired order.

[0144] For example, an agent for an associated trigger pattern of a specified node of type "link" with a "transmitted_bytes" attribute can be associated with a callback function that determines whether the specified node of type "link" has an output edge pointing to a node of type "process_step," and if the specified node of type "link" does indeed share an output edge with a node of type "process_step," the "transmitted_bytes" attribute value of the node of type "link" is saved to the attribute of the node of type "process_step." The "transmitted_bytes" attribute value can be stored under the "base_calculation_value" attribute of the node of type "process_step." In some implementations, the calculation of aggregate attributes is parameterized by the trigger pattern (e.g., the attribute of the transmitted bytes is defined in the trigger pattern and used as input to the calculation of the percentage of overutilized links). For example, a proxy associated with a trigger pattern for the "base_calculation_value" property of a node of type "process_step" can cause a callback function associated with the proxy to perform calculations of aggregate properties based on the value stored under the "base_calculation_value" property of a node of type "process_step" and the formula stored under the "formula" property. In some implementations, aggregate properties are stored as node properties (e.g., as the value of the "aggregate_property" property). In some implementations, these values ​​are passed between processing stages by storing them as node or edge properties.

[0145] Creating a second node of type "process_step" with a node attribute of a specified threshold can trigger an agent associated with a trigger pattern of the specified node's "threshold_value" attribute. A callback function associated with the agent can determine the presence of an anomaly based on the "threshold_value" attribute value of the second node of type "process_step" and the "aggregate_property" attribute value of the first node of type "process_step". If an anomaly is detected, the "anomaly" attribute of the second node of type "process_step" can be updated to indicate the presence of an anomaly. In different implementations, the processing steps are performed by different configurations of graphical elements (e.g., nodes, attributes, and edges) and agents.

[0146] Figure 16This is a flowchart illustrating an implementation of the process used to generate a validation model. Figure 16 The processing can be done Figure 1 It is implemented on the management server 102.

[0147] At 1602, a set of service requirements is received. The service can be a network service and / or other types of services. In some implementations, this set of requirements includes a set of declarative requirements. For example, declarative requirements can express the desired configuration of network components without specifying precise local device configurations and control flows. By utilizing declarative requirements, it is possible to specify what should be implemented, rather than how it should be implemented.

[0148] At 1604, a verification model is generated for each device in the set of requirements to verify the status and implementation of the service. In some implementations, generating the verification model involves using the received set of requirements and one or more received constraints associated with that set of requirements to determine a more complete set of requirements to be used to generate one or more verification models and one or more device configurations. In some implementations, a verification test procedure is performed, and the results are compared with the generated expectations. In some implementations, the received set of requirements has been processed to include information such as cabling diagrams / maps. For example, the set of requirements received at 1602 may be processed to specify the topology of connections between network components.

[0149] At point 1606, each generated verification model is provided to each appropriate device in one or more devices used to implement the required service. In some implementations, providing the generated verification model includes sending the generated verification model to an agent of the appropriate device. For example, Figure 1 The agent of management server 102 can send the generated verification model to Figure 1 The network device 106's agent sends another generated verification model to... Figure 1 The network device 108 is an agent. In some implementations, providing each generated verification model includes storing each generated verification model in a data storage (e.g., Figure 1 The data in the data storage 104) is stored in the graph representation of the node's data to allow one or more agents to read and access their corresponding verification models from the graph representation node. Therefore, the agent stores the verification model in the graph representation node to pass information, rather than passing the verification model directly to the device.

[0150] In some implementations, the graphical representation is validated to ensure it conforms to the patterns defining allowed elements and how the graphical representation is structured / connected. For example, an agent triggered by a new / modified element or connection in the graphical representation can perform validation of the new / modified element or connection via its callback function to ensure it meets the rules of the pattern. In some implementations, validation is performed during monitoring of the computer network (e.g., monitoring the computer network to detect problems or anomalies). In some implementations, validation is performed when configuring the computer network (e.g., configuring a new computer network for operation based on declarative requirements).

[0151] Figure 17 This is a flowchart illustrating an implementation of a process for detecting state parameters. Figure 17 The processing can be done Figure 1 Implemented on network device 106 and / or network device 108. For example, Figure 17 At least a portion of the processing can be handled by Figure 1 One or more agents of network device 106 and / or network device 108 shall perform this action.

[0152] At 1702, the verification model is received. In some implementations, a proxy receives the verification model. The proxy may be a proxy configured to handle verification using the verification model. In some implementations, the received verification model is... Figure 16 The verification model is provided in 1606. For example, the agent of the device being verified can obtain the verification model from another agent.

[0153] In some implementations, the received verification model is Figure 16 The verification model provided for the agent's device is specified in 1606. In some implementations, receiving the verification model includes detecting (e.g., via a matching trigger pattern) that the verification model has been stored in a node of a graphical representation. In some implementations, the verification model includes a list of one or more connections and associated parameters of the connections, and the associated device / agent of the verification model reports / verifies the presence, status, and / or parameters of the listed connections.

[0154] In some implementations, the verification model includes a list of one or more service processes that should operate on the associated device of the verification model, and the presence, status, and / or parameters of the service processes listed by the associated device / agent report / verify. In some implementations, the verification model includes a list of one or more IP addresses that should be configured and operated on the associated device of the verification model, and the presence, status, and / or parameters of the IP addresses listed by the associated device / agent report / verify. In some implementations, the verification model includes a list of one or more interfaces of the associated device to be verified, and the presence, status, and / or parameters of the interfaces listed by the associated device / agent report / verify. In some implementations, the verification model includes a list of one or more connections between an interface of the associated device and an interface of another connected device that should be configured and operated, and the presence, status, and / or parameters of the interface connections listed by the associated device / agent report / verify. In some implementations, the verification model includes a list of one or more device identifiers of the associated device, and the presence, status, and / or parameters of the device identifiers listed by the associated device / agent report / verify.

[0155] At 1704, one or more parameters to be reported are determined to validate the validation model. In some implementations, the validation model identifies one or more parameters. For example, the validation model may include a list of parameters of interest and the status / validation of each of these parameters to be reported. Examples of parameters and statuses include parameters / status of a connection session, services, IP addresses, interfaces, interface connections, device configurations, device attributes, ports, quality of service metrics, etc. In some implementations, the validation model identifies a higher-level conceptual item to be validated rather than a specific parameter to be validated, and identifies one or more parameters that need to be validated to validate that item. For example, the validation model may identify a connection to be validated and identify one or more parameters of the connection that need to be validated. In some implementations, determining one or more parameters includes generating a list of status parameters that need to be detected from the device based on the validation model. In some implementations, determining one or more parameters includes identifying device / OS-specific parameters to be validated to validate the item of the validation model. For example, the validation model may include validation instructions / parameters that are not specific to a particular device type and / or device operating system, and an agent translates the validation instructions into device type / OS-specific instructions / parameters. The generation of the validation model is simplified by allowing the protocol / format / instructions of the validation model to be vendor / OS-specific. Because each agent can be dedicated to a specific type of device vendor / operating system, agents are the most efficient entities for performing the conversion between generic verification projects of a verification model and device-specific projects.

[0156] At 1706, the determined parameters are detected. In some implementations, parameter detection is performed upon receiving the verification model. For example, initial verification may be performed to ensure that the service of the verification model has been correctly initialized / configured in the graphical representation. In some implementations, parameter detection is performed periodically. For example, verification may be performed on a continuous basis at periodic intervals to continuously ensure the correct operation of the service. In some implementations, parameter detection is performed periodically (e.g., at each periodic interval). In some implementations, parameter detection is performed dynamically. For example, when a potential material change is detected (e.g., in the graphical representation), parameter detection may be invoked and performed to ensure that the service still operates correctly despite the change. Examples of changes may include changes to one or more of the following: network connectivity, device hardware, device operating system, device applications, error events, and any state of the device associated with the verification model. In another example, when the device (e.g., a switch) operating system is notified of a change (e.g., a change to a routing / routing table), the operating system may instruct an agent to trigger parameter detection in response.

[0157] In some implementations, detecting the determined parameter includes obtaining the status of the parameter. For example, the status of a network connection can be obtained. In another example, it can be determined whether the identified process is still running. In some implementations, detecting the determined parameter includes obtaining the value of the parameter. For example, the network identifier (e.g., IP address) of the identified network connection can be determined. In some implementations, detecting the determined parameter includes obtaining information reported to the device from another device. For example, the device performing the verification detection can receive status reports / messages from its neighboring devices and obtain the information contained in these reports / messages. In some implementations, detecting the determined parameter includes performing a query on another device connected to the device performing the verification detection. For example, a query message can be sent to another device to detect the parameter. In another example, a ping message or a request for information can be sent. In some implementations, detecting the determined parameter includes obtaining received messages identifying the parameter / status from connected nodes / devices. For example, a Link Layer Discovery Protocol (LLDP) message can be received from a peer-to-peer switch and reported / analyzed to perform verification.

[0158] At 1708, the detected parameters are reported. For example, one or more detected parameters can be detected by one or more agents (e.g., Figure 1The agent of the management server 102 (which is assigned to perform verification tasks) detects and stores the parameters in one or more nodes of a graphical representation. In some implementations, reporting the detected parameters includes performing analysis to determine the verification result. For example, one or more detected parameters are detected by an agent triggered by a change in a parameter of a node in the graph model, and the agent's callback function can perform a comparison with one or more expected values ​​of the parameter to determine whether the expected value has been detected, and include an identifier of the comparison result in the report. In some implementations, reporting the detected parameters includes using a callback function of an agent triggered by an associated trigger pattern to determine a summary of one or more of the detected parameters. For example, the detected parameters can be categorized, organized, analyzed, recorded, and / or statistically analyzed, and one or more results can be included in the provided report.

[0159] In some implementations, the parameters detected by the report include storing the report in one or more nodes of a graphical representation and / or providing the report to a user. In some implementations, the report includes a determined summary / count of one or more parameters. For example, in addition to a list of individual states / parameters for each interface (e.g., state identifier, last state update time, etc.), the number of active, inactive, anticipated, etc. interfaces may be determined and included in the report. In another example, in addition to a list of individual states / parameters for each session (e.g., session state, last state update time, source / destination IP address / ASN, etc.), the number of active, inactive, anticipated, etc. sessions (e.g., BGP sessions) may be determined and included in the report. In some implementations, the report includes identification of LLDP messages and one or more parameters of messages exchanged between the device and its peers (e.g., identification of sending / receiving interfaces and devices, message timestamps, etc.).

[0160] Figure 18 This is a flowchart illustrating an implementation method for processing verification reports. Figure 1 This can be achieved in the manager server 102. Figure 18 The processing. In some implementations, Figure 18 At least one or more parts of the processing are executed by one or more agents.

[0161] At 1802, one or more reports of parameters detected by one or more verification models are received. In some implementations, the received reports are... Figure 17The report provided in 1708 comes from one or more different agents in one or more instances. For example, a report may be received from each device that has been configured to provide the service being authenticated. In some implementations, receiving reports includes receiving reports directly from one or more devices. In some implementations, receiving reports includes obtaining / receiving reports from one or more nodes represented in the graph.

[0162] At 1804, the report is analyzed. For example, report data included in the received report can be correlated, compared, and otherwise analyzed to determine whether the service has been properly implemented / configured and / or is operating appropriately. In some implementations, one or more expected values ​​and / or expected states corresponding to the appropriate operational state of the service are known, and the report is analyzed to verify that the expected values / states have been detected. In some implementations, analyzing the report includes determining whether an error message and / or an unexpected state has been reported in the report.

[0163] In some implementations, verification is expected in relation to the received report. For example, one or more rules or tests may be executed to verify that the values ​​included in the report are expected, specified, and / or within range. In some implementations, the expectation includes one or more tests to be performed to verify that a set of requirements has been successfully implemented. For example, a received set of network requirements may specify one or more tests to be performed to verify that the set of network requirements has been successfully implemented. For example, in an L3Clos network, tests to verify that the routing table has been successfully updated and that leaf switch nodes know that their neighbors reflect the Clos network configuration may be received along with the received network requirements. This test may be published by one or more agents, and one or more agents may receive the test as an expectation for verification. In some implementations, it is expected that the acceptable range of resource utilization indicators will be identified. In some implementations, it is expected that the error state of the received status will be identified.

[0164] In some implementations, performing analysis includes determining whether throughput and / or quality of service / attribute metrics are met. In some implementations, performing analysis includes determining whether all required connections between devices for providing the desired service have been appropriately configured / detected in all reports from the device providing the service. For example, data reported in multiple reports from different devices can be correlated to determine connection data / parameter matching between two devices supporting the connection to create a valid connection, rather than simply checking each report individually. In some implementations, performing analysis includes determining whether one or more parameters / connections are irrelevant (or presumed not to exist for providing the required service). In some implementations, performing analysis includes verifying domain isolation and / or ensuring that a domain does not over-utilize resources.

[0165] At 1806, if applicable, actions are performed based on the analysis of the report. In some implementations, no action is performed if the data included in the received report is expected, specified, and / or within the expected range. For example, it may be determined that the service is properly operating and / or properly configured. In some implementations, it is determined that the service is not properly operating and / or not properly configured, and a message is provided to indicate this error (e.g., via an agent). In some implementations, it is anticipated that the response action to be performed is identified based on the data in the received report. In some implementations, performing actions includes reporting the reported data. For example, the results of a test may be reported (e.g., reporting the results of a test verifying that the set of network requirements has been successfully met). In some implementations, reporting the reported data includes data summarizing the report. Reporting the reported data may include providing a report / status to an agent (e.g., the agent may provide a report / status to a user).

[0166] In some implementations, performing actions includes configuring, moving, removing, and / or adding network devices and / or processes / programs for network devices. For example, an agent may generate instructions for automatically mitigating / repairing errors indicated by status (e.g., repairing / replacing devices that have encountered errors) (e.g., publishing device requests to the system data store for the agent to implement on the device). In one instance, when an agent provides a status update on its associated device overload, the agent may add a new device to the network to offload processing and / or move the processing tasks of the overloaded device to another network device. The collected status information may be provided by the agent as reports and / or action requests.

[0167] In some implementations, performing an action includes allowing an agent configured to perform an action to do so. For example, an agent that has determined that a received status indication should perform an action notifies another agent (e.g., due to the detection of an agent's trigger pattern) to perform the action.

[0168] Although the above embodiments have been described in some detail for clarity of understanding, the invention is not limited to the details provided. Many alternative ways of implementing the invention exist. The disclosed embodiments are illustrative and not restrictive.

Claims

1. A method for using connectability templates, comprising: Receive the identifier of a connectivity template to be applied to a design of a computer network, wherein the connectivity template is configured to be applied to a set of one or more application point types; From a plurality of application points in the design of the network, a qualified application point is identified, wherein determining the qualified application point includes: in response to a match between the application point type of a first application point in the plurality of application points and at least one of a set of one or more application point types of the connectivity template, determining to include the first application point in the qualified application points; and in response to a mismatch between the application point type of a second application point in the plurality of application points and a set of one or more application point types of the connectivity template, determining not to include the second application point in the qualified application points. Receive a designation for one or more designated application points from the identified qualified application points to which the connectivity template is to be applied, wherein the identified qualified application points include at least one application point not included in the designated one or more designated application points; and The connectivity template is applied to one or more designated application points among the identified qualified application points to configure the computer network.

2. The method according to claim 1, wherein, The identifier of the connectivity template specifies the selection from the available connectivity template library.

3. The method according to claim 1, wherein, The connectivity template is created by the user using one or more other connectivity templates that include at least one primitive.

4. The method according to claim 1, wherein, The connectivity template is configured using one or more parameters provided by the user.

5. The method according to claim 1, wherein, The design of the computer network includes the specification of physical devices and the specification of connections between the physical devices.

6. The method according to claim 1, wherein, The design of the computer network identifies one or more general-purpose devices with corresponding application points.

7. The method according to claim 1, wherein, The design of the computer network is automatically generated, at least in part, based on intent-based declarative requirements provided by the user.

8. The method according to claim 1, wherein, The identified qualified application points include at least one of the following: port, port channel, sub-interface, routing instance, routing security zone instance, and Internet Protocol (IP) interface.

9. The method according to claim 1, wherein, Automated analysis of the network design to identify the qualified application points includes: analyzing the connectivity template to determine a set of application point types, and the intersection between each set corresponding to a different component connectivity template utilized in the connectivity template.

10. The method of claim 1, further comprising indicating via a user interface that the qualified application points identified are qualified for application of the connectivity template, and indicating that other application points are unqualified for application of the connectivity template.

11. The method according to claim 1, wherein, Receiving a designation for one or more designated application points from the identified qualified application points includes: receiving a user's selection of an item from the list of identified qualified application points.

12. The method according to claim 1, wherein, The connectivity template is one of a plurality of connectivity templates applied to the same connectivity point among the identified qualified application points.

13. The method according to claim 1, wherein, Applying the connectivity template to one or more designated application points among the identified qualified application points includes: establishing, defining, managing, or modifying one or more attributes of the one or more designated application points among the identified qualified application points based on the connectivity template and the application context within the design of the network.

14. The method according to claim 1, wherein, Applying the connectivity template to one or more designated application points among the identified qualified application points includes: automatically determining the intent associated with the application of the connectivity template, and performing administrative or management functions automatically based on the determined intent.

15. The method of claim 1, further comprising detecting changes in the connectivity template and, in response, automatically updating the configuration of the one or more designated application points among the identified qualified application points based on the changes in the connectivity template.

16. The method according to claim 1, further comprising: Detect changes to an application point where the connectivity template has been applied, and in response, automatically update the configuration of that application point based on the detected changes and the connectivity template.

17. The method according to any one of claims 1 to 16, wherein, Applying the connectivity template includes enabling Border Gateway Protocol (BGP) peering sessions toward floating Internet Protocol (IP) addresses.

18. A system using connectivity templates, comprising: The processor is configured as follows: Receive the identifier of a connectivity template to be applied to a design of a computer network, wherein the connectivity template is configured to be applied to a set of one or more application point types; From a plurality of application points in the design of the network, a qualified application point is identified, wherein determining the qualified application point includes: in response to a match between the application point type of a first application point in the plurality of application points and at least one of a set of one or more application point types of the connectivity template, determining to include the first application point in the qualified application points; and in response to a mismatch between the application point type of a second application point in the plurality of application points and a set of one or more application point types of the connectivity template, determining not to include the second application point in the qualified application points. Receive a designation for one or more designated application points from the identified qualified application points to which the connectivity template is to be applied, wherein the identified qualified application points include at least one application point not included in the designated one or more designated application points; and The connectivity template is applied to one or more designated application points among the identified qualified application points to configure the computer network; and The memory is coupled to the processor and configured to provide instructions to the processor.

19. A computer-readable storage medium storing instructions for causing one or more programmable processors to perform the method according to any one of claims 1 to 17.

Citation Information

Patent Citations

  • Methods and apparatus for configuring interface units

    CN101438214A

  • Method and device for automatically deploying network configuration

    CN103269282A

  • Pattern based network configuration

    US20170104625A1