Method for docking and adapting working node host and DPU of cloud computing cluster, DPU chip, DPU intelligent network card and cloud computing equipment

Abstract

The application provides a method for docking and adapting a work node host and a DPU of a cloud computing cluster, a DPU chip, a DPU intelligent network card and a cloud computing device, and the method comprises the following steps: calling a single-root I / O virtualization network device plug-in to allocate a first virtual function; creating a first container group and allocating the first virtual function to the first container group; calling the multi-interface container network element plug-in to create a first interface device corresponding to the first virtual function; the vector data packet processing framework agent calls a DPU virtual resource management daemon to load and manage the first interface device; the multi-interface container network element plug-in loads a virtualization network driver for the first virtual function and transfers the first interface device to a network space of the first container group. According to the technical scheme of the application, complex network layer functions and large-scale network topology processing can be supported, and seamless support for the cloud computing cluster and efficient network policy management can be realized.

Description

Technical Field

[0001] This invention relates to the field of cloud computing technology, specifically to a method for interfacing and adapting a cloud computing cluster's worker node host and DPU, a DPU chip and a DPU smart network card, and cloud computing equipment. Background Technology

[0002] With technological advancements, Data Processing Units (DPUs) play a crucial role in cloud-native networks, particularly in enhancing performance, security, and flexibility. DPUs can offload tasks previously performed by the host CPU to their own devices, such as packet processing on virtual switches (e.g., OVS-DPDK), storage protocol processing, and encryption / decryption operations. Furthermore, DPUs can leverage hardware acceleration to improve network performance, providing cloud-native networks with greater processing power, higher efficiency, and enhanced security, enabling enterprises to remain competitive while meeting ever-growing application demands.

[0003] However, currently, running OVS-DPDK (Data Plane Development Kit) on general-purpose chips integrated into DPUs is a slow path. While OVS (Open Virtual Switch) is mature in the L2 (data link layer) switching field, its capabilities at the L3 (network layer) are still relatively limited. For cloud-native scenarios, OVS-DPDK is difficult to interface with pure Layer 3 network plugins, which complicates dynamic network policy management in cloud-native environments.

[0004] Therefore, a technical solution is needed that can support the processing of complex network layer functions and large-scale network topologies, and achieve seamless support for cloud computing clusters and efficient network policy management. Summary of the Invention

[0005] This application aims to provide a method for interfacing and adapting a worker node host and a DPU for a cloud computing cluster, a DPU chip and a DPU smart network card, and a cloud computing device, which supports complex network layer functions and large-scale network topology processing, and achieves seamless support for cloud computing clusters and efficient network policy management.

[0006] According to one aspect of this application, a method for interfacing and adapting a worker node host and a DPU in a cloud computing cluster is provided. The worker node host is connected to a smart network interface card (NIC), the smart NIC has a DPU, and the worker node host runs a Kubernetes cluster agent, a multi-interface container network element plugin for Kubernetes clusters, a single-root I / O virtualization network device plugin, and a vector packet processing framework agent. The single-root I / O virtualization network device plugin manages the virtual functions of the smart NIC, and the vector packet processing framework agent interacts with a vector packet processing framework offloaded to the DPU. The method is used on the worker node host, and the method includes:

[0007] The K8S cluster agent responds to the instructions from the control node host and calls the single root I / O virtualization network device plugin to allocate the first virtual function;

[0008] The K8S cluster agent creates a first container group and assigns the first virtual function to the first container group;

[0009] The K8S cluster agent calls the multi-interface container network element plugin through the vector packet processing framework agent to call the vector packet processing framework, and the vector packet processing framework creates a first interface device corresponding to the first virtual function;

[0010] The vector data packet processing framework agent calls the DPU virtual resource management daemon to load and manage the first interface device;

[0011] The multi-interface container network element plugin loads the virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group.

[0012] According to some embodiments, the worker node host also runs a first container network interface plugin and a vector packet processing framework node container group integrated into the first container network interface plugin, the vector packet processing framework node container group including the vector packet processing framework agent;

[0013] The K8S cluster agent invokes the multi-interface container network meta-plugin through the vector packet processing framework, which in turn invokes the vector packet processing framework. The vector packet processing framework creates a first interface device corresponding to the first virtual function, including:

[0014] The multi-interface container network element plugin calls the first container network interface plugin to configure the first virtual function;

[0015] The first container network interface plugin invokes the vector packet processing framework agent, thereby the vector packet processing framework agent invokes the vector packet processing framework.

[0016] According to some embodiments, the multi-interface container network meta-plugin loads a virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group, including:

[0017] The first container network interface plugin loads a virtualized network driver for the first virtual function and associates the first interface device with the first virtual function, thereby enabling the first virtual function to communicate with the first interface device through a virtualized network protocol.

[0018] According to some embodiments, the vector packet processing framework creates a first interface device corresponding to the first virtual function, including:

[0019] The vector packet processing framework interfaces with the DPU's DPDK via a DPDK plugin and adds the first interface device through a device creation function.

