Identify the execution environment used to deploy network functions
By using domain-specific languages to express and compile serverless network functions, and optimizing their deployment locations by the network controller, the inefficiency of multi-functional operation on network device hardware is solved, achieving dynamic resource allocation and improved cost-effectiveness.
Patent Information
- Application Number
- CN202180064682.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2020-09-22
- Filing Date
- 2021-09-16
- Publication Date
- 2026-11-17
- Estimated Expiration
- 2041-09-16
AI Technical Summary
In existing technologies, network devices run multiple network functions directly on the hardware, resulting in low efficiency, high cost, and frequent hardware updates. Virtualized network functions in VMs and containers still suffer from resource waste and inefficiency.
Serverless network functions are expressed and compiled using a domain-specific language (DSL), and their deployment on network devices is optimized by a network controller, which dynamically allocates resources to execute network functions.
It enables flexible deployment of network functions and resource optimization, reduces the frequency of hardware updates, and improves the operating efficiency and cost-effectiveness of network equipment.
Smart Images

Figure CN116235477B_ABST
Abstract
Description
[0001] Related applications
[0002] This application claims priority to U.S. Patent Application No. 17 / 028,715, filed September 22, 2020, the entire contents of which are incorporated herein by reference.
[0003] Technology Domain
[0004] This disclosure generally relates to expressing and compiling serverless networking functions using domain-specific languages, and optimizing the deployment location of serverless networking functions on network devices. Background Technology
[0005] A computer network is typically a group of computers or other devices that communicate with each other and exchange data using one or more communication protocols, such as packet switching. For example, computer networking can refer to connected computing devices (such as laptops, desktops, servers, smartphones, and tablets) and an ever-expanding range of Internet of Things (IoT) devices (such as cameras, door locks, doorbells, refrigerators, audio / video systems, thermostats, and various sensors) that communicate with each other. Modern networks offer various types of network architectures, such as Local Area Networks (LANs) located in a single physical location, such as a building; Wide Area Networks (WANs) that extend over a larger geographical area to connect individual users or LANs; Enterprise Networks built for large organizations; Internet Service Provider (ISP) networks that operate WANs to provide connectivity to individual users or businesses; and so on.
[0006] These networks typically include specialized network devices for transmitting packets representing various types of data between devices, such as switches, routers, servers, and access points. Each of these devices is designed and configured to perform a different network function. For example, a switch acts as a controller, allowing devices in the network to communicate with each other. A router connects multiple networks together and also connects computers on these networks to the Internet by analyzing the data sent through the network and selecting the best path for data transmission, thus acting as a distributor in the network. Access points act like amplifiers for the network and are used to extend the bandwidth provided by the router so that the network can support many devices that are geographically distant from each other.
[0007] Computing networks have continued to become more complex, for example, with the introduction of Software-Defined Networking (SDN). In SDN, network management is centralized at the controller, abstracting the control plane from the data forwarding functions of discrete networking devices. The SDN controller is the core element of the SDN architecture and enables centralized management and control, automation, and policy enforcement across physical and virtual network environments. Various standards and protocols have been developed for SDN architectures, such as OpenFlow, Protocol-Independent Packet Processors (P4), Open Virtual Switch Database (OVSDB), Python, and others. These SDN protocols allow the SDN controller to interact directly with the forwarding plane of network devices, such as switches and routers, using various application programming interfaces (APIs).
[0008] Traditionally, SDN controllers use these SDN protocols to program network devices or push changes down to switch / router flow tables, allowing them to segment traffic, control flow for optimal performance, test new configurations and applications, and / or otherwise control or bootstrap data plane traffic. To perform these operations, network devices traditionally run different types of network functions (e.g., packet dropping, packet copying, packet forwarding, etc.) directly on the network device's hardware (e.g., bare metal implementation). However, running various types of network functions on the same network device can be inefficient, insecure, or otherwise disadvantageous. For example, the scale, diversity, and cost of the hardware required to effectively run these network functions increase significantly as network devices need to perform different types of network functions. Furthermore, as network requirements change, it may be necessary to update the software running in the network, which could necessitate replacing or updating the hardware in the network (e.g., replacing the entire network device or components within it).
[0009] Given the various inefficiencies and drawbacks of running network functions directly on the hardware of network devices, Network Function Virtualization (NFV) technology emerged to decouple network functions from the underlying hardware, creating virtualized networks that can run on commodity hardware, thus allowing for more flexible and cost-effective networks. NFV technology uses Virtual Network Functions (VNFs) that handle specific network functions, such as firewall functions, load balancing functions, packet routing functions, etc. Therefore, networks have shifted from using multiple pieces of hardware, each performing a single function, to having multiple virtual machines (VMs) within a single piece of hardware, where each VM performs the operation of one or more VNFs. Further, recent advancements include using containers for network function virtualization. That is, instead of simply using multiple VMs as hardware virtualization, containers act as operating system (OS) virtualization. Containers can share the same host OS as VMs but may be able to run separate VNFs in an isolated manner so that each VM can support multiple containerized VNFs. However, various inefficiencies and drawbacks still exist when running VNFs within VMs and containers. Attached Figure Description
[0010] The following is a detailed description in conjunction with the accompanying drawings. In the drawings, the leftmost number(s) of the reference numerals identify the drawing in which the reference numeral first appears. The same reference numerals are used in different drawings to denote similar or identical items. The systems depicted in the drawings are not drawn to scale, and the components in the drawings may be depicted as not being drawn to scale with each other.
[0011] Figure 1 This diagram illustrates the system architecture of an environment where users of user equipment utilize a domain-specific language to express and compile serverless network functions to perform network operations. Figure 1 The network controller in the network architecture is further illustrated, which deploys serverless networking functions in the optimal location within the network architecture (e.g., on the optimal network component or device).
[0012] Figure 2 A component diagram of an example user device is shown, which allows a user to express and compile serverless networking functions, at least in part, using a domain-specific language for expressing serverless networking functions.
[0013] Figure 3 A component diagram of an example network controller is shown, which receives serverless networking functionality and determines the optimal location for deploying serverless networking functionality within the network architecture.
[0014] Figure 4The flowchart illustrates an example method for a user to express serverless networking functionality for a user device, for a domain-specific language compiler to generate code for executing the serverless networking functionality, and for a network controller to deploy the code for the serverless networking functionality to one or more network devices in the network architecture.
[0015] Figure 5 The diagram shows a graphical user interface presented on a user device, through which the user can express serverless networking functions using text, graphical icons, and / or combinations thereof.
[0016] Figure 6 The flowchart illustrates an example method for users to express serverless networking functions using domain-specific and general languages for user devices, for compilers to generate code for executing serverless networking functions, and for network controllers to deploy the code for serverless networking functions to one or more network devices in the network architecture.
[0017] Figure 7A and Figure 7B Flowcharts are shown illustrating example methods for user devices to express serverless networking functions using domain-specific and general languages, for compilers to generate code for executing serverless networking functions, and for network controllers to deploy the code for serverless networking functions to one or more network devices in the network architecture. More specifically, Figure 7A It demonstrates the use of a domain-specific language and at least one of the Go or Rust programming languages to express serverless networking functionality, and Figure 7B This demonstrates how serverless networking functionality can be expressed using a domain-specific language and the Python programming language.
[0018] Figure 8 The graphical user interface presented on the user's device is shown, through which the user can express serverless networking functions using a combination of domain-specific and general languages.
[0019] Figure 9 This diagram illustrates a system architecture of an environment in which the network controller in the network architecture is deployed with serverless network functionality in the optimal location within the network architecture (e.g., on the optimal network component or device).
[0020] Figure 10 A flowchart is shown illustrating an example method for expressing serverless networking functions using a domain-specific language and generating code for executing those functions.
[0021] Figure 11 A flowchart is shown illustrating an example method for expressing serverless networking functions using domain-specific and general languages and generating code for executing those functions.
[0022] Figure 12 A flowchart is shown as an example method for deploying serverless networking functionality to a network component where the serverless networking functionality is optimized for execution.
[0023] Figure 13 This is a computer architecture diagram, illustrating an example computer architecture capable of executing program components that can be used to implement various aspects of the various technologies presented in this article. Detailed Implementation
[0024] Overview
[0025] Various aspects of the invention are set forth in the independent claims, and preferred features are set forth in the dependent claims. A feature of one aspect may be applied to any aspect alone or in combination with other aspects.
[0026] This disclosure generally relates to expressing and compiling serverless networking functions using domain-specific languages, and optimizing the deployment location of serverless networking functions on network devices.
[0027] The first approach described herein involves generating serverless network functions using a domain-specific language (DSL). This may include receiving first code expressed in DSL, which defines the serverless network functions to be executed by a network device. Typically, a DSL is a programming language that can be used to define multiple serverless network functions. Some types of network functions may include packet acquisition, packet generation, packet copying, packet modification, packet dropping, packet forwarding, etc., configured to be selectively executed on a network device. The first approach may also include generating second code by a DSL compiler, at least partially using the first code. This second code includes machine-executable instructions that can be executed by the network device to perform the serverless network functions. The second code may include code expressed in at least one of the following: an OpenFlow programming language program, a P4 programming language program, a Linux Extended Berkeley Packet Filter (eBPF) program, a program configured to execute on a Smart Network Interface Controller (NIC), a hardware description language associated with at least one of a Field-Programmable Gate Array (FPGA) or an Application-Specific Integrated Circuit (ASIC), or a Vector Packet Processor (VPP) program.
[0028] The second approach described herein involves using a domain-specific language (DSL) and a generalized language (GPL) to generate serverless networking functions. This second approach may include receiving first source code expressed in a DSL, which defines a first portion of the serverless networking function to be executed by a network device. Typically, a DSL can be used to define multiple serverless networking functions. The second approach may also include receiving second source code expressed in a GPL, which defines a second portion of the serverless networking function. In some cases, the GPL may include at least one of the Go, Rust, or Python programming languages. The second approach may further include generating the first and second source codes, at least partially using a compiler, with the object code comprising machine-executable instructions that can be executed by a network device to perform the serverless networking function.
[0029] The third method described herein involves identifying a network component from among multiple network components in the network, on which network functions will be deployed. This third method may include receiving code representing a network function by a network controller. Furthermore, the third method may include determining characteristics associated with the execution of the network function by the controller. Additionally, the third method may include selecting a network component from among multiple network components in the network that is optimized to perform the network function at least in part based on these characteristics. Further still, the third method may include deploying the code representing the network function to the network component by the controller.
[0030] Furthermore, the techniques of at least the first, second, and third methods, as well as any other techniques described herein, can be executed by a system and / or device having a non-transitory computer-readable medium storing computer-executable instructions that, when executed by one or more processors, perform the above-described (one or more) methods.
[0031] Example Implementation
[0032] Computer networks have evolved and become increasingly complex in terms of how they control or instruct network devices to transmit data through the network architecture. For example, SDN technology has emerged and developed, and often includes the use of controllers to extract the control plane from the data forwarding functions of discrete networked devices. The controller manages and controls various control plane functions, such as providing Layer 2 reachability information and Layer 3 routing information to network devices that need this information to make packet processing decisions. Network devices and components process data plane functions based on the control plane information received from the controller, such as forwarding or routing decisions, packet dropping operations, etc.
[0033] As mentioned above, network devices traditionally execute or run different types of network functions directly on the network device's hardware (e.g., bare metal implementation). However, due to the inefficiency of running network functions directly on the hardware, various NFV technologies have emerged to decouple network functions from the underlying hardware, creating virtualized networks that can run on commodity hardware, thus allowing for greater network flexibility and cost-effectiveness. Using these NFV technologies, network devices now execute VNFs, which handle specific network functions such as firewall functions, load balancing functions, packet routing functions, etc. Therefore, the network has shifted from using multiple hardware components, each performing a single function, to allowing VMs and / or containers to run within a single piece of hardware, where each virtual resource performs the operations of one or more VNFs. However, various inefficiencies and drawbacks still exist when running VNFs in VMs and containers. For example, containers and VMs are often long-running mechanisms that may be constantly started and consume compute power. Furthermore, starting containers and VMs each time a VNF is needed or requested can consume resources and time.
[0034] This disclosure describes techniques and mechanisms for expressing and compiling serverless networking functions using a domain-specific language (DSL) and optimizing the deployment location of serverless networking functions on network devices. In some examples, serverless networking functions may be expressed entirely in a DSL (e.g., via a text-based editor, a graphics-based editor, etc.), where a DSL is a computer language specifically designed for a particular domain (e.g., a network function domain). In additional examples, a DSL combined with a generalized language (GSL) may be used to express and compile serverless networking functions. Once the serverless networking function is expressed and / or compiled, the techniques of this disclosure also include determining the optimized network components on which the serverless networking function will execute, and deploying the serverless networking function to the optimized network components.
[0035] Typically, a domain-specific language, or DSL, is a computer language designed specifically for a particular domain. This disclosure describes a DSL specifically designed to express network functions that will be performed by network devices (e.g., routers, switches, etc.). The DSL can then be compiled into code representing serverless network functions that can be executed by network devices to perform various actions, such as packet acquisition, packet generation, packet copying, packet dropping, packet forwarding, etc. Similar to how Hypertext Markup Language (HTML) is a DSL used for creating web pages, the DSL described herein may be specific to or specifically designed to express network functions, more specifically, serverless network functions.
[0036] As described in this article, serverless functions are typically programmatic functions that are dynamically executed (e.g., in response to predefined events) within a piece of code. Therefore, the resources required to execute a serverless function are similarly dynamically allocated, or allocated at runtime, in contrast to the computational resources required to support long-running VMs or containers. Thus, serverless network functions can include network functions (e.g., packet dropping, packet forwarding, etc.) that are dynamically executed in response to specific events (e.g., a network device receiving one or more packets in a stream). Serverless network functions can be used to execute a variety of network functions and deployed to different network devices based on the functions these devices execute within the network architecture.
[0037] Therefore, users of a user equipment can use a DSL to express serverless network functions. A DSL is a dedicated or domain-specific programming language that can be used to express network functions. A DSL can include a formal programming language that comprises a set of instructions that produce the desired results through serverless network functions. For example, a DSL can be a programming language written in command form (e.g., a sequence of operations to be performed), declarative form (e.g., specifying the desired result), and / or another form. Typically, a DSL can be a programming language with syntax (or form) and semantics (or meaning) and can be defined by a standard or specification (e.g., the C programming language is specified by the ISO standard). Furthermore, a DSL can have various built-in libraries, functions, APIs, etc.
[0038] In some examples, a user on a user device can run an editor on their user device to receive input that at least partially expresses serverless networking functionality using a DSL. The input can be text-based, graphical, and / or a combination thereof. For example, text can be input into an editor representing a portion of the serverless networking functionality in the DSL, graphical icons can be placed into an editor representing at least a portion of the serverless networking functionality in the DSL, and / or combinations thereof. Once the user has expressed the serverless networking functionality using the DSL, the user can run a compiler, which can be a DSL-specific compiler, transpile, etc., to compile into or generate object code for the serverless networking functionality.
[0039] In some examples, the techniques described herein may include using a combination of a DSL and a general-purpose language (GPL) to express and create serverless networking functions. For instance, by understanding the nature of DSLs and GPLs, the techniques described herein include compiling source code written using a combination of DSLs and GPLs into executable code (e.g., object code or other machine code) to perform one or more serverless networking functions. The GPL may include any type of GPL that can be used to define networking functions, such as the Go programming language (often referred to as "Golang"), the Rust programming language, the Python programming language, the P4 programming language, the OVSDB programming language, and / or any other language that can be used to define networking functions.
[0040] In some cases, DSLs and GPLs can be integrated, allowing different languages to represent different components or parts of one or more serverless networking functions. For example, the DSL and GSL parts of one or more serverless networking functions can be integrated using built-in connections. As an example, a component can be expressed using a DSL, another component can be expressed using a GPL (e.g., Rust or Golang), and the DSL and GPL can interface or interact using channels (e.g., asynchronous channels). That is, Rust channels and Golang channels can be used as pipes to connect concurrently running components (e.g., DSL-based components and GPL-based components). In another example where the GPL is Python, DSL-based and GPL-based components can be connected using an asyncio library (e.g., a collection of high-level APIs, low-level APIs, etc.) for connecting asynchronous components.
[0041] In some cases, DSP and GPL can be integrated with other technologies. For example, a DSL can be designed to allow GPL code to be embedded within DSL code and compiled (or transpiled) into a combined code segment. Alternatively, a DSL can be configured to allow DSL code to be embedded within GPL code and compiled (or transpiled) into a combined code segment. The compiler can be configured to ensure that the resulting code is a combination of the following: functionality expressed in DSL and functionality expressed in GPL, and cross-linking between parts of the resulting code expressed in different languages. By combining DSL and GPL, users gain the benefit of being able to concisely express serverless networking functionality using DSL, and also the benefit of being able to express a portion of serverless networking functionality using GPL, which users may be familiar with. The compiler can be configured to identify which parts of the code are written in DSL or GPL (e.g., identify semantics, identify syntax, etc.) and ensure that these parts of the code are properly compiled into the desired output code segment.
[0042] Once a user has completed expressing the serverless networking functionality using the DSL itself or in conjunction with the GPL through an editor, the user can instruct the compiler to compile the code into the desired object code. The object code representing the serverless networking functionality can then be sent to a network controller, which manages the network architecture on which the serverless networking functionality will be deployed. The network controller can be configured to determine the network components on which the serverless networking functionality should be deployed. The network controller can determine an optimized layout for executing the serverless functionality, or determine the network components in the network architecture on which the serverless networking functionality will run.
[0043] A network controller manages the network architecture and maintains data about its state and layout. The controller can use this information and data to determine the locations or network components / devices on which to deploy serverless networking functions. In other words, the controller can determine network components with the most suitable characteristics for performing serverless networking functions based on their type or features.
[0044] As an example, a controller can maintain a model or other representation of the layout or architecture of the network it manages. This can include the location of network components within the network (e.g., near the network edge, near application servers, etc.) and / or the functionality of different network devices within the network (e.g., firewall components, routing components, etc.). The controller can determine where to deploy serverless networking functions based on the location and / or functionality of network components. For example, the controller can determine that the serverless networking function is a firewall function or a packet dropping function. In such an example, the controller can determine that performing the packet dropping serverless networking function on network components at or near the edge of the network architecture would be more optimized. This way, dropped packets do not need to flow through network devices and thus consume resources, but can be dropped at the network edge.
[0045] As another example, the controller may collect and / or analyze telemetry data indicating the availability of one or more computing resources (e.g., computing resources, storage resources, network resources, memory resources, etc.) of network components within the network. In such an example, the controller may determine to deploy serverless networking functions to network components with excess resource capacity or at least sufficient resource availability to host the serverless networking functions. In some cases, the controller may determine the optimal network component on which to deploy the serverless networking functions based on the primary resource type consumed by the serverless networking functions and the availability of resources on the network components. For example, a serverless networking function maintaining routing tables may be deployed to a network component with excess memory, while a serverless networking function performing packet processing may be deployed to a network component with excess computing resources.
[0046] As a further example, the controller can monitor or otherwise determine the software locality of various software functions, such as applications hosted in a Software as a Service (SaaS) environment. In such an example, the controller can further determine that a serverless networking function is configured to be attached to a specific SaaS computing function and perform serverless networking functions specific to that SaaS computing function. In such an example, the controller can determine to deploy the serverless networking function on the same host as or adjacent to the SaaS computing function to work seamlessly with the SaaS computing function.
[0047] While these are merely illustrative examples, other criteria or characteristics (discussed further below) may be considered when determining the best or optimized network components on which serverless networking functionality should be deployed and run. Although the techniques used to determine optimized network components are primarily described in relation to serverless networking functionality, these techniques are generally applicable to any type of network behavior element. That is, the techniques used to optimize the placement of serverless networking functionality are generally applicable to any piece of software code that is a piece of network behavior tailored to run in a convenient runtime environment (hardware or software) on components within the network.
[0048] As described herein, network components can include any type of component capable of hosting or running serverless networking functionality, whether hardware-based, software-based, etc. For example, network components can include hardware-based devices such as routers, network switches (e.g., leaf switches, backbone switches, etc.), gateways, network interface cards (NICs), smart NICs, servers, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), and / or any other hardware device capable of performing serverless networking functionality. Network components can also include software-based components such as virtual machines, containers, etc.
[0049] Certain embodiments and implementations of this disclosure will now be described more fully below with reference to the accompanying drawings, in which various aspects are illustrated. However, these aspects may be implemented in many different forms and should not be construed as limited to the implementations set forth herein. As described herein, this disclosure includes variations of the embodiments. The same numerals always refer to the same elements.
[0050] Figure 1 A system architecture diagram of environment 100 is shown, which includes a network architecture 102 that may include one or more data centers 104, and wherein a user 108 of user equipment 106 uses a domain-specific language to express and compile serverless network functions to perform network operations. Figure 1The diagram further illustrates the deployment of serverless networking functionality by the network controller 118 in network architecture 102 at its optimal location within network architecture 102 (e.g., on the optimal network component or device).
[0051] In some examples, network architecture 102 may include devices housed or located in one or more data centers 104. Network architecture 102 may include one or more networks implemented using any feasible communication technology, such as wired and / or wireless modes and / or technologies. Network architecture 102 may include any combination of: Personal Area Network (PAN), Local Area Network (LAN), Campus Area Network (CAN), Metropolitan Area Network (MAN), Extranet, Intranet, Internet, Short-range wireless communication networks (e.g., ZigBee, Bluetooth, etc.), Wide Area Network (WAN)—centralized and / or distributed—and / or any combination, arrangement, and / or aggregation thereof. Network architecture 102 may include devices, virtual resources, or other nodes in a computer network that relay packets from one network segment to another. Network architecture 102 may include multiple devices that utilize the network layer (and / or session layer, transport layer, etc.) in the OSI model for packet forwarding, and / or utilize other layers. Network architecture 102 may include various hardware devices such as routers, switches, gateways, smart NICs, NICs, ASICs, FPGAs, servers, and / or any other type of device. In addition, network architecture 102 may include virtual resources, such as VMs, containers and / or other virtual resources.
[0052] One or more data centers 104 may be physical facilities or buildings located in a geographic area designated to store networked devices as part of network architecture 102. Data center 104 may include a variety of network devices, as well as redundant or backup components and infrastructure for power, data communication connectivity, environmental control, and various security devices. In some examples, data center 104 may include one or more virtual data centers, which are pools or collections of cloud infrastructure resources specifically designed for enterprise needs and / or specifically for cloud-based service provider needs. Typically, data center 104 (physical and / or virtual) can provide basic resources such as processors (CPU), memory (RAM), storage devices (disks), and network (bandwidth). However, in some examples, devices in packet forwarding network 102 may not be located in the explicitly defined data center 104, but may be located in other locations or buildings.
[0053] User equipment 106 can establish communication connections through one or more networks 116 to communicate with devices in network architecture 102, such as network controller 118 of network architecture 102. Network 116 may include any feasible communication technology, such as wired and / or wireless modes and / or technologies. Network 116 may include any combination of the following: Personal Area Network (PAN), Local Area Network (LAN), Campus Area Network (CAN), Metropolitan Area Network (MAN), Extranet, Intranet, Internet, Short-range wireless communication network (e.g., ZigBee, Bluetooth, etc.), Wide Area Network (WAN)—centralized and / or distributed—and / or any combination, arrangement, and / or aggregation thereof. User equipment 106 can communicate on network 116 using any type of protocol, such as Transmission Control Protocol / Internet Protocol (TCP / IP) used to manage connections to and through the Internet.
[0054] As shown in the figure, user device 106 can run editor 110, which is presented in DSL interface 112 and configured to receive input using DSL to express and create serverless network functions. As shown, editor 110 can receive a portion of source code at "1", which is simply shown as pseudocode representing an example packet routing serverless network function expressed by user 108. User 108 can express the serverless network function using text input, graphical icons, and / or combinations thereof. In some cases, all source code representing the serverless network function can be expressed using DSL, and in other examples, the first part of the source code can be expressed using DSL, and the second part of the source code can be expressed using GPL (e.g., Golang, Rust, Python, P4, etc.).
[0055] As "2", the compiler running on user equipment 106 can compile the definition or expression of serverless network functionality into object code. The compiler running on user equipment 106 can include any compiler type, such as a DSL-specific compiler, a transpiler / translator configured to compile DSL-based input and GPL-based input into serverless network functionality, and / or any other type of compiler. The compiler can be configured to compile serverless network definitions from DSL-based expressions (e.g., source code) into object code in various programming languages. For example, source code can be compiled into object code in various languages, such as OpenFlow programming language programs, P4 programming language programs, Linux Extended Berkeley Packet Filter (eBPF) programs, programs configured to execute on a Smart Network Interface Controller (NIC), and hardware description languages associated with at least one of Field Programmable Gate Array (FPGA), Application-Specific Integrated Circuit (ASIC), or Vector Packet Processor (VPP) programs.
[0056] In section “3”, user equipment 106 may provide SNF code 114 to network controller 118. For example, user 108 of user equipment 106 may provide SNF code 114 to network controller 118 via network 116, as well as via a network-accessible portal, via an API, via an interface (e.g., CLI), and / or via any other mechanism. Although the expression of the serverless networking function can be compiled from source code to object code locally on user equipment 106, in some cases, the source code may be sent to network controller 118 as SNF code 114. Therefore, SNF code 114 can be in any programming language, compiled or pre-compiled, and typically corresponds to the serverless networking function.
[0057] In section "4", network controller 118 can determine the optimal location for deploying and instantiating serverless networking functions. (See also: Regarding...) Figure 9 In more detail, network controller 118 can determine the optimal location for deploying serverless networking functionality based on various criteria or characteristics, such as computing resource capacity, the administrative complexity of controller 118, the cost of running serverless networking functionality on a particular network component, security concerns, application location (e.g., attaching serverless networking functionality to a specific SaaS computing function), the type of serverless networking functionality (e.g., the action performed), the type of target code of SNF code 114, and so on.
[0058] Typically, network architecture 102 may include various network devices and components, such as router 120, backbone switch 122, leaf switch 124, server 126, and / or other network components. Although not shown, network architecture may additionally or alternatively include gateways, NICs and smartNICs, FPGAs, ASICs, virtual machines, containers, and / or any other type of hardware-based or software-based network components.
[0059] In section 5, network controller 118 may instantiate and / or deploy one or more serverless network functions on network components in network architecture 102. In some cases, instantiating a serverless network function may include using a secure connection, such as a Secure Sockets Layer (SSL) connection, to securely load SNF code 114 onto the network component.
[0060] In section "6", serverless network functions can perform network actions to be performed as programmed. Typically, serverless network functions can be event-driven, such as events that invoke a specific API, which calls the appropriate serverless network function. As an example, router 120 can receive packets using the Packet Acquisition SNF, and an event can be triggered based on the Packet Acquisition SNF used to receive the packet (e.g., an API call). For example, this event could trigger a Packet Drop SNF, which determines whether to drop the packet based on various criteria, such as the packet's source address. Furthermore, packet forwarding functions can be invoked to determine the link to which the packet should be forwarded based on information in the packet header. Therefore, one or more SNFs can be invoked to analyze the packet and determine how to handle it at network components.
[0061] In this way, serverless networking functions can be dynamically executed to perform network functions that are traditionally executed using VNFs as long-running VMs or containers. However, the techniques described in this paper include the use of a DSL that enables the programmatic expression of networking functions, allowing these functions to be compiled and deployed using serverless methods and consistent with existing serverless computing capabilities.
[0062] Figure 2 Component Figure 200 illustrates an example user equipment (e.g., user equipment 106) through which a user can at least partially express and compile serverless network functions using a domain-specific language for expressing serverless network functions. User equipment 106 can be any type of computing device capable of receiving the expression of serverless network functions via DSL interface 112 and transmitting SNF code 114 to network 116 via a suitable data communication network, such as, but not limited to, laptop or desktop computers, tablet computing devices, server computers, televisions, or mobile phones.
[0063] As shown in the figure, user equipment 106 may include one or more hardware processors 202 (processors), one or more devices, and be configured to execute one or more stored instructions. Processor 202 may include one or more cores. Furthermore, user equipment 106 may include one or more network interfaces 204 configured to provide communication between user equipment 106 and other devices (e.g., network controller 118, and / or other systems or devices in and / or remote from network architecture 102). Network interface 204 may include devices configured to couple to personal area networks (PANs), wired and wireless local area networks (LANs), wired and wireless wide area networks (WANs), etc. For example, network interface 204 may include devices compatible with Ethernet, Wi-Fi, etc.
[0064] User equipment 206 may include one or more power sources 206, such as one or more batteries, a connection to a mains power source, etc. User equipment 106 may also include one or more inputs and outputs 208 for receiving and processing input from multiple input devices, such as a keyboard, mouse, touchpad, touchscreen, stylus, or other types of input devices. Furthermore, inputs / outputs 208 may include displays, such as computer monitors, flat panel displays, digital projectors, printers, or other types of output devices. It should be understood that user equipment 106 may not include... Figure 2 All components shown may include those not listed. Figure 2 Other components explicitly shown in the document, or those that can be used in a completely different manner. Figure 2 The architecture shown.
[0065] User equipment 106 may also include memory 210, such as a computer-readable medium, for storing various executable components (e.g., software-based components, firmware-based components, etc.). Memory 210 may typically store components to implement the functions described herein. Memory 210 may store an operating system 212 for controlling the operation of the components of user equipment 106. Furthermore, memory 210 may store a communication component 214, which includes software (e.g., any protocol stack) enabling user equipment 106 to communicate with other devices using network interface 204. Further still, memory 210 may store one or more applications 216, which may typically include any type of software application to perform various functions.
[0066] In some cases, memory 210 may store user interface component 218 configured to present a user interface, such as DSL interface 112, on the display of user equipment 106, through which editor 110 receives expressions of serverless network functions written in DSL. User equipment 106 may further store code editor 220 (e.g., editor 110) including text-based editor 222 and graphics-based editor 224. (As at least regarding...) Figure 5 In more detail, the text-based editor 222 can be configured to receive text input expressing serverless network functionality according to a DSL, and the graphics-based editor 224 can be configured to receive graphical icons representing at least a portion of the serverless network functionality according to a DSL. In this way, the code editor 220 can receive expressions using serverless network functionality according to a DSL via text-based input, graphics-based input, and / or a combination thereof.
[0067] Memory 210 may also store one or more DSL compilers 226, as well as DSL and GPL compilers. DSL compiler 226 may typically include any type of compiler configured to take source code, input code, human-readable code, etc., analyze that code, and generate or produce computer-readable code (e.g., binary code, machine code, object code, bytecode, etc.). In some cases, DSL compiler 226 may not directly enter machine code, but instead enter assembly or a different human-readable language. Compilers may include any type of compiler, including source-to-source compilers (or transpilers). For example, in an example using a combination of DSL and GPL to express serverless network functionality, DSL compiler 226 may convert the DSL source code into GPL source code, such that all source code is in GPL form before being finally compiled into object code (or machine code). Similarly, DSL compiler 226 may convert GPL code into DSL source code before compiling all code expressed in the DSL into object code (e.g., machine code).
[0068] In some cases, the DSL compiler 226 can be configured to accept graphical icons as input representing parts of serverless networking functionality. The graphical icons can represent text in DSL form and be converted to DSL text before compilation. In other examples, the DSL compiler 226 can be configured to compile the graphical icons directly into machine code. The DSL compiler 226 can be similar to React (a networking framework) because it includes a pre-compiler built into the DSL embedded in the GPL (if found not to be GPL (e.g., different syntax or semantics)) that is transpiled to the GPL, so that all source code is ultimately pre-compiled to the GPL. The GPL can then be compiled into any desired backend target code or object code. However, in other examples, the DSL compiler 226 may include a pre-compiler that finds GPL code embedded in the DSL code and pre-compiles the GPL code into DSL code, so that all source code is expressed in DSL before being compiled into the desired target code or object code. In some cases, the DSL compiler 226 may include a transpiler, as shown in the React example, where the DSL and GPL can be compiled into a version that can be compiled using the compiler's primary language (e.g., DSL, GPL, etc.) if needed. Therefore, the DSL compiler 226 may include one or more compilers, enabling users to express serverless network functionality using the code editor 220 alone or in conjunction with the GPL.
[0069] The DSL compiler 226 is typically capable of compiling computer code in any computer language that can be executed on multiple different types of network components. For example, the DSL compiler 226 can compile OpenFlow programming language programs, P4 programming language programs, Linux Extended Berkeley Packet Filter (eBPF) programs, programs configured to execute on a Smart Network Interface Controller (NIC), a Hardware Description Language associated with at least one of a Field Programmable Gate Array (FPGA) or Application-Specific Integrated Circuit (ASIC), or Vector Packet Processor (VPP) programs, any type of machine code, object code, bytecode, machine code, binary code, and / or any type of executable code that can be executed by any type of device or network component. Therefore, the DSL compiler 226 can be configured to compile source code, at least partially written in DSL, into any type of object or output code that expresses or represents serverless network functionality.
[0070] User equipment 106 may also include a data storage device 228, which may include any type of computer memory, including long-term memory (e.g., read-only memory (ROM), random access memory (RAM), cache, etc.). Data storage device 228 may include a DSL library 230 containing resources for expressing serverless networking functions using DSL, such as macros, type definitions, and functions for tasks such as string manipulation, mathematical calculations, input / output processing, memory management, and various other system services. Similarly, data storage device GPL library 232 may include any type of library for any type of GPL language. Data storage device 228 may include source code already expressed by the user of user equipment 106 and / or downloaded from a code repository, representing serverless networking functions and / or other programs. Furthermore, in the example where source code 234 is compiled locally on user equipment 106 by DSL compiler 226, data storage device 228 may include SNF object code 236.
[0071] Figure 3 A component diagram 300 illustrates an example network controller (e.g., network controller 118) that receives serverless networking functionality and determines the optimal location within network architecture 102 to deploy the serverless networking functionality. In some cases, network controller 118 may run on one or more computing devices (e.g., a single device or device system) in or associated with network architecture 102. Network controller 118 may include a single running controller 118, or multiple instances of network controller 118 running at least partially concurrently.
[0072] Typically, network controller 118 may be a programmable controller that manages some or all of the control plane activities of network architecture 102 and uses one or more centralized control models to manage or monitor network status. Typically, network controller 118 may perform at least the following functions: (i) receiving SNF code 114 (source code, object code, etc.) for serverless network functions, (ii) identifying network components in network architecture 102 optimized to host or manage serverless network functions, and (iii) deploying or instantiating SNF code 114 on network components optimized to run serverless network functions.
[0073] As shown in the figure, network controller 118 may include one or more hardware processors 302 (processors), one or more devices, or running on one or more hardware processors 302 (processors), one or more devices, which are configured to execute one or more stored instructions. Processor 302 may include one or more cores. Furthermore, network controller 118 may include or be associated with (e.g., communicatively coupled to) one or more network interfaces 304, which are configured to provide communication with user equipment 106 and other devices, and / or other systems or devices in and / or remote from network architecture 102. Network interface 304 may include devices configured to couple to personal area networks (PANs), wired and wireless local area networks (LANs), wired and wireless wide area networks (WANs), etc. For example, network interface 304 may include devices compatible with any network protocol.
[0074] Network controller 118 may also include memory 306, such as a computer-readable medium, for storing various executable components (e.g., software-based components, firmware-based components, etc.). Memory 306 may typically store components to implement the functions described herein and performed by network controller 118. Memory 306 may store one or more network service functions 308, such as a slice manager, a topology manager for managing the topology of network architecture 102, a host tracker for tracking which network components are hosting which programs or software, a switch manager for managing the switches of network architecture 102, a process manager, and / or any other types of functions performed by network controller 118.
[0075] Network controller 118 may also include network orchestration functions 310 stored in memory 206, which perform various network functions such as resource management, creating and managing network overlays, programmable APIs, providing or deploying applications, software or code to hosts, and / or performing any other orchestration functions. Furthermore, memory 306 may store one or more service management functions 312 configured to manage specific services of network architecture 102 (configurable), and one or more APIs 314 for communicating with devices in network architecture 102 and causing various control plane functions to occur. In some cases, network controller 118 may include multiple compilers, such as DLS compiler 226, and use DSL compiler 226 to compile source code into object code before deploying code to network components. However, this occurs when user equipment 106 does not compile source code 234 into the final SFN object code 236.
[0076] Additionally, network controller 118 may include SNF placement component 316, which is configured to determine optimized (or advantageous) network components on which serverless networking functions run, and to deploy / instantiate serverless networking functions on those network components. Figure 9 As described in more detail, the SNF placement component 316 can determine the optimal network component on which to deploy and instantiate the serverless networking function based on various criteria or characteristics (e.g., computing resource capacity, management difficulty of controller 118, cost of running serverless networking functions on a particular network component, security concerns, application location (e.g., attaching serverless networking functions to a particular SaaS computing function), type of serverless networking function (e.g., the action performed), target code type of SNF code 114, etc.).
[0077] Network controller 118 may also include data storage device 318, such as long-term storage, which stores communication libraries 320 for different communication protocols configured to be used or executed by network controller 118. Furthermore, data storage device 318 may include network topology data 322, such as a model representing the layout of network components in network architecture 102. Data storage device 318 may store telemetry data 324, which indicates the usage and / or availability of computing resources on different network components in network architecture 102. Additionally, data storage device 318 may store SNF target code 326 (which can be received and / or generated) that will be deployed and / or has already been deployed on network components.
[0078] Figure 4A flowchart illustrates an example method 400 for user-expressed serverless networking functionality for user equipment 106, for domain-specific language compiler 226 to generate code for executing serverless networking functionality, and for network controller 118 to deploy the code for serverless networking functionality to one or more network devices or components in network architecture 102.
[0079] At 402, user 108 can define serverless network functions using a DSL. For example, user 108 can interact with code editor 220 to input text-based input, graphical input, and / or combinations thereof. Code editor 220 can receive input from user 108 that at least partially expresses or defines serverless network functions in DSL.
[0080] In 404, it indicates that the code for serverless network functionality can be compiled by the DSL compiler 226. The DSL compiler 226 can compile the source code into any desired object code (or target code). In some cases, the DSL compiler 226 can compile the source code into object code that is configured to be executed by the target network component (e.g., the object code can be selected based on the type of code the network component can execute). In 406, the DSL compiler 226 can generate code for the SNF. For example, the DSL compiler 226 can generate object code based on the type of the destination network device.
[0081] At 408, the target code for the serverless networking functionality is sent for runtime. More specifically, user equipment 106 can send the target code to network controller 118. The task of network controller 118 is then to determine the network device on which the serverless networking functionality will be deployed.
[0082] At 410, network controller 118 determines on which network device 414 (or network component 414) the code for the serverless network function is deployed. Various characteristics or standards may be considered regarding the serverless network function and network device 414 to identify the optimal network device 414 on which the code representing the serverless network function is deployed. Network controller 118 can then deploy the code for the serverless network function to the network device 414 that has been determined to be optimized for running the serverless network function.
[0083] At 412, the code for serverless network functions can be executed by network components and / or network devices 414. For example, an event may have occurred that triggers the execution of serverless network functions and dynamically performs network actions (e.g., receiving a packet at network device 414 on which actions are required).
[0084] Figure 5An example environment 500 is shown, in which a graphical user interface (GUI) 502 is presented on a user device 106, through which a user 108 can express serverless networking functions using text, graphical icons, and / or combinations thereof.
[0085] As shown in the figure, GUI 502 may present or include DSL interface 110, through which user 108 of user equipment 106 can at least partially use DSL to express serverless networking functionality via editor 220. As described above, editor 220 may include a text-based editor 222 and / or a graphics-based editor 224. As shown in the figure, DSL interface 110 may include graphics library 504, which includes one or more visual graphics or icons that can be used to express at least a portion of the serverless networking functionality. The graphics shown in the graphics library can be used to express serverless networking functionality in DSL, enabling the graphics to be analyzed and compiled by DSL compiler 226 and used to generate SNF object code 236.
[0086] Therefore, a DSL can be at least partially a visual programming language when serverless network functionality can be defined at least in part using visual graphics or icons. As shown in the figure, the graphics library 504 can contain graphics representing different network operations, actions, and / or functions, such as generating packet graphics, discarding packet graphics, copying packet graphics, forwarding packet graphics, and so on. However, graphic icons can be used to represent any type of function or action, and these are merely illustrative examples. For example, graphics representing more fine-grained portions of the source code that can be used (e.g., code functions, code variables, etc.) can exist.
[0087] As further shown, the DSL interface 110 may include a portion for receiving text to express serverless network functionality in the DSL. The text portion 506 shown is merely an example using pseudocode, and the DSL may be a specialized programming language used to express and create serverless network functionality for the purpose of performing network functions. The DSL may include a formal programming language comprising a set of instructions that produce the desired result. For example, the DSL may be a programming language written in command form (e.g., a sequence of operations to be performed), declarative form (e.g., specifying the desired result), and / or another form. Typically, the DSL may be a programming language with syntax (or form) and semantics (or meaning), and may be defined by a standard or specification (e.g., the C programming language is specified by the ISO standard). Furthermore, the DSL may have various built-in libraries, functions, APIs, etc.
[0088] As shown in the figure, user 108 of user equipment 106 can input text portion 506 and graphics portion 508 to express serverless network functionality in a DSL. In some cases, graphics portion 508 can switch back and forth between an icon and the text corresponding to that icon. In this way, user 108 can utilize graphics / icons from library 504 and quickly switch to text to complete code snippets. Therefore, editor 220 can allow user 108 to express serverless network functionality in a DSL that supports text-based input, graphics / icon-based input, and / or combinations thereof. In the example shown, text input 506 can indicate functionality for packet routing, routing packets along a specific path if a packet is recognized, otherwise discarding the packet, as indicated by graphics 508 used in the else statement. Again, this is merely an illustrative example, and a DSL can be expressed or defined by any semantics or syntax.
[0089] OpenFlow is an example of a control plane protocol used by network controllers. The following is an illustrative example explaining the use of a DSL language mapped to an OpenFlow action set. However, similar patterns emerge when using languages such as P4 and eBPF.
[0090] • Packet Acquisition: Packet acquisition can be accomplished by creating a port on the OpenFlow switch, allowing specific service patterns to reach that port. The equivalent OpenFlow action is OFPT_PACKET_IN.
[0091] • Packet generation: Packet generation can involve using an OpenFlow port on a switch to allow the DSL to generate packets that are sent from that port. The equivalent OpenFlow action is OFPT_PACKET_OUT.
[0092] • Packet copying: Packet copying can be accomplished by allowing OFPT_PACKET_IN to receive packets, and then the DSL itself will generate code to copy the packet.
[0093] • Packet Modification: Packet modification can involve using a DSL to allow OFPT_PACKET_IN to receive packets, and then allowing packet modification via some generated code. This can also be done on a per-stream basis using OFPT_FLOW_MOD.
[0094] • Packet drop: Packet drop may involve using the DSL to set OFPT_TABLE_MOD so that drop can be set for the packet type specified by the user via the DSL.
[0095] • Forwarding packets along a specific link: Packet forwarding can involve using OFPT_TABLE_MOD to allow specific packet types to be sent somewhere.
[0096] Figure 6 A flowchart of an example method 600 is shown, illustrating how user 108 of user equipment 106 expresses serverless networking functions using domain-specific and general languages, how a compiler generates code for executing serverless networking functions, and how a network controller deploys the code for serverless networking functions to one or more network devices in the network architecture.
[0097] In section 602, user 108 can use DSL and GPL to define serverless network functions. The GPL can include any type of GPL that can be used to define network functions, such as the Go programming language, Rust programming language, Python programming language, P4 programming language, OVSDB programming language, and / or any other language that can be used to define network functions.
[0098] At 604, code editor 220 can initiate one or more GPL processes 604 based on the GPL used in conjunction with the DSL. For example, if user 108 is writing their code in Go, code editor 220 will use channels to integrate between hardware and software at 604A. Furthermore, if user 108 is writing their code in Python, code editor 220 will use asyncio to integrate between hardware and software at 604B. Additionally, if user 108 is writing their code in Rust, code editor 220 will use Rust channels to integrate between hardware and software at 604C. As another example, if user 108 is writing their code in PHP, editor 220 will use a standard PHP model to map their code.
[0099] Because the editor 220 and compiler 226 are configured to understand the nature of the DSL and GPL, they can use this knowledge to find the most efficient way to make components interact, which is specific to the nature of the network code and its implementation, as well as the characteristics of the GPL in use. The low-level connectivity can be further refined by adding a presentation layer to the GPL (e.g., using Golang channels to get feedback from the NPU by enabling go threads to probe the NPU and return data, but we restrict the channels to the Golang program side, where an object reads the data, interprets it, and makes a callback).
[0100] In some examples, channels and asyncio can be used to create filter paths (e.g., flatboat paths). Channels and asyncio can be used for various functions, such as Cable Data Service Interface Specification (DOCSIS) control messages, IPsec IKE messages, BGP control plane messages, etc. Furthermore, channels and asyncio can be used for various events that may trigger serverless network functions, such as detecting and enforcing thresholds, rate limiting, new packet detection, etc. Going further, channels and asyncio can be used for logging, such as logging current packets and the history of packets that are interesting.
[0101] At 606, it is indicated that the source code representing the serverless networking functionality can be compiled into object code by the DSL compiler 226, and at 608, the DSL compiler 226 can generate object code for the serverless networking functionality. The source code can be generated or compiled into object code, which uses a language executable on the target network component. Therefore, the network controller 118 can determine the network component on which the serverless networking functionality is deployed, at least in part, based on the network component capable of executing the object code.
[0102] At 610, code can be sent from DSL compiler 226 to network controller 118 for runtime. At 612, network controller 118 can identify the best network component on which to execute serverless networking functions and deploy the target code for the serverless networking functions to that network component. At 614, the code for the serverless networking functions can be executed by network component 414.
[0103] Figure 7A and Figure 7B The diagram illustrates a corresponding flowchart of an example method for user 106 of user equipment 108 to express serverless networking functions using domain-specific and general languages, for a compiler to generate code for executing serverless functions, and for a network controller to deploy the code for serverless networking functions to one or more network devices in the network architecture. More specifically, Figure 7A It demonstrates the use of a domain-specific language and at least one of the Go or Rust programming languages to express serverless networking functionality, and Figure 7B This demonstrates how serverless networking functionality can be expressed using a domain-specific language and the Python programming language.
[0104] Figure 7AFlowchart 700 illustrates an example method of executing a serverless network function 702 on a network component, where the serverless network function is expressed using a DSL and a GPL (e.g., the Go language). As shown, the serverless network function 702 can move to a deployment state at 704. For example, at 708, the network controller 118 can deploy the code (e.g., source code, object code, etc.) of the serverless network function to a host device or network component, as described herein. Packet 706 can be sent to the host device. In such an example, the serverless network function can use a Go channel at 710 to receive packet 706. That is, the Go channel provides an interface between the serverless network function, which is at least partially written using a DSL, and the hardware layer that receives packet 706. At 712, the serverless network function can perform operations on the packet and return packet 706, such as copying packet 706, modifying packet 706, and / or any other functionality.
[0105] Figure 7B Flowchart 714 illustrates an example method of executing a serverless network function 702 on a network component, where the serverless network function is expressed using a DSL and a GPL (e.g., Python). As shown, the serverless network function 702 can move to a deployment state at 704. For example, at 716, the network controller 118 can deploy the code (e.g., source code, object code, etc.) of the serverless network function to a host device or network component, as described herein. Packet 706 can be sent from another device to the host device. In such an example, the serverless network function can receive packet 706 at 718 using the Python asyncio library. That is, the asyncio library provides an interface between the serverless network function, written at least partially using a DSL, and the hardware layer receiving packet 706. At 720, the serverless network function can perform operations on the packet and return packet 706, such as copying packet 706, modifying packet 706, and / or any other functionality.
[0106] Figure 8 An example environment 800 is shown, in which a graphical user interface (GUI) 802 is presented on user device 106, through which user 108 can express serverless networking functions using a combination of domain-specific and general languages.
[0107] As shown in the figure, GUI 802 may present or include a DSL interface 804 with GPL, through which user 108 of user equipment 106 can at least partially use DSL and at least partially use GPL to express serverless network functions via editor 220.
[0108] As described above, the techniques described herein can include using a combination of DSL and GPL to express and create serverless networking functions. For example, by understanding the nature of DSL and GPL, the techniques described herein include compiling source code written using a combination of DSL and GPL into executable code (e.g., object code or other machine code) to perform one or more serverless networking functions. GPL can include any type of GPL that can be used to define networking functions, such as the Go programming language (often referred to as "Golang"), the Rust programming language, the Python programming language, the P4 programming language, the OVSDB programming language, and / or any other language that can be used to define networking functions.
[0109] like Figure 8 As shown, interface 804 allows user 108 to provide input to editor 220 using both GPL and DSL languages. In the example shown, user 108 has entered GPL section 806 and DSL section 808 to define one or more serverless network functions. In this example, GPL section 806 is the OpenFlow programming language, but GPL can be any language (e.g., Python, Go, etc.).
[0110] In some cases, DSLs and GPLs can be integrated, allowing different languages to represent different components of one or more serverless networking functions. For example, the DSL and GSL parts 806 / 808 of a serverless networking function can be integrated using built-in connections. For instance, one component can be expressed using a DSL, and another using a GPL (e.g., Rust or Golang), and the DSL and GPL can interface or interact using channels (e.g., asynchronous channels). That is, Rust channels and Golang channels can be used as pipes to connect concurrently running components (e.g., a DSL-based component and a GPL-based component). In another example where the GPL is Python, DSL-based and GPL-based components can be connected using an asyncio library (e.g., a collection of high-level APIs, low-level APIs, etc.) for connecting asynchronous components.
[0111] In some cases, DSP and GPL can be integrated using other technologies. For example, a DSL can be designed to allow GPL code to be embedded within DSL code and compiled (or transpiled) into a combined code segment. Alternatively, a DSL can be configured to allow DSL code to be embedded within GPL code and compiled (or transpiled) into a combined code segment. Compiler 226 can be configured to ensure that the resulting code is a combination of the following: functionality expressed in DSL and functionality expressed in GPL, and cross-linking between portions of the resulting code expressed in different languages. By combining DSL and GPL, user 108 is provided with the benefit of being able to concisely express serverless network functionality using DSL, and also with the benefit of being able to express a portion of serverless network functionality using GPL, which the user may be familiar with. Compiler 226 can be configured to identify which parts of the code are written in DSL or GPL (e.g., identify semantics, identify syntax, etc.) and ensure that these parts of the code are properly compiled into the desired output code segment.
[0112] Once user 108 has completed expressing the serverless networking functionality using the DSL itself or in conjunction with the GPL through an editor, the user can select compilation option 810 to cause compiler 226 to compile the code into the desired object code. The object code 114 representing the serverless networking functionality can then be sent to network controller 118, which manages the network architecture 102 on which the serverless networking functionality will be deployed. Network controller 118 can be configured to determine the network components on which the serverless networking functionality will be deployed. Network controller 118 can determine an optimized layout for performing the serverless functionality, or determine the network components in the network architecture on which the serverless networking functionality will run.
[0113] Figure 9 A system architecture diagram of environment 900 is shown, in which network controller 118 in the network architecture deploys serverless networking functionality in an optimal location (e.g., on the optimal network component or device) within network architecture 102.
[0114] Network controller 118 can manage network architecture 102 and maintain data about the status and layout of network architecture 102. Controller 118 can use this information and data to determine the location or network components / devices to deploy serverless network functions. That is, controller 118 can determine network components with the most suitable characteristics for performing serverless network functions based on the type or characteristics of the serverless network function.
[0115] Network controller 118 can be configured to evaluate various standards, characteristics, data, information, etc., to determine the optimal network components for placing serverless network functions in network architecture 102. Network controller 118 can consider at least the standards, characteristics, data, etc., surrounding serverless network functions and network components. For example, network controller 118 can utilize various SNFs to place data 902, such as capacity data, management data, cost data, security issues, application location, SNF actions, DSL-generated code, collaboration data, device type, etc.
[0116] Regarding capacity data 902, network controller 118 may collect and / or analyze telemetry data indicating the availability of one or more computing resources (e.g., computing resources, storage resources, network resources, memory resources, etc.) of network components in network architecture 102. In such an example, network controller 118 may determine to deploy serverless networking functions to network components with excess resource capacity or at least sufficient resource availability to host the serverless networking functions. In some cases, network controller 118 may determine the optimal network component on which to deploy serverless networking functions based on the primary resource type consumed by the serverless networking functions and the resource availability of the network components. For example, a serverless networking function that maintains routing tables may be deployed to a network component with excess memory, while a serverless networking function that performs packet processing may be deployed to a network component with excess computing resources. Network controller 118 may determine, for example, host capacity (e.g., how many are running on potential host / network components), SmartNIC capacity (e.g., how many programs are on the SmartNIC and how full its tables are), and router capacity (e.g., how many running programs the router can handle), etc. Regarding management data 902, network controller 118 can identify difficulties associated with managing network components that are running serverless network functions. For example, network components may be at least partially outside the control of network controller 118, or configured to perform operations that controller 118 cannot control.
[0117] Regarding cost data 902, network controller 118 can consider the cost of running serverless networking functions on different network components. For example, running serverless networking functions on a host device may be more expensive than running them on a SmartNIC or router. In some cases, compute nodes may run on insufficient memory, and running serverless networking functions on that compute node may cost more. As another example, a SmartNIC may run as a host (e.g., due to too much traffic), so serverless networking functions can be placed on different network components / hosts. Therefore, network controller 118 can gain insight into cost data 902 for running serverless networking functions on network components and select optimized network components to run serverless networking functions based on a lower cost compared to other network components capable of running serverless networking functions.
[0118] Regarding security concerns, network controller 118 may consider security issues related to running serverless networking functions. For example, network controller 118 may determine whether the serverless networking function is trusted to run on various network components. For example, based on the functions being performed by the serverless networking function, compared to data and / or functions performed by network components, network controller 118 may determine whether to deploy the serverless networking function to network components based on security concerns.
[0119] Regarding the application location used to optimize the placement of serverless networking functions, network controller 118 can monitor or otherwise determine the software location of various software functions, such as applications hosted in a Software as a Service (SaaS) environment. In such an example, network controller 118 can further determine that the serverless networking function is configured to attach to a specific SaaS computing function and perform serverless networking functions specific to that SaaS computing function. In such an example, network controller 118 can determine to deploy the serverless networking function on the same or adjacent host as the SaaS computing function to work seamlessly with the SaaS computing function.
[0120] Regarding serverless network function actions, network controller 118 can determine the type of serverless network function (e.g., which one or more actions the serverless network function performs) and place the serverless network function. Network controller 118 can maintain a layout or architectural model or other representation of the network architecture 102 that network controller 118 is managing. This can include the location of network components in network architecture 102 (e.g., near the network edge, near application servers, etc.) and / or the functionality of different network devices in network architecture 102 (e.g., firewall components, routing components, etc.). Network controller 118 can determine the location for deploying serverless network functions based on the location and / or functionality of network components.
[0121] As an example, network controller 118 can determine that the serverless networking function is packet drop SNF 904. In such an example, network controller 118 can determine that the optimal location for packet drop SNF 904 would be on router 120, or on another network component near the edge of network architecture 102. This way, dropped packets do not need to flow through as many devices as those in network architecture 102, thus conserving resources, and can be dropped at the edge of network architecture 102. Furthermore, packet drop SNF 904 can operate efficiently on router 120, at least because router 120 is capable of efficiently dropping packets in hardware (since software dropping is more expensive).
[0122] For some other examples, network controller 118 may determine to place packet forwarding SNF 906 on backbone switch 122, packet routing SNF 908 on leaf switch, and / or packet modification SNF 910 on server 126. Network controller 118 may determine that these network components are optimized to perform specific serverless network functions based on their location in the network architecture or based on the actions they perform in network architecture 102. Furthermore, packet modification SNF 910 may be optimized to run on server 126 or a SmartNIC.
[0123] Furthermore, regarding the DSL-generated code 902, the network controller 118 can determine the code type of the serverless network function and identify the network components capable of executing or optimized to execute that code type. For example, the SNF can be compiled into code such as OpenFlow programming language programs, P4 programming language programs, Linux eBPF programs, programs configured to execute on a SmartNIC, hardware description languages associated with at least one of an FPGA or ASIC, vector packet processor (VPP) programs, and / or any other object code or source code. The network controller 118 can select the network components capable of executing the serverless network function or optimized (e.g., efficient operation) to execute the serverless network function based on the code type of the serverless network function.
[0124] Furthermore, network controller 118 can determine whether to place serverless networking functionality on network components that synergize with the type of serverless networking functionality. For example, network controller 118 can determine that some other network components closer to network architecture 102 are more efficient at running SNFs due to factors such as the availability of packet transmission in memory.
[0125] Network controller 118 can determine network components optimized to run serverless functions and deploy serverless networking functions based on one or more (individually or in combination) of the SNF placement data discussed herein.
[0126] Furthermore, network controller 118 can deploy SNF code 114 and has one or more mechanisms for deploying SNF code 114. For example, when deploying SNF code 114 to the host itself (e.g., on a Linux bridge, OpenvSwitch switch, eBPF, VPP, etc.), network controller 118 can simply load the generated code onto the host. The generated SNF code 114 can instruct the target backend network component, thereby restricting placement. In some cases, an SSL connection can be used to load SNF code 114 onto an optimized network component.
[0127] Once an SNF is deployed, the network controller 118 can monitor the SNF to ensure it is functioning properly. This can include obtaining telemetry data from the SNF and / or the host, and the telemetry data can allow the network controller 118 to ensure the SNF is operating within its parameters. A production-ready DSL can also be built around this telemetry, allowing the network controller 118 to easily use it and shut down the cycle of monitoring the SNF when running in production.
[0128] In some examples, the SNF can autoscale. For instance, the DSL can include autoscaling bits in the generated code, and the network controller 118 can use it to handle autoscaling consistent with the deployment options. This means that when the SNF reaches certain thresholds regarding things like bandwidth, CPU usage, etc., it can automatically scale. This will be done using telemetry data from the monitoring described above. Autoscaling of the SNF can be performed in this way.
[0129] Figures 10 to 12 Flowcharts of example methods 1000, 1100, and 1200 are shown, which illustrate at least in part the methods described by... Figures 10 to 12 This document describes various aspects of the functions performed by the devices (e.g., user equipment 106, network controller 118, etc.) described herein. Figures 10 to 12 The described logical operations can be implemented as (1) a computer-implemented sequence of actions or a program module running on a computing system and / or (2) machine logic circuits or circuit modules interconnected within the computing system.
[0130] The implementation of the various components described in this paper depends on the performance and other requirements of the computing system. Therefore, the logical operations described herein are referred to differently as operations, structural devices, actions, or modules. These operations, structural devices, actions, and modules can be implemented using software, firmware, dedicated digital logic, and any combination thereof. It should also be understood that it is possible to perform operations that are more complex than... Figures 10 to 12 The operations shown and described herein may include more or fewer operations. These operations may also be performed in parallel or in an order different from that described herein. Some or all of these operations may also be performed by components other than those specifically identified. Although the techniques described in this disclosure are referenced to specific components, in other examples, these techniques may be implemented by fewer components, more components, different components, or any configuration of components.
[0131] In certain circumstances, the steps of methods 1000, 1100, and / or 1200 may be performed by a device and / or device system comprising one or more processors and one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by one or more processors, cause one or more processors to perform the operations of methods 1000, 1100, and / or 1200.
[0132] Figure 10 A flowchart is shown for an example method 1000 for expressing serverless networking functions using a domain-specific language and generating code for performing serverless networking functions.
[0133] At 1002, user equipment 106 (and / or network controller 118) may receive a first code expressed in DSL, which defines a serverless network function to be performed by the network device. Typically, a DSL can be used to define multiple serverless network functions and is specifically used to define a Serverless Network Function (SNF). A serverless network function may include at least one of the following: a packet acquisition function configured to selectively perform on the network device to acquire packets; a packet generation function configured to selectively perform on the network device to generate packets; a packet replication function configured to selectively perform on the network device to replicate packets; a packet modification function configured to selectively perform on the network device to modify packets; a packet drop function configured to selectively perform on the network device to drop packets; or a packet forwarding function configured to selectively perform on the network device to forward packets.
[0134] In some cases, method 1000 may further include exposing a text editor configured to receive text input expressed in DSL to define serverless network functionality, wherein receiving a first code includes receiving the text input defining the serverless network functionality. Additionally, method 1000 may additionally or alternatively include exposing an editor configured to receive graphical icon input that can be used to express serverless network functionality in DSL, wherein receiving a first code includes receiving one or more graphical icons via the editor defining the serverless network functionality.
[0135] At 1004, user equipment 106 (and / or network controller 118) can generate second code using a DSL compiler and at least in part using the first code. This second code includes machine-executable instructions executable by the network device to perform serverless networking functions. In some cases, method 1000 may also include receiving an indication of the device type of the network device on which the serverless networking functions will be performed, and determining, at least in part, a programming language executable on the network device based on the device type, wherein the second code is generated in that programming language.
[0136] In some cases, method 1000 may also include providing a second code to a software-defined networking (SDN) controller that manages a network including network devices, and the SDN controller providing the second code to the network devices.
[0137] Figure 11 A flowchart is shown for an example method 1100 for expressing serverless networking functions using domain-specific and common languages and generating code for performing serverless networking functions.
[0138] At 1102, user equipment 106 may receive first source code expressed in DSL, which defines a first portion of a serverless network function to be executed by a network device. The DSL can be used to define multiple serverless network functions. At 1104, user equipment 106 may receive second source code expressed in GPL, which defines a second portion of the serverless network function. At 1106, user equipment 106 may at least partially use a compiler to generate the first and second source codes, the object code including machine-executable instructions executable by the network device to perform the serverless network function.
[0139] Figure 12 A flowchart is shown for an example method 1200 for deploying serverless networking functionality to a network component, where the serverless networking functionality is optimized to perform at the network component.
[0140] At 1202, the network controller can receive code representing a network function. At 1204, the controller can determine the characteristics associated with the execution of the network function. At 1206, the controller can select from multiple network components in the network a network component optimized to perform the network function at least in part based on that characteristic. At 1208, the controller can deploy the code representing the network function to the network component.
[0141] Figure 13 An example computer architecture is shown that is capable of executing program components for achieving the above-described functions. Figure 13 The computer architecture shown illustrates any type of computer 1300, such as a conventional server computer, workstation, desktop computer, laptop computer, tablet computer, network device, e-reader, smartphone, or other computing device, and can be used to execute any of the software components presented herein. In some examples, computer 1300 may correspond to user device 106 and / or any other device described herein, and may include personal devices (e.g., smartphones, tablets, wearable devices, laptops, etc.), networking devices (e.g., servers, switches, routers, hubs, bridges, gateways, modems, repeaters, access points), and / or any other type of computing device that may run any type of software and / or virtualization technology.
[0142] Computer 1300 includes a baseboard 1302 or “motherboard,” which is a printed circuit board that can be connected to a number of components or devices via a system bus or other electrical communication path. In an illustrative configuration, one or more central processing units (“CPU”) 1304 operate in conjunction with chipset 1306. CPU 1304 may be a standard programmable processor that performs the arithmetic and logic operations necessary to perform the operation of computer 1300.
[0143] The CPU 1304 performs operations by transitioning from one discrete physical state to the next (via manipulating switching elements that distinguish and change these states). Switching elements typically include electronic circuitry, such as flip-flops, that holds one of two binary states, and often include electronic circuitry, such as logic gates, that provides an output state based on a logical combination of the states of one or more other switching elements. These basic switching elements can be combined to create more complex logic circuits, including registers, adders / subtractors, arithmetic logic units, floating-point units, and more.
[0144] Chipset 1306 provides an interface between CPU 1304 and the remaining components and devices on substrate 1302. Chipset 1306 may provide an interface to RAM 1308, which serves as main memory in computer 1300. Chipset 1306 may further provide an interface to a computer-readable storage medium, such as read-only memory (“ROM”) 1310 or non-volatile RAM (“NVRAM”), for storing information that facilitates booting computer 1300 and transferring information between various components and devices. Depending on the configuration described herein, ROM 1310 or NVRAM may also store other software components necessary for the operation of computer 1300.
[0145] Computer 1300 can operate in a networked environment using logical connections to remote computing devices and computer systems via a network (e.g., network 116). Chipset 1306 may include functionality for providing network connectivity via NIC 1312, such as a Gigabit Ethernet adapter. NIC 1312 enables computer 1300 to connect to other computing devices via network 116. It should be understood that multiple NICs 1312 may exist in computer 1300, connecting the computer to other types of networks and remote computer systems.
[0146] Computer 1300 can be connected to storage device 1318, which provides non-volatile storage for the computer. Storage device 1318 can store operating system 1320, programs 1322, and data, which have been described in more detail herein. Storage device 1318 can be connected to computer 1300 via storage controller 1314 connected to chipset 1306. Storage device 1318 can consist of one or more physical storage units. Storage controller 1314 can interface with physical storage units via a Serial Attached SCSI (“SAS”) interface, a Serial Advanced Technology Attached (“SATA”) interface, a Fibre Channel (“FC”) interface, or other types of interfaces for physical connection and data transfer between the computer and physical storage units.
[0147] Computer 1300 can store data on storage device 1318 by transforming the physical state of physical storage units to reflect the information being stored. In different embodiments of this specification, the specific transformation of the physical state can depend on various factors. Examples of such factors may include, but are not limited to, the technology used to implement the physical storage units, whether storage device 1318 is characterized as a primary storage device or a secondary storage device, etc.
[0148] For example, computer 1300 can store information in storage device 1318 by issuing instructions via storage controller 1314 to change the magnetic properties of a specific location within a disk drive unit, the reflection or refraction properties of a specific location within an optical storage unit, or the electrical properties of a specific capacitor, transistor, or other discrete component in a solid-state storage unit. Other transformations of the physical medium are possible without departing from the scope and spirit of this specification; the foregoing examples are provided merely for ease of description. Computer 1300 can further read information from storage device 1318 by detecting the physical state or characteristics of one or more specific locations within the physical storage unit.
[0149] In addition to the aforementioned mass storage device 1318, computer 1300 may access other computer-readable storage media to store and retrieve information, such as program modules, data structures, or other data. Those skilled in the art will understand that computer-readable storage media are any available media that provides non-transitory storage of data and can be accessed by computer 1300. In some examples, operations performed by user equipment 106, network controller 118, and / or any components included therein may be supported by one or more devices similar to computer 1300. In other words, some or all of the operations performed by user equipment 106 and / or network controller 118 and / or any components included therein may be performed by one or more computer devices 1300.
[0150] By way of example and not limitation, computer-readable storage media can include volatile and non-volatile, removable and non-removable media implemented in any method or technology. Computer-readable storage media include, but are not limited to, RAM, ROM, erasable programmable ROM (“EPROM”), electrically erasable programmable ROM (“EEPROM”), flash memory or other solid-state storage technologies, optical disc ROM (“CD-ROM”), digital versatile optical disc (“DVD”), high-definition DVD (“HD-DVD”), Blu-ray or other optical storage devices, magnetic tape cassettes, magnetic tape, disk storage devices or other magnetic storage devices, or any other medium that can be used to store desired information in a non-transitory manner.
[0151] As described above, storage device 1318 may store operating system 1320 for controlling the operation of computer 1300. According to one embodiment, the operating system includes a LINUX operating system. According to another embodiment, the operating system includes a Microsoft Corporation from Redmond, Washington. SERVER operating system. According to a further embodiment, the operating system may include one of the UNIX operating systems or variants thereof. It should be understood that other operating systems may also be used. Storage device 1318 may store other systems or applications and data used by computer 1300.
[0152] In one embodiment, storage device 1318 or other computer-readable storage medium is encoded with computer-executable instructions that, when loaded into computer 1300, transform the computer from a general-purpose computing system into a special-purpose computer capable of implementing the embodiments described herein. As described above, these computer-executable instructions transform computer 1300 by specifying how CPU 1304 transitions between states. According to one embodiment, computer 1300 can access a computer-readable storage medium storing computer-executable instructions that, when executed by computer 1300, perform the above-described... Figures 1 to 12 The various processes described herein. The computer 1300 may also include a computer-readable storage medium having instructions stored thereon for performing the operations of any other computer implementation described herein.
[0153] Computer 1300 may also include one or more input / output controllers 1316 for receiving and processing input from multiple input devices, such as a keyboard, mouse, touchpad, touchscreen, electronic stylus, or other types of input devices. Similarly, input / output controllers 1316 may provide output to a display, such as a computer monitor, flat panel display, digital projector, printer, or other types of output devices. It should be understood that computer 1300 may not include... Figure 2 and / or Figure 3 All components shown may include those not listed Figure 13 Other components explicitly shown in the document, or those that may utilize [the following]. Figure 13 The architecture shown is completely different from the one shown.
[0154] As described herein, computer 1300 may include one or more of user equipment 106, network controller 118, and / or any other devices. Computer 1300 may include one or more hardware processors 1304 (processors) configured to execute one or more stored instructions. Processor 1304 may include one or more cores. Furthermore, computer 1300 may include one or more network interfaces configured to provide communication between computer 1300 and other devices, such as the communication described herein performed by user equipment 106 or network controller 118. Network interfaces may include devices configured to couple to personal area networks (PANs), wired and wireless local area networks (LANs), wired and wireless wide area networks (WANs), etc. For example, network interfaces may include interfaces with Ethernet, Wi-Fi, etc. TM Compatible devices.
[0155] Program 1322 may include any type of program or process to perform the techniques described in this disclosure for generating SNFs using DSLs and / or deploying SNFs to optimized network components.
[0156] While the invention has been described with respect to specific examples, it should be understood that the scope of the invention is not limited to these specific examples. Since other modifications and variations to suit specific operational requirements and environments will be readily apparent to those skilled in the art, the invention is not to be considered limited to the examples chosen for the purposes of disclosure, and covers all changes and modifications that do not depart from the true spirit and scope of the invention.
[0157] Although this application describes embodiments with specific structural features and / or methodological actions, it should be understood that the claims are not necessarily limited to the specific features or actions described. Rather, the specific features and actions are merely illustrative embodiments that fall within the scope of the claims of this application.
Claims
1. A method for identifying network components to which network functions are to be deployed from a plurality of network components in a network, the method comprising: The controller of the network receives code representing the network function, wherein the code is executable to perform data plane operations on data traffic in the network; The controller identifies characteristics associated with the execution of the network function, wherein identifying characteristics associated with the execution of the network function includes determining that a specific type of the network function is a packet forwarding function; Determine where the network component is located in the network where the execution of the network function is optimized to perform the specific type of network function, wherein performing the specific type of network function includes forwarding packets to a server; The network component is selected from a plurality of network components in the network, at least in part based on the fact that the network component is a switch device optimized to perform the network function in the location of the network component. as well as The controller deploys the code representing the network function to the network component.
2. The method of claim 1, wherein: The network functionality includes serverless network functionality; and The code representing the network function includes, at least in part, target code generated using a domain-specific language that can be used to define serverless network functions.
3. The method as described in claim 1 or 2, wherein: Identifying characteristics associated with the execution of the network function includes determining the amount of computing resources consumed by the execution of the network function; and Selecting the network component includes determining the availability of computing resources for the network component to support the amount of computing resources consumed by the execution of the network function.
4. The method as described in claim 1 or 2, wherein: Identifying characteristics associated with the execution of the network function includes determining that the network function is configured to interact with a software computing instance hosted on another network component within the network; and Selecting the network component includes determining that the network component is within a threshold distance to the other network component in the network.
5. The method as described in claim 1 or 2, wherein: Identifying characteristics associated with the execution of the network function includes determining the specific type of the code representing the network function; and Selecting the network component includes determining that the network component is configured to execute the specific type of code.
6. The method as described in claim 1 or 2, wherein: Identifying characteristics associated with the execution of the network function includes determining a specific trust level associated with the execution of the network function; and Selecting the network component includes determining that the network component is configured to perform network functions with the specific trust level.
7. The method as described in claim 1 or 2, wherein, The network component includes one or more of the following: router; Network interface card (NIC); server; Network switch; Virtual machine; or Virtual container.
8. A system for identifying network components to be deployed with network functions from a plurality of network components in a network, the system comprising: One or more processors; as well as One or more non-transitory computer-readable media storing computer-executable instructions, which, when executed by the one or more processors, cause the one or more processors to perform operations, the operations including: Receive code indicating the network function to be deployed in the network, wherein the code is executable to perform data plane operations on data traffic in the network; Identifying characteristics associated with the execution of the network function, wherein identifying characteristics associated with the execution of the network function includes determining that the specific type of the network function is a packet forwarding function; Determine where the network component is located in the network where the execution of the network function is optimized to perform the specific type of network function, wherein performing the specific type of network function includes forwarding packets to a server; The network component is selected from a plurality of network components in the network, at least in part based on the fact that the network component is a switch device optimized to perform the network function in the location described above; and The code representing the network function is deployed to the network component.
9. The system of claim 8, wherein: The network functionality includes serverless network functionality; and The code representing the network function includes, at least in part, target code generated using a domain-specific language that can be used to define serverless network functions.
10. The system of claim 8 or 9, wherein: Identifying characteristics associated with the execution of the network function includes determining the amount of computing resources consumed by the execution of the network function; and Selecting the network component includes determining the availability of computing resources for the network component to support the amount of computing resources consumed by the execution of the network function.
11. The system of claim 8 or 9, wherein: Identifying characteristics associated with the execution of the network function includes determining that the network function is configured to interact with a software computing instance hosted on another network component within the network; and Selecting the network component includes determining that the network component is within a threshold distance to the other network component in the network.
12. The system of claim 8 or 9, wherein: Identifying characteristics associated with the execution of the network function includes determining the specific type of the code representing the network function; and Selecting the network component includes determining that the network component is configured to execute the specific type of code.
13. The system of claim 8 or 9, wherein: Identifying characteristics associated with the execution of the network function includes determining a specific trust level associated with the execution of the network function; and Selecting the network component includes determining that the network component is configured to perform network functions with the specific trust level.
14. The system as claimed in claim 8 or 9, wherein, The network component includes one or more of the following: router; Network interface card (NIC); server; Network switch; Virtual machine; or Virtual container.
15. One or more non-transitory computer-readable media storing computer-executable instructions, which, when executed by the one or more processors, cause the one or more processors to perform operations, the operations including: Receive code representing network functions to be deployed in a network, wherein the code is executable to perform data plane operations on data traffic in the network; Identifying characteristics associated with the execution of the network function, wherein identifying characteristics associated with the execution of the network function includes determining that the specific type of the network function is a packet forwarding function; Determine where the network component is located in the network where the execution of the network function is optimized to perform the specific type of network function, wherein performing the specific type of network function includes forwarding packets to a server; The network component is selected from a plurality of network components in the network, at least in part based on the fact that the network component is a switch device optimized to perform the network function in the location of the network component. as well as The code representing the network function is deployed to the network component.
16. One or more non-transitory computer-readable media as claimed in claim 15, wherein: The network functionality includes serverless network functionality; and The code representing the network function includes, at least in part, target code generated using a domain-specific language that can be used to define serverless network functions.
17. One or more non-transitory computer-readable media as described in claim 15 or 16, wherein: Identifying characteristics associated with the execution of the network function includes determining the amount of computing resources consumed by the execution of the network function; and Selecting the network component includes determining the availability of computing resources for the network component to support the amount of computing resources consumed by the execution of the network function.
18. An apparatus for identifying a network component from a plurality of network components in a network on which network functions are to be deployed, the apparatus comprising: A means for receiving, by a controller of the network, code representing network functions, wherein the code is executable to perform data plane operations on data traffic in the network; A means for identifying characteristics associated with the execution of the network function by the controller, wherein identifying characteristics associated with the execution of the network function includes determining that a particular type of the network function is a packet forwarding function; A means for determining the location of the network component in the network where the execution of the network function is optimized to perform the specific type of network function, wherein performing the specific type of network function includes forwarding packets to a server; A means for selecting a network component from a plurality of network components in the network, based at least in part on the fact that the network component is an optimized switching device located in the network to perform the network function; as well as A means for deploying the code representing the network function to the network component by the controller.
19. The apparatus of claim 18, further comprising means for implementing the method of any one of claims 2 to 7.
20. A computer program product comprising instructions that, when executed by a computer, cause the computer to perform the steps of the method as claimed in any one of claims 1 to 7.
Citation Information
Patent Citations
Controlling of virtualized network functions for usage in communication network
US20150358248A1
Virtualized network functions and service chaining in serverless computing infrastructure
US20190182128A1