[0020] According to some embodiments, the vector packet processing framework agent communicates with the vector packet processing framework offloaded to the DPU via the TCP protocol.

[0021] According to another aspect of this application, a method for interfacing and adapting a worker node host and a DPU in a cloud computing cluster is provided. The worker node host is connected to a smart network interface card (NIC), the smart NIC has a DPU, and the worker node host runs a K8S cluster agent, a multi-interface container network element plugin for K8S clusters, a single root I / O virtualization network device plugin, and a vector packet processing framework agent. The single root I / O virtualization network device plugin manages the virtual functions of the smart NIC, and the vector packet processing framework agent interacts with the vector packet processing framework offloaded to the DPU.

[0022] The K8S cluster agent responds to the instructions from the control node host and calls the single root I / O virtualization network device plugin to allocate the first virtual function;

[0023] The K8S cluster agent creates a first container group and assigns the first virtual function to the first container group;

[0024] The method is used in the DPU, and the method includes:

[0025] In response to the call of the vector packet processing framework agent, the vector packet processing framework creates a first interface device corresponding to the first virtual function;

[0026] The DPU virtual resource management daemon loads and manages the first interface device, thereby enabling the first container network interface plugin to load the virtualized network driver for the first virtual function and associate the first interface device with the first virtual function.

[0027] According to some embodiments, the vector packet processing framework replaces the DPDK plugin's data stream redirection to a queue with a data stream redirection to a port.

[0028] According to another aspect of this application, a DPU chip is provided, including a processor and a memory, wherein a computer program is stored in the memory, and when the processor runs the computer program stored in the memory, it implements the method described in any of the preceding claims.

[0029] According to another aspect of this application, a DPU smart network card is provided, the DPU smart network card comprising: a DPU chip as described above and a plurality of interfaces, the DPU chip communicating externally through the plurality of interfaces.

[0030] According to another aspect of this application, a cloud computing device is provided, comprising: a DPU smart network interface card and a central processing unit as described above, wherein the DPU smart network interface card is used for processing data or external communication, and the central processing unit is used for processing data scheduled by the DPU smart network interface card.

[0031] According to another aspect of this application, a non-transitory computer-readable storage medium is provided, having stored thereon computer-readable instructions that, when executed by a processor, cause the processor to perform the method as described in any of the preceding claims.

[0032] According to some embodiments, the design scheme of this invention, through the collaboration between the vector packet processing framework proxy and the Kubernetes cluster proxy, can implement granular network access control policies. By allocating the first Virtual Function (VF) to the first container group and utilizing the DPU on the smart network interface card for vector packet processing, network data processing speed can be significantly improved and latency reduced. By applying Single Root I / O Virtualization (SR-IOV) technology, multiple containers can share the resources of the same physical network interface card while maintaining relatively independent network interfaces, thereby improving the network performance and resource utilization efficiency of the cloud computing cluster. Each container group has independent virtual functions and corresponding network interface devices, achieving effective network isolation and increasing security.

[0033] According to embodiments of the present invention, the design scheme offloads the data plane processing tasks of the VPP to the DPU, fully utilizing the hardware acceleration capabilities provided by the DPU, thereby significantly improving the processing speed and efficiency of data packets. According to some embodiments, the design scheme of the present invention adapts to various related components in the VPP, enabling it to seamlessly support the complex network requirements of cloud-native environments.

[0034] According to some embodiments, the first container network interface plugin loads a virtualized network driver for the first virtual function and associates the first interface device with the first virtual function, so that the first virtual function communicates with the first interface device through a virtualized network protocol.

[0035] It should be understood that the above general description and the following detailed description are merely exemplary and do not limit this application. Attached Figure Description

[0036] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below.

[0037] Figure 1 This diagram illustrates the architecture of the worker node host and DPU docking adaptation of a cloud computing cluster according to an example embodiment.

[0038] Figure 2 A flowchart illustrating a method for interfacing and adapting worker node hosts and DPUs in a cloud computing cluster applied to worker node hosts according to an example embodiment.

[0039] Figure 3 This diagram illustrates a device for interfacing and adapting worker nodes and DPUs in a cloud computing cluster, according to an example embodiment.

[0040] Figure 4 A flowchart illustrating a method for interfacing and adapting a cloud computing cluster worker node host and a DPU to a DPU, according to an example embodiment, is shown.

[0041] Figure 5 This diagram illustrates a device for interfacing and adapting worker nodes and DPUs in a cloud computing cluster, according to an example embodiment.

[0042] Figure 6 A schematic diagram of a DPU smart network interface card is shown according to an example embodiment.

[0043] Figure 7 A block diagram of a cloud computing device according to an exemplary embodiment is shown. Detailed Implementation

[0044] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the embodiments set forth herein; rather, they are provided so that this application will be thorough and complete, and will fully convey the concept of the exemplary embodiments to those skilled in the art. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted.

[0045] Furthermore, the described features, structures, or characteristics can be combined in any suitable manner in one or more embodiments. Numerous specific details are provided in the following description to give a thorough understanding of embodiments of this application. However, those skilled in the art will recognize that the technical solutions of this application can be practiced without one or more of the specific details, or other methods, components, apparatuses, steps, etc., can be employed. In other instances, well-known methods, apparatuses, implementations, or operations are not shown or described in detail to avoid obscuring various aspects of this application.

[0046] The block diagrams shown in the accompanying drawings are merely functional entities and do not necessarily correspond to physically independent entities. That is, these functional entities can be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0047] The flowcharts shown in the accompanying drawings are merely illustrative and do not necessarily include all content and operations / steps, nor do they necessarily have to be performed in the described order. For example, some operations / steps can be broken down, while others can be combined or partially combined; therefore, the actual execution order may change depending on the specific circumstances.

[0048] It should be understood that although the terms first, second, third, etc., may be used herein to describe various components, these components should not be limited by these terms. These terms are used to distinguish one component from another. Therefore, the first component discussed below may be referred to as the second component without departing from the teachings of this application. As used herein, the term "and / or" includes all combinations of any one and more of the associated listed items.

[0049] The user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0050] Those skilled in the art will understand that the accompanying drawings are merely schematic diagrams of exemplary embodiments, and the modules or processes in the drawings are not necessarily essential for implementing this application, and therefore cannot be used to limit the scope of protection of this application.

[0051] As mentioned earlier, OVS-DPDK is difficult to interface with pure Layer 3 network plugins in cloud-native scenarios, which complicates dynamic network policy management in cloud-native environments. VPP (Vector Packet Processing), on the other hand, boasts a highly mature routing stack, supporting complex Layer 3 functions and large-scale network topologies. Furthermore, VPP's memory and caching utilization is meticulously optimized, making it more consistently efficient in packet processing compared to OVS.

[0052] To this end, this application proposes a method for the docking and adaptation of worker node hosts and DPUs in a cloud computing cluster. This method can combine the advantages of DPUs and VPPs, support complex network layer functions and large-scale network topology processing, and achieve seamless support for cloud computing clusters and efficient network policy management.

[0053] Figure 1 This diagram illustrates the architecture of the worker node host and DPU docking adaptation of a cloud computing cluster according to an example embodiment.

[0054] See Figure 1 According to the embodiment, by offloading the VPP's data plane processing tasks to run on the DPU and using the DPDK plugin for efficient interaction, the hardware acceleration capabilities provided by the DPU can be fully utilized, thereby significantly improving the processing speed and efficiency of data packets.

[0055] like Figure 1 As shown in the example embodiment, in the overall architecture after DPU integration, the VPP is offloaded to the DPU, and a Single Root I / O Virtualization (SR-IOV) network device plugin is added to manage Virtual Function (VF) devices. The SR-IOV plugin allows Kubernetes to directly manage the virtual functions (VFs) of physical network interface cards, improving network performance.

[0056] See Figure 1The worker node host is connected to a smart network interface card (NIC), which has a Data Processing Unit (DPU). The worker node host runs a Kubernetes cluster agent (kubelet), a multi-interface container network element (MultusCNI) for Kubernetes clusters, a single root I / O virtualization network device plugin (SR-IOV network device plugin), and a vector packet processing framework agent (Calico-VPP agent). The single root I / O virtualization network device plugin manages the virtual functions of the smart NIC, and the vector packet processing framework agent interacts with the vector packet processing framework offloaded to the DPU.

[0057] On the control node (Master), the Kubernetes API handles API requests for the Kubernetes cluster. Kubernetes is an open-source container orchestration platform. Kubernetes is a core tool for modern cloud-native applications and is widely used in enterprise IT infrastructure. The Calico API handles network policies and configurations related to Calico. Calico is an open-source container networking solution widely used in Kubernetes clusters, supporting various network scenarios, including pure Layer 3 routing and complex network policies.

[0058] Multus CNI is a Kubernetes CNI (Container Network Interface) plugin that allows Pods (groups of containers) to bind to multiple network interfaces, enabling multi-network functionality. A Pod is the smallest unit of deployment in Kubernetes, and a Pod can contain one or more containers. Kubernetes provides a network environment for Pods, allowing communication between Pods and between Pods and the external network. The Kubernetes cluster agent (kubelet) is responsible for executing Pods and maintaining their state.

[0059] The single-root I / O virtualization network device plugin (SR-IOV network device plugin) manages the virtual functions (VFs) of the smart network interface card. The SR-IOV network device plugin is a key component for managing and allocating SR-IOV virtual function (VF) resources. Through the SR-IOV network device plugin, Kubernetes can dynamically allocate VFs to Pods, thereby achieving network virtualization and resource isolation.

[0060] The Calico-VPP agent interacts with the Vector Packet Processing Framework (VPP) offloaded to the DPU. Calico VPP is an extension of the Calico networking solution, integrating VPP technology to provide high-performance container networking capabilities. The Calico-VPP agent manages the interaction between Calico and VPP, optimizing network forwarding performance.

[0061] See Figure 1 The worker node host also runs a first container network interface plugin (Calico CNI) and a vector packet processing framework node container group (Calico-VPP-nodePod) integrated into the first container network interface plugin. The vector packet processing framework node container group includes the vector packet processing framework agent (Calico-VPP agent) and the control plane component (Felix).

[0062] Calico CNI is the Calico container networking plugin used to implement Layer 3 networking functionality. In Calico-VPP-nodePod, Felix is ​​Calico's control plane component, responsible for applying network policies to the data plane. Calico VPPagent is responsible for communicating with the VPP and forwarding network policies to it.

[0063] See Figure 1 VPP is used as a high-performance packet processing engine, especially in scenarios requiring complex Layer 3 functionality. Network policies are forwarded to the VPP on the DPU via the Calico VPP agent, ensuring efficient network policy enforcement. The combination of Calico CNI and Multus CNI provides flexible network interface management and Layer 3 network functionality. As a high-performance network data plane processing framework, VPP offers extremely fast packet processing capabilities, making it particularly suitable for cloud computing and edge computing environments.

[0064] According to example embodiments, the DPU typically runs a private virtual resource management daemon (libvirtd) to manage virtualization resources (such as Virtual Functions, network interfaces, etc.). In some embodiments, the Calico VPP agent interfaces with the libvirtd process on the DPU side to create corresponding DPU resources. For example, the Calico VPP agent interfaces with the libvirtd process on the DPU to dynamically create and manage DPU-related resources. For instance, the Calico VPP agent can include a libvirtd development library (such as libvirt-go) to call the APIs provided by the libvirtd process and implement interaction logic with the libvirtd process, such as creating and destroying Virtual Functions (VFs) and binding network interfaces.

[0065] See Figure 1 The resource scheduling core component (hyper-commander) on the DPU is responsible for managing various software components on the DPU and interfacing with libvirtd. SPDK (Storage Performance Development Kit) is an open-source high-performance storage toolkit that optimizes NVMe and RDMA storage performance.

[0066] According to the example embodiments, the architecture of the present invention fully utilizes the capabilities of SR-IOV, Multus CNI, Calico CNI, and DPU to achieve high-performance, low-latency network configuration, which is particularly suitable for application scenarios that require high throughput and low latency, such as high-performance computing, AI training, and real-time communication.

[0067] According to the example implementation, the architecture can combine the advantages of DPU and VPP, support complex network layer functions and large-scale network topology processing, and achieve seamless support for Kubernetes and efficient network policy management.

[0068] According to some embodiments, the design scheme of this invention, through the collaboration between the vector packet processing framework proxy and the Kubernetes cluster proxy, can implement granular network access control policies. By allocating the first Virtual Function (VF) to the first container group and utilizing the DPU on the smart network interface card for vector packet processing, network data processing speed can be significantly improved and latency reduced. By applying Single Root I / O Virtualization (SR-IOV) technology, multiple containers can share the resources of the same physical network interface card while maintaining relatively independent network interfaces, thereby improving the network performance and resource utilization efficiency of the cloud computing cluster. Each container group has independent virtual functions and corresponding network interface devices, achieving effective network isolation and increasing security.

[0069] According to some embodiments, the design of the present invention offloads the data plane processing task of VPP to run on DPU and uses DPDK plugin for efficient interaction, making full use of the hardware acceleration capabilities provided by DPU (such as encryption / decryption engine, compression / decompression unit, etc.), thereby significantly improving the processing speed and efficiency of data packets.

[0070] According to some embodiments, the design of the present invention, by employing the SR-IOV network device plug-in, realizes the dynamic allocation and reclamation of physical network interface virtual function (VF) resources, improves resource utilization, ensures that each Pod or container can obtain an independent network interface, and enhances resource isolation.

[0071] Figure 2 A flowchart illustrating a method for interfacing and adapting worker node hosts and DPUs in a cloud computing cluster applied to worker node hosts according to an example embodiment.

[0072] See Figure 2 In S201, the K8S cluster agent responds to the instruction from the control node host and calls the single root I / O virtualization network device plugin to allocate the first virtual function.

[0073] For example, see Figure 1 Users can create Pod resources using the kubectl command or WebUI via the K8S API on the control node host. When the kubelet on a worker node detects that the Pod has been scheduled to this node, the kubelet calls the SR-IOV network device plugin to allocate the first virtual function (VF) device resources.

[0074] According to the implementation example, in a cloud-native environment, the introduction of the SR-IOV (Single Root I / O Virtualization) network device plugin can dynamically manage and allocate the virtual functions (VF) of physical network cards, providing an independent network interface for each Pod. This not only improves network performance but also enables flexible allocation and isolation of resources.

[0075] In S203, the K8S cluster agent creates a first container group and assigns the first virtual function to the first container group.

[0076] For example, after creating a Pod using kubelet, the Multus CNI plugin can be called to configure the network for that Pod.

[0077] In some implementations, when a Pod is scheduled, Kubernetes dynamically allocates a Virtual File (VF) based on the Pod's resource requests. After allocation, the VF is bound to the network namespace where the Pod resides.

[0078] In S205, the K8S cluster agent calls the multi-interface container network element plugin through the vector packet processing framework agent to call the vector packet processing framework, and the vector packet processing framework creates a first interface device corresponding to the first virtual function.

[0079] According to some implementations, in cloud-native and high-performance network environments, offloading the VPP to the DPU to fully utilize its hardware acceleration capabilities can significantly improve packet processing efficiency and free up host CPU resources. Through the DPDK plugin, the VPP can directly interact with the DPU hardware (such as network interface cards and queues), achieving efficient network function offloading.

[0080] According to some embodiments, the multi-interface container network module calls the first container network interface module to perform network configuration on the first virtual function. The first container network interface module calls the vector packet processing framework proxy, thereby the vector packet processing framework proxy calls the vector packet processing framework.

[0081] For example, Multus CNI calls Calico CNI to configure specific network cards, and Calico CNI calls the Calico VPP agent. The Calico VPP agent then calls the DPU-side VPP to create the device.

[0082] According to some embodiments, the vector packet processing framework agent communicates with the vector packet processing framework offloaded to the DPU via the TCP protocol. The Calico VPP agent and VPP originally communicated via Unix sockets; however, after the VPP is offloaded to the DPU, they are adapted to communicate via TCP. Furthermore, the Calico VPP agent can be adapted to interface with the private libvirtd process on the DPU side to create corresponding DPU resources.

[0083] According to some embodiments, the vector packet processing framework interfaces with the DPU's DPDK via a DPDK plugin and adds the first interface device through a device creation function.

[0084] For example, VPP and DPU need to interact through the DPDK plugin. Since the DPDK library provided by the DPU differs from the open-source DPDK library in how devices are created, a new device type needs to be added to VPP. For example, two files, jmnd_cli.c and jmnd_device.c, can be added to the src / plugins / dpdk / device path in the VPP source code. jmnd_device.c is responsible for interfacing with the DPU's DPDK, implementing the creation and deletion of specific devices, and provides the following two functions:

[0085] int jmnd_create_if(vlib_main_t vm, jmnd_create_if_args_t devargs);

[0086] int jmnd_delete_if (vlib_main_t vm, dpdk_device_t rd).

[0087] `jmnd_cli.c` is responsible for registering the VPP CLI (Command Line Interface), parsing the VPP CLI parameters, and ultimately calling `jmnd_create_if` or `jmnd_delete_if`. The registered VPP CLI interfaces are as follows:

[0088] VLIB_CLI_COMMAND (jmnd_create_command, static) = {

[0089] .path = "create interface jmnd",

[0090] .short_help = "create interface jmnd devargs <devargs>name <devname>[num-desc] <size>] [num-queue <size>] ",

[0091] .function = jmnd_create_command_fn,

[0092] };

[0093] VLIB_CLI_COMMAND (jmnd_delete_command, static) = {

[0094] .path = "delete interface jmnd",

[0095] .short_help = "delete interface jmnd name <devname>",

[0096] .function = jmnd_delete_command_fn,

[0097] }

[0098] After completing the code, compile the DPU's DPDK library and VPP. The device can be created using the following VPP CLI:

[0099] create interface jmnd devargs net_jmnd_vpp0, iface= / tmp / vpp_sock0,client=1, queues=1, pref-mode=0 name jmnd_vpp0 num-desc 256 num-queue 1.

[0100] In S207, the vector packet processing framework agent calls the DPU virtual resource management daemon to load and manage the first interface device.

[0101] For example, the device is loaded by calling libvirtd on the DPU side through the Calico VPP agent.

[0102] In S209, the multi-interface container network element plugin loads the virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group.

[0103] According to some embodiments, the first container network interface plugin loads a virtualized network driver for the first virtual function and associates the first interface device with the first virtual function, so that the first virtual function communicates with the first interface device through a virtualized network protocol.

[0104] For example, since the DPU presents the VF resources to the worker node host, Calico CNI can work with the SR-IOVnetwork device plugin and Multus CNI to load the Virtio-Net driver onto the allocated VF resources and transfer the corresponding interfaces to the Pod's network space.

[0105] Figure 3 This diagram illustrates a device for interfacing and adapting worker nodes and DPUs in a cloud computing cluster, according to an example embodiment.

[0106] See Figure 3 The device includes a K8S cluster agent 301, a multi-interface container network element plugin 302 for K8S clusters, a single-root I / O virtualization network device plugin 303, and a vector packet processing framework agent 304. The single-root I / O virtualization network device plugin 303 manages the virtual functions of the smart network interface card (NIC) associated with the device, and the smart NIC has a DPU (Data Processing Unit). The K8S cluster agent 301 includes a response module 3011, a container group creation module 3012, and a calling module 3013.

[0107] According to some embodiments, the response module 3011 is configured to respond to instructions from the control node host by invoking the single-root I / O virtualization network device plugin 303 to allocate a first virtual function. Users can create Pod resources using the kubectl command or WebUI via the K8S API on the control node host. If the kubelet on a worker node detects that the Pod has been scheduled to its node, the kubelet invokes the SR-IOV network device plugin to allocate the first virtual function (VF) device resource.

[0108] According to some embodiments, the container group creation module 3012 is configured to create a first container group and assign the first virtual function to the first container group. For example, after the kubelet creates a Pod, it calls the Multus CNI plugin to configure the network for that Pod.

[0109] According to some embodiments, the calling module 3013 is configured to call the multi-interface container network element plugin 302 to call the vector packet processing framework through the vector packet processing framework agent 304, and the vector packet processing framework creates a first interface device corresponding to the first virtual function. For example, Multus CNI calls Calico CNI to perform specific network card configuration, and Calico CNI calls Calico VPP agent. Calico VPP agent calls the DPU-side VPP to create the device.

[0110] According to some embodiments, the vector packet processing framework agent 304 interacts with the vector packet processing framework offloaded to the DPU, invoking the DPU virtual resource management daemon to load and manage the first interface device. The multi-interface container network meta-plugin 302 loads a virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group. For example, the first container network interface plugin loads a virtualized network driver for the first virtual function and associates the first interface device with the first virtual function, thereby enabling the first virtual function to communicate with the first interface device through a virtualized network protocol.

[0111] Figure 4 A flowchart illustrating a method for interfacing and adapting a cloud computing cluster worker node host and a DPU to a DPU, according to an example embodiment, is shown.

[0112] Figure 4 The method shown can be used for DPUs, so that worker node hosts in a cloud computing cluster can be connected to and adapted to DPUs.

[0113] See Figure 4 In S401, in response to the call of the vector packet processing framework agent, the vector packet processing framework creates a first interface device corresponding to the first virtual function.

[0114] As previously described, according to the example embodiment, the first container network interface plugin invokes the vector packet processing framework agent, thereby the vector packet processing framework agent invokes the vector packet processing framework.

[0115] For example, Multus CNI calls Calico CNI to configure specific network cards, and Calico CNI calls the Calico VPP agent. The Calico VPP agent then calls the DPU-side VPP to create the device.

[0116] In S403, the DPU virtual resource management daemon loads and manages the first interface device, thereby enabling the first container network interface plugin to load the virtualized network driver for the first virtual function and associate the first interface device with the first virtual function.

[0117] For example, the device is loaded by calling libvirtd on the DPU side through the Calico VPP agent.

[0118] According to some embodiments, the vector packet processing framework interfaces with the DPU's DPDK via a DPDK plugin and adds the first interface device through a device creation function.

[0119] To fully leverage the hardware acceleration capabilities of the DPU, VPP needs deep integration with the DPU's hardware flow table. By modifying the VPP's hardware flow table interface, more efficient traffic management and forwarding policy configuration can be achieved, while ensuring seamless collaboration with the DPU hardware.

[0120] According to some embodiments, the vector packet processing framework replaces the DPDK plugin's data stream redirection to a queue with a data stream redirection to a port.

[0121] For example, modify the hardware flow table interface. In `src / vnet / flow / flow.c`, configure the VPP flow management interface to decouple it from other flow interfaces. VPP has its own flow management interface, which is also decoupled from specific flow interfaces (DPDK, etc.) in `src / vnet / flow / flow.c`. The DPDK library provided by DPU may differ from the open-source DPDK library in how it uses hardware flow tables, requiring modifications to the specific implementation. For instance, DPU's flow action operations do not support redirect-to-queue, while VPP's DPDK plugin uses redirect-to-queue, requiring a redirect-to-port replacement.

[0122] Figure 5 This diagram illustrates a device for interfacing and adapting worker nodes and DPUs in a cloud computing cluster, according to an example embodiment.

[0123] See Figure 5 The figure illustrates a device for interfacing and adapting a worker node host and a DPU in a cloud computing cluster. The worker node host is connected to a smart network interface card (NIC), which has a DPU. The worker node host runs a Kubernetes cluster agent, a multi-interface container network element plugin for Kubernetes clusters, a single-root I / O virtualization network device plugin, and a vector packet processing framework agent. The single-root I / O virtualization network device plugin manages the virtual functions of the smart NIC. The vector packet processing framework agent interacts with the vector packet processing framework offloaded to the DPU. The Kubernetes cluster agent responds to instructions from the control node host, invoking the single-root I / O virtualization network device plugin to allocate a first virtual function. The Kubernetes cluster agent creates a first container group and allocates the first virtual function to the first container group.

[0124] The device includes: an interface device creation module 501 and a driver module 502.

[0125] According to some embodiments, the interface device creation module 501 is configured to respond to a call from the vector packet processing framework agent, wherein the vector packet processing framework creates a first interface device corresponding to the first virtual function. For example, Multus CNI calls Calico CNI to perform specific network card configuration, and Calico CNI calls the Calico VPP agent. The Calico VPP agent calls the DPU-side VPP to create the device.

[0126] According to some embodiments, the driver module 502 is configured to load and manage the first interface device by the DPU virtual resource management daemon, thereby enabling the first container network interface plugin to load the virtualization network driver for the first virtual function and associate the first interface device with the first virtual function. For example, the Calico VPP agent calls libvirtd on the DPU side to load the device.

[0127] As mentioned above, according to embodiments of the present invention, by offloading the VPP's data plane processing tasks to the DPU and using the DPDK plugin for efficient interaction, the hardware acceleration capabilities provided by the DPU are fully utilized, thereby significantly improving the processing speed and efficiency of data packets.

[0128] According to some embodiments, by modifying the hardware flow table interface, the VPP can directly manipulate the hardware flow tables on the DPU, supporting complex traffic rule matching and dynamic updates of flow table entries, further improving the flexibility and efficiency of traffic management and forwarding policy configuration. By decoupling the hardware flow table interface, the maintainability and scalability of the system are enhanced, allowing for easy addition of new hardware features or optimization of existing functions as needed in the future.

[0129] According to some embodiments, the design scheme of the present invention can also be applied to the design of a DPU chip, wherein the DPU chip includes a processor and a memory, the memory stores a computer program, and when the processor runs the computer program stored in the memory, it implements the method described above, so that the DPU chip can offload the VPP data plane processing task to the DPU for execution, making full use of the hardware acceleration capability provided by the DPU, thereby greatly improving the processing speed and efficiency of data packets.

[0130] Figure 6 A schematic diagram of a DPU smart network interface card is shown according to an example embodiment.

[0131] According to some embodiments, see Figure 6 The design scheme of the present invention can also be applied to the design of DPU smart network card 300. The DPU smart network card 300 includes: the DPU chip 200 as described above and multiple interfaces 310. The DPU chip 200 communicates with the outside world through the multiple interfaces 310 to support complex traffic rule matching and dynamic updating of flow table entries, thereby further improving the flexibility and efficiency of traffic management and forwarding strategy configuration.

[0132] According to some embodiments, the design of the present invention, by employing the SR-IOV network device plugin, realizes the dynamic allocation and reclamation of physical network interface virtual function (VF) resources, improves resource utilization, and also ensures that each Pod or container can obtain an independent network interface, thereby enhancing resource isolation.

[0133] According to some embodiments, the design of this invention adapts to various related components in VPP, enabling it to seamlessly support complex network requirements in cloud-native environments. Combining Calico's network policy engine and VPP's powerful routing capabilities, it supports complex network requirements (such as support for BGP and OSPF protocols), providing fine-grained security rules and service chain configurations, suitable for the network function requirements of enterprise applications.

[0134] Figure 7 A block diagram of a cloud computing device according to an example embodiment is shown.

[0135] like Figure 7 As shown, the cloud computing device 30 includes a processor 12 and a memory 14. The cloud computing device 30 may also include a bus 22, a network interface 16, and an I / O interface 18. The processor 12, memory 14, network interface 16 (such as the aforementioned DPU smart network card), and I / O interface 18 can communicate with each other through the bus 22.

[0136] Processor 12 may include one or more general-purpose CPUs (Central Processing Units), microprocessors, or application-specific integrated circuits, for executing relevant program instructions. According to some embodiments, cloud computing device 30 may also include a high-performance display adapter (GPU) 20 for accelerating processor 12.

[0137] Memory 14 may include machine-readable media in the form of volatile memory, such as random access memory (RAM), read-only memory (ROM), and / or cache memory. Memory 14 is used to store one or more programs containing instructions and data. Cloud computing device 30 may also communicate with one or more networks via network interface 16. The DPU smart network card is used to process data or perform external communication, and the central processing unit is used to process data scheduled by the DPU smart network card. The DPU smart network card includes a network chip (such as a DPU chip). The network chip stores a computer program, which, when executed, implements the method according to embodiments of the present invention. Bus 22 may include an address bus, a data bus, a control bus, etc. Bus 22 provides a path for exchanging information between components.

[0138] The cloud computing device 30 can also communicate with one or more networks via network interface 16 (e.g., DPU network interface).

[0139] Bus 22 can include address bus, data bus, control bus, etc. Bus 22 provides a path for exchanging information between components.

[0140] It should be noted that, in specific implementations, the cloud computing device 30 may also include other components necessary for normal operation. Furthermore, those skilled in the art will understand that the device described above may only include the components necessary for implementing the embodiments of this specification, and not necessarily all the components shown in the figures.

[0141] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the above-described method. The computer-readable storage medium may include, but is not limited to, any type of disk, including floppy disks, optical disks, DVDs, CD-ROMs, microdrives, as well as magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic cards or optical cards, nanosystems (including molecular memory ICs), network storage devices, cloud storage devices, or any type of medium or device suitable for storing instructions and / or data.

[0142] This application also provides a computer program product including a non-transitory computer-readable storage medium storing a computer program operable to cause a computer to perform some or all of the steps of any of the methods described in the above method embodiments.

[0143] Those skilled in the art will clearly understand that the technical solutions of this application can be implemented using software and / or hardware. In this specification, "unit" and "module" refer to software and / or hardware capable of independently performing or cooperating with other components to perform a specific function, where the hardware may be, for example, a field-programmable gate array (FPGA), an integrated circuit, etc.

[0144] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0145] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0146] In the several embodiments provided in this application, it should be understood that the disclosed apparatus can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some service interface; the indirect coupling or communication connection between apparatuses or units may be electrical or other forms.

[0147] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0148] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0149] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage device. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a memory and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application.

[0150] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0151] The exemplary embodiments of this application have been specifically shown and described above. It should be understood that this application is not limited to the detailed structures, arrangements, or implementation methods described herein; rather, this application is intended to cover various modifications and equivalent arrangements contained within the spirit and scope of the appended provisions.< / devname> < / size> < / size> < / devname> < / devargs>

Claims

1. A method for interfacing and adapting worker node hosts and DPUs in a cloud computing cluster, characterized in that, The worker node host is connected to a smart network interface card (NIC), which has a Data Processing Unit (DPU). The worker node host runs a Kubernetes cluster agent, a multi-interface container network element plugin for Kubernetes clusters, a single-root I / O virtualization network device plugin, and a vector packet processing framework agent. The single-root I / O virtualization network device plugin manages the virtual functions of the smart NIC. The vector packet processing framework agent interacts with the vector packet processing framework offloaded to the DPU. The method is used on the worker node host and includes: The K8S cluster agent responds to the instructions from the control node host and calls the single root I / O virtualization network device plugin to allocate the first virtual function; The K8S cluster agent creates a first container group and assigns the first virtual function to the first container group; The K8S cluster agent calls the multi-interface container network element plugin through the vector packet processing framework agent to call the vector packet processing framework, and the vector packet processing framework creates a first interface device corresponding to the first virtual function; The vector data packet processing framework agent calls the DPU virtual resource management daemon to load and manage the first interface device; The multi-interface container network element plugin loads the virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group.

2. The method according to claim 1, characterized in that, The worker node host also runs a first container network interface plugin and a vector packet processing framework node container group integrated into the first container network interface plugin, the vector packet processing framework node container group including the vector packet processing framework agent. The K8S cluster agent invokes the multi-interface container network meta-plugin through the vector packet processing framework, which in turn invokes the vector packet processing framework. The vector packet processing framework creates a first interface device corresponding to the first virtual function, including: The multi-interface container network element plugin calls the first container network interface plugin to configure the first virtual function; The first container network interface plugin invokes the vector packet processing framework agent, thereby the vector packet processing framework agent invokes the vector packet processing framework.

3. The method according to claim 2, characterized in that, The multi-interface container network meta-plugin loads the virtualized network driver for the first virtual function and transfers the first interface device to the network space of the first container group, including: The first container network interface plugin loads a virtualized network driver for the first virtual function and associates the first interface device with the first virtual function, thereby enabling the first virtual function to communicate with the first interface device through a virtualized network protocol.

4. The method according to claim 1, characterized in that, The vector packet processing framework creates a first interface device corresponding to the first virtual function, including: The vector packet processing framework interfaces with the DPU's DPDK via a DPDK plugin and adds the first interface device through a device creation function.

5. The method according to claim 1, characterized in that, The vector packet processing framework agent communicates with the vector packet processing framework offloaded to the DPU via the TCP protocol.

6. A method for interfacing and adapting worker node hosts and DPUs in a cloud computing cluster, characterized in that, The worker node host is connected to a smart network interface card (NIC), which has a Data Processing Unit (DPU). The worker node host runs a K8S cluster agent, a multi-interface container network element plugin for K8S clusters, a single-root I / O virtualization network device plugin, and a vector packet processing framework agent. The single-root I / O virtualization network device plugin manages the virtual functions of the smart NIC, and the vector packet processing framework agent interacts with the vector packet processing framework offloaded to the DPU. The K8S cluster agent responds to the instructions from the control node host and calls the single root I / O virtualization network device plugin to allocate the first virtual function; The K8S cluster agent creates a first container group and assigns the first virtual function to the first container group; The method is used in the DPU, and the method includes: In response to the call of the vector packet processing framework agent, the vector packet processing framework creates a first interface device corresponding to the first virtual function; The DPU virtual resource management daemon loads and manages the first interface device, thereby enabling the first container network interface plugin to load the virtualized network driver for the first virtual function and associate the first interface device with the first virtual function.

7. The method according to claim 6, characterized in that, The vector packet processing framework replaces the DPDK plugin's data stream redirection to a queue with a data stream redirection to a port.

8. A DPU chip, comprising a processor and a memory, characterized in that, A computer program is stored in the memory, and when the processor runs the computer program stored in the memory, it implements the method as described in any one of claims 6 to 7.

9. A DPU smart network card, characterized in that, The DPU smart network card includes: the DPU chip according to claim 8 and multiple interfaces, wherein the DPU chip communicates externally through the multiple interfaces.

10. A cloud computing device, characterized in that, include: As described in claim 9, the DPU smart network card and central processing unit are used to process data or conduct external communication, and the central processing unit is used to process the data scheduled by the DPU smart network card.

Images