Container creation method, device, system, and storage medium

Abstract

Provided in the embodiments of the present disclosure are a container creation method, a device, a system, and a storage medium. In the embodiments of the present disclosure, the method comprises: in a cache pool of a storage cluster, pre-caching container instance snapshots and compiled drivers of parallel processing units, that is, caching executable files of the drivers; and during container creation, by means of an intranet, reading from the cache pool container mirror snapshots and the executable files of the drivers of the parallel processing units without the need of pulling container mirrors and drivers from a mirror repository by means of a public network. Therefore, on one hand, the present disclosure reduces downloading of mirror layers, thereby increasing the container creation speed; and on the other hand, the present disclosure directly acquires executable files of drivers such that the drivers do not need to be compiled and installed during instance creation so as to reduce time for driver compiling and installation, thus further improving the container creation speed. Raising the container creation speed helps to increase the container start-up speed.

Description

Container creation method, device, system and storage medium

[0001] Cross-reference

[0002] This disclosure claims priority to the Chinese patent application filed with the China Patent Office on August 16, 2023, application number 202311034259.3, and application name “Container creation method, device, system and storage medium”, the entire content of which is incorporated by reference into this disclosure. Technical Field

[0003] The present disclosure relates to the field of cloud computing technology, and in particular to a container creation method, device, system, and storage medium. Background Art

[0004] Serverless computing is a cloud computing model. Based on Platform as a Service (PaaS), Serverless provides a micro-architecture where end customers don't need to deploy, configure, or manage server services. Instead, the server services required to run code are provided by the cloud platform.

[0005] While Serverless offers high elasticity and flexibility, it also inevitably introduces the cold start problem. Because container instances are typically released after completing a request, when a request arrives, if there are no available instances, a new container instance must be started from scratch to handle the request. In other words, in a Serverless scenario, container instance startup is a cold start, requiring all resources, including the preparation of computing, storage, and network resources, as well as the pulling and creation of container images.

[0006] When a cold start occurs, the Serverless service platform must perform a series of operations, including instance scheduling, container image pull, instance creation, resource configuration, runtime environment initialization, and code loading. This process often results in latency that can be several times the actual execution time of the request. Therefore, accelerating container startup has become a pressing technical challenge in this field.

[0007] Summary of the Invention

[0008] Various aspects of the present disclosure provide a container creation method, device, system, and storage medium to increase container creation speed and thereby increase container startup speed.

[0009] In a first aspect, an embodiment of the present disclosure provides a container creation method applicable to a control node in a computing system, wherein the computing system is connected to an intranet of a storage cluster; the storage cluster is provided with a cache pool; cache objects in the cache pool include: a container image snapshot and a driver executable file; the driver is configured to drive a parallel processing unit;

[0010] The method comprises:

[0011] Get the container creation request;

[0012] Based on the container creation request, determining a target container image snapshot and a target driver that satisfy the container creation request from cache objects in the cache pool;

[0013] Controlling a computing node to obtain the target container image snapshot and the target driver executable file from the storage cluster; the computing node belongs to a computing cluster in the computing system;

[0014] Controlling the computing node to create a target container instance on a target parallel processing unit to which the computing node is communicatively connected based on the target container image snapshot;

[0015] The computing node is controlled to run the target driver in the target container instance based on the executable file of the target driver.

[0016] In a second aspect, an embodiment of the present disclosure further provides a container creation method, applicable to a computing node in a computing system, wherein the computing system is connected to an intranet of a storage cluster; the storage cluster is provided with a cache pool; the cache objects in the cache pool include: a container image snapshot and a driver executable file; the driver is configured to drive a parallel processing unit;

[0017] The method comprises:

[0018] Receiving an identifier of a target container image snapshot and an identifier of a target driver sent by a control node in the computing system; the target container image snapshot and the target driver satisfy the container creation request;

[0019] Based on the identifier of the target container image snapshot and the identifier of the target driver, obtaining the target container image snapshot and the executable file of the target driver from the cache pool;

[0020] Creating a target container instance on the target parallel processing unit based on the target container image snapshot;

[0021] Based on the executable file of the target driver, the target driver is run in the target container instance.

[0022] In a third aspect, an embodiment of the present disclosure further provides a container creation method, applicable to a control node in a computing system, wherein the computing system is connected to an intranet of a storage cluster; the storage cluster is provided with a cache pool; the cache objects in the cache pool include: a container image snapshot and an executable file of a graphics processing unit (GPU) driver; the GPU driver is configured to drive the GPU;

[0023] The method comprises:

[0024] Obtain a container creation request provided by a target application; the container creation request is set to request creation of a target container instance of a model training service or an image processing service required by the target application;

[0025] Based on the container creation request, determining a target container image snapshot and a target GPU driver that satisfy the container creation request from cache objects in the cache pool;

[0026] Controlling a computing node to obtain the target container image snapshot and the target GPU driver executable file from the storage cluster; the computing node belongs to a computing cluster in the computing system;

[0027] Controlling the computing node to create a target container instance on a target GPU to which the computing node is communicatively connected based on the target container image snapshot;

[0028] Control the computing node to run the target GPU driver in the target container instance based on the executable file of the target driver, so as to run the target container instance to provide the model training service or the image processing service to the target application.

[0029] In a fourth aspect, an embodiment of the present disclosure further provides a container creation method, applicable to a computing node in a computing system, wherein the computing system is connected to an intranet of a storage cluster; the storage cluster is provided with a cache pool; the cache objects in the cache pool include: a container image snapshot and an executable file of a graphics processing unit (GPU) driver; the GPU driver is configured to drive the GPU;

[0030] The method comprises:

[0031] Receiving an identifier of a target container image snapshot and an identifier of a target GPU driver sent by a control node in the computing system; the target container image snapshot and the target GPU driver satisfy a container creation request; the container creation request is configured to request creation of a target container instance for a model training service or an image processing service required by the target application;

[0032] Based on the identifier of the target container image snapshot and the identifier of the target GPU driver, obtaining the target container image snapshot and the executable file of the target GPU driver from the cache pool;

[0033] Based on the target container image snapshot, create a target container instance on the target GPU to which the computing node is communicatively connected;

[0034] Based on the executable file of the target GPU driver, the target GPU driver is run in the target container instance to run the target container instance to provide the model training service or the image processing service to the target application.

[0035] The present disclosure also provides a computing system comprising: a management and control node and a computing cluster; the computing system and the storage cluster communicate via an intranet; the computing cluster comprises: computing nodes; the computing nodes are in communication with a target parallel processing unit;

[0036] The storage cluster is provided with a cache pool; the cache objects in the cache pool include: a container image snapshot, a driver executable file, and a container instance snapshot; the driver is configured to drive a parallel processing unit; the container instance snapshot includes: a combination of the container image snapshot and the driver executable file;

[0037] The control node is configured to execute the steps of the container creation method provided in the first aspect and / or the third aspect above;

[0038] The computing node is configured to execute the steps in the container creation method provided in the second aspect and / or the fourth aspect.

[0039] In a fifth aspect, an embodiment of the present disclosure further provides a computing device, comprising: a memory and a processor; wherein the memory is configured to store a computer program;

[0040] The processor is coupled to the memory and configured to execute the computer program to perform the steps of the container creation method provided in the first aspect, the second aspect, the third aspect and / or the fourth aspect.

[0041] In a sixth aspect, an embodiment of the present disclosure further provides a computer-readable storage medium storing computer instructions. When the computer instructions are executed by one or more processors, the one or more processors are caused to execute the steps in the container creation method provided in the first, second, third and / or fourth aspects above.

[0042] In the embodiment of the present disclosure, the container instance snapshot and the compiled parallel processing unit driver are cached in advance in the cache pool of the storage cluster, that is, the cache driver executable file. When the container is created, the container image snapshot and the parallel processing unit driver executable file are read from the cache pool through the intranet, without the need to pull the container image and driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the driver executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the driver compilation and installation time and further improve the container creation speed. The increase in container creation speed helps to increase the container startup speed. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] The drawings described herein are used to provide a further understanding of the present disclosure and constitute a part of the present disclosure. The exemplary embodiments of the present disclosure and their descriptions are used to explain the present disclosure and do not constitute an improper limitation of the present disclosure. In the drawings:

[0044] FIG1 is a schematic diagram of the structure of a computing system provided by an embodiment of the present disclosure;

[0045] FIG2 is a schematic diagram of a cache object provided by an embodiment of the present disclosure;

[0046] FIG3 is a schematic diagram of a process for creating a cache object according to an embodiment of the present disclosure;

[0047] 4-7 are schematic flow diagrams of a container creation method according to an embodiment of the present disclosure;

[0048] FIG8 is a schematic diagram of the structure of a computing device provided in an embodiment of the present disclosure. DETAILED DESCRIPTION

[0049] To make the objectives, technical solutions, and advantages of the present disclosure more clear, the technical solutions of the present disclosure will be clearly and completely described below in conjunction with the specific embodiments of the present disclosure and the corresponding drawings. Obviously, the described embodiments are only part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments of the present disclosure, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present disclosure.

[0050] The inventors of this disclosure have discovered that during a cold start of a container instance, pulling container images is the primary bottleneck affecting the startup time, with the time it takes to pull container images ranging from a few seconds to several hours. In existing solutions, during a cold start of a container instance, container images are pulled from a cloud-based image repository, which takes a long time.

[0051] In some solutions, to improve the efficiency of Serverless services, heterogeneous resources are used to offload container instances to heterogeneous resource devices, which then run the container instances to provide computing services, thereby achieving the offloading of Serverless services. Heterogeneous resource devices refer to devices or components with computing resources other than central processing units (CPUs). These include graphics processing units (GPUs) and field-programmable gate arrays (FPGAs). This method of providing Serverless services by offloading heterogeneous resources can, on the one hand, accelerate services; on the other hand, by offloading container instances to heterogeneous resource devices, the CPU load of the device is reduced, reducing CPU resource consumption and helping to reduce the probability of CPU performance bottlenecks.

[0052] When offloading heterogeneous resources to container instances, compiling and installing the drivers for these resources is also very time-consuming, taking minutes from driver compilation to installation. Clearly, in Serverless scenarios where container instance startup speed is critical, these time-consuming constraints do not meet the latency requirements of Serverless.

[0053] In order to improve the container startup speed in the Serverless scenario, in some embodiments of the present disclosure, the container instance snapshot and the compiled parallel processing unit driver are pre-cached in the cache pool of the storage cluster, that is, the cache driver executable file. When the container is created, the container image snapshot and the parallel processing unit driver executable file are read from the cache pool through the intranet, without the need to pull the container image and driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the driver executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the driver compilation and installation time and further improve the container creation speed. The increase in container creation speed helps to improve the container startup speed.

[0054] The technical solutions provided by various embodiments of the present disclosure are described in detail below with reference to the accompanying drawings.

[0055] It should be noted that the same reference numerals denote the same objects in the following drawings and embodiments, and therefore, once an object is defined in one drawing or embodiment, it does not need to be further discussed in the subsequent drawings and embodiments.

[0056] Figure 1 is a schematic diagram of the computing system provided by an embodiment of the present disclosure. As shown in Figure 1 , computing system S10 includes a management and control node 10 and a computing cluster 20. Computing cluster 20 includes computing nodes 201. There are typically multiple computing nodes 201. Multiple refers to two or more.

[0057] Computing node 201 is communicatively connected to parallel processing unit 202. In this embodiment, computing node 201 can be any computer device with computing, storage, and communication capabilities, that is, a physical machine. For example, computing node 201 can be a server, a computer, a mobile phone, etc. Of course, computing node 201 can also be a virtual machine deployed on a physical machine.

[0058] In this embodiment, computing node 201 may include general processing units, etc. In this embodiment, the number of general processing units is not limited. There may be at least one general processing unit, i.e., one or more general processing units; each general processing unit may be a single-core processing unit or a multi-core processing unit.

[0059] In this embodiment, the general processing unit is generally a processing chip provided on the motherboard of the computing node 201, such as the CPU of the computing node 201 (not shown in the accompanying drawings), and single-machine expansion cannot be achieved. The general processing unit can be any processing device with processing computing capabilities. The general processing unit can be a serial processing unit or a parallel processing unit. For example, the general processing unit can be a general-purpose processor, such as a CPU. A parallel processing unit refers to a processing device that can perform parallel computing. For example, the parallel processing unit can be a graphics processing unit (GPU) or a field-programmable gate array (FPGA). Optionally, the memory of the general processing unit is greater than the memory of the parallel processing unit.

[0060] The parallel processing unit 202 is any device or apparatus with parallel computing capabilities, and can be a GPU or a programmable hardware device.

[0061] The programmable hardware device may be a hardware processor built by an electronic device, or a hardware processor that uses a hardware description language (HDL) for data processing. The hardware description language may be a very-high-speed integrated circuit hardware description language (VHDL), Verilog HDL, System Verilog, or System C. Accordingly, the parallel processing unit 202 may be an FPGA, a programmable array logic device (PAL), a general array logic device (GAL), a complex programmable logic device (CPLD), or the like. Alternatively, the parallel processing unit 202 may also be an application-specific integrated circuit (ASIC) or a data processing unit (DPU). The DPU is a dedicated electronic circuit with hardware acceleration capabilities, configured for data-centric computing.

[0062] In the present embodiment, the parallel processing unit 202 is communicatively connected with the computing node 201, specifically, the parallel processing unit 202 is communicatively connected with the CPU of the computing node 201. Specifically, the parallel processing unit 202 and the computing node 201 can be communicatively connected via a bus interface. Wherein, the bus interface can be a serial bus interface, such as a Peripheral Component Interconnect Express (PCIe) bus interface, a Peripheral Component Interconnect (PCI) bus interface, a Super Path Interconnect (UPI) bus interface, a Universal Serial Bus (USB) serial interface, an RS485 interface or an RS232 interface, etc. Preferably, the bus interface is a PCIe interface, which can improve the data transmission rate between the parallel processing unit 202 and the computing node 201.

[0063] The bus interface of the computing node 201 can be expanded according to the specifications of the physical machine corresponding to the computing node 201. Generally, the physical machine has multiple communication interfaces. "Multiple" in the embodiments of the present disclosure refers to more than one, that is, two or more. When the parallel processing unit 202 is communicatively connected to the computing node 201 through the bus interface, the parallel processing unit 202 may be one or more. The implementation forms of multiple parallel processing units 202 may be the same, or partially or completely different. For example, in some embodiments, the multiple parallel processing units 202 may all be FPGAs, or all may be DPUs, ASICs or GPUs, etc. In other embodiments, the multiple parallel processing units 202 may be partially FPGAs, partially DPUs, ASIC chips or GPUs, etc., but are not limited to this.

[0064] In some embodiments, parallel processing unit 202 and computing node 201 may be located on different physical machines, and computing node 201 and parallel processing unit 202 may be connected via a network. For example, computing node 201 and parallel processing unit 202 may be located on different cloud servers and connected via a network, etc. FIG1 illustrates computing node 201 and parallel processing unit 202 as being located on the same physical machine, but this is not intended to be limiting.

[0065] In this embodiment, the computing system S10 and the storage cluster S20 communicate via an intranet. The intranet can be a local area network (LAN), a virtual private cloud (VPC), or a virtual private network (VPN). This intranet communication between the computing system S10 and the storage cluster S20 can increase communication speed compared to public network communication, thereby increasing the speed at which the computing system S10 accesses the storage cluster S20.

[0066] In this embodiment, to reduce the CPU pressure on computing node 201 and lower the probability of the CPU reaching a performance bottleneck, computing node 201 can use virtualization technology to map parallel processing unit 202 to a virtual device of the computing node. Through the mapped virtual device, the container instance is offloaded to parallel processing unit 202. Due to its strong parallel computing capabilities, parallel processing unit 202 can increase the running speed of the application corresponding to the container instance.

[0067] In order for parallel processing unit 202 to operate, the container instance unloaded to parallel processing unit 202 must also be installed with the driver of parallel processing unit 202. The driver of parallel processing unit 202 refers to a computer program that drives parallel processing unit 202. It is the software corresponding to the hardware and is configured to drive the parallel processing unit. In each embodiment of the present disclosure, the driver refers to the driver of the parallel processing unit. For example, if the parallel processing unit is a GPU, the driver is the GPU driver.

[0068] Since the parallel processing unit unloads the container instance and accelerates the operation of the application corresponding to the container instance, the speed of container startup is mainly limited by the pulling of the container image of the container instance and the compilation and installation of the driver of the parallel processing unit. Therefore, in order to achieve accelerated container startup, the present embodiment provides a container image cache and a pre-installation function of the driver of the parallel processing unit. The container image to be used can be made into a container image snapshot in advance and stored in the storage cluster S20. When creating a container instance, the container instance can be created based on the container image snapshot, avoiding or reducing the download of the image layer, improving the creation speed of the container instance, and then improving the container startup speed. On the other hand, the driver to be used is cached in advance, and the driver is compiled and installed in advance to obtain the executable file of the driver. In this way, after the container instance is created, the driver can be run in the container instance to further improve the container startup speed.

[0069] Based on the above analysis, in this embodiment, as shown in FIG2 , a cache pool can be set in the storage cluster S20. The cache objects in the cache pool may include: container image snapshots and driver executable files. Among them, the driver refers to the driver of the parallel processing unit. The container image snapshot and the driver executable file can be stored in the cache pool in an independent form; of course, the container image snapshot and the driver executable file can also be stored in the cache pool in the form of a container instance snapshot. Among them, the container instance snapshot includes a combination of the container image snapshot and the driver executable file. The container image snapshot is stored in the cache pool in an independent form and the driver executable file is stored in the cache pool in an independent form, both compared to the storage in the cache pool in the form of a container instance snapshot. Among them, the container image snapshot mainly refers to the container image snapshot stored in the cache pool as an independent file. The driver executable file is stored in the cache pool in an independent form, which mainly refers to the driver executable file being stored in the cache pool as an independent file.

[0070] A container image is a lightweight, executable, standalone software package used to package a software runtime environment and software developed based on it. It contains everything required to run a piece of software, including code, runtime, libraries, environment variables, and configuration files. A container image snapshot is a copy of a container image. Container images can be general-purpose or user-defined, known as custom container images. General-purpose container images are provided by the cloud service platform and are available to all users. Custom container images are hosted by users on the cloud service platform and are only available to the user who provided the custom container image. Container image snapshots are categorized into general-purpose and custom container image snapshots. General-purpose container image snapshots are snapshots of general container images and are available to all users; custom container image snapshots are snapshots of custom container images and are only available to the user who provided the custom container image.

[0071] Users can also customize system configuration information. System configuration information refers to the kernel information that containers rely on for operation, including but not limited to kernel version information and memory parameter information. Some custom container image snapshots are compatible with general system configuration information, while others have special kernel information requirements, requiring users to provide customized system configuration information. General system configuration information refers to the system configuration information provided by the cloud service platform based on general container images. It can be compatible with general container image snapshots as well as custom container image snapshots that do not have special system configuration information requirements.

[0072] In this embodiment, the driver of the parallel processing unit carries system configuration information, which includes user-defined system configuration information and general system configuration information.

[0073] Based on the custom container image snapshot and the universal container image snapshot, the cache objects in the cache pool may include the following scenarios: (1) a driver carrying custom system configuration information; (2) a driver carrying universal system configuration information; (3) a combination of a driver carrying custom system configuration information and a container image snapshot; (4) a combination of a driver carrying a universal container image and a universal container image snapshot; (5) a custom container image snapshot, etc.

[0074] The aforementioned drivers that carry custom system configuration information can only be used in conjunction with custom container image snapshots and are only available to users who provide custom container images. The combination of drivers that carry custom system configuration information and container image snapshots can only be used by users who provide custom system configuration information.

[0075] Accordingly, in some embodiments, the management and control node 10 may provide a configuration interface for container images and system configuration information, such as an application programming interface (API). Based on the configuration interface for container images and system configuration information, users can independently configure the container image and system configuration information to obtain a customized container image and customized system configuration information. Accordingly, the management and control node 10 can obtain the customized container image and customized system configuration information provided through the configuration interface.

[0076] In this embodiment, the control node 10 can create a cache object. Specifically, as shown in Figure 3, the control node 10 can obtain a container image to be cached and a driver to be cached. The container image to be cached can be one or more. "More than one" means two or more. The container image to be cached can include both general-purpose and custom container images.

[0077] Drivers to be cached may include drivers carrying general system configuration information or drivers carrying customized system configuration information. There may be one or more drivers to be cached. "Multiple" means two or more. There may also be one or more drivers carrying general system configuration information. Of course, there may also be one or more drivers carrying customized system configuration information.

[0078] In this embodiment, the specific implementation method for the control node 10 to obtain the container image to be cached and the driver to be cached is not limited. In some embodiments, the container image to be cached may be a hot container image, that is, a container image that is frequently used within a period of time. It can be defined as a container image whose usage frequency within a set time period meets a set frequency requirement. The set frequency requirement can be: usage frequency greater than or equal to a set frequency threshold; it can also be: maximum usage frequency, etc., but is not limited to these.

[0079] Accordingly, the management and control node 10 can obtain the historical usage data of the container image in the image repository within the set historical time period; the historical time period is the same time period as the prediction time window within the set scheduling period. The prediction time window is a time window set to predict the hot container image for a period of time in the future. For example, the current time is 8:00 on July 3, 2023, and the prediction time window is the next hour (i.e., 8:00-9:00), then the scheduling period can be set to 1 day, and the same time period within the scheduling period is set to 8:00-9:00 every day. Accordingly, the historical time period is the historical 8:00-9:00, such as 8:00-9:00 every day in the last week, 2 weeks, one month, or 2 months from the current time. For another example, if the prediction time window is Tuesday of this week, then the scheduling period can be set to 1 week, and the same time period within the scheduling period can be set to every Tuesday. Accordingly, the historical time period can be the past Tuesday, such as every Tuesday in the last 1 month, 2 months, or 3 months from the current time.

[0080] Based on the historical usage data of the container images in the image repository within the set historical time period, the management and control node 10 can determine the hot container images within the predicted time window from the container images in the image repository as the container images to be cached.

[0081] In some embodiments, the control node 10 can use big data statistical methods to identify hot container images. Specifically, the control node 10 can determine the usage frequency of container images in the image repository within a historical period based on the historical usage data of the container images in the image repository within that period. The control node 10 can then select hot container images from the container images in the image repository whose usage frequency meets the set frequency requirement as the container images to be cached.

[0082] In other embodiments, in order to improve the accuracy of determining the hotspot container image, a neural network model can be introduced. In the embodiments of the present disclosure, the specific implementation form of the neural network model is not limited. Optionally, the neural network model can be a convolutional neural network (CNN), a deep learning neural network (DNN), a recurrent neural network (RNN), or a convolutional neural tensor network (CNTN), etc. Alternatively, the neural network model can also be a classification model, such as a random forest model, a gradient boosting decision tree (GBDT), or a boosting tree model (XGBoost), etc., but is not limited thereto.

[0083] A neural network model is configured to predict hot container images, defined as a hot container image prediction model. The hot container image prediction model is trained using historical usage data of container image samples pre-labeled with hot and cold identifiers. This historical usage data includes, but is not limited to, the usage time and identifier of the container image sample. When used online, the hot container image prediction model can take as input the historical usage data of the container image and output the hot / cold classification of the container image, i.e., whether the container image is a hot container image or a cold container image.

[0084] In this embodiment, minimizing the loss function is used as the training objective, and historical usage data of container image samples pre-labeled with hot and cold labels is used as training samples. The initial model corresponding to the hot container image prediction model is trained to obtain the hot container image prediction model. The loss function is determined by the difference between the predicted hot and cold labels of the container image samples output by the model training and the pre-labeled hot and cold labels of the container image samples. For example, in some embodiments, the loss function can be implemented as the mean square error, variance, or standard deviation between the predicted hot and cold labels of the container image samples output by the model and the pre-labeled hot and cold labels of the container image samples.

[0085] In some embodiments, assuming that the container image sample is a hot container image, the hot and cold flags are pre-marked as 1; if the container image sample is a cold container image, the hot and cold flags are pre-marked as 0. The loss function can be expressed as:

[0086] Wherein, in the above formula (1), N represents the total number of container image samples, and i represents the i-th container image sample. i = 1, 2, ..., N. p i represents the pre-labeled hot and cold labels of the i-th container image sample, p i Equal to 0 or 1. Indicates the value corresponding to the predicted hot and cold flag of the i-th container image sample, which is generally any value between 0 and 1.

[0087] The implementation forms of the loss functions shown in the above embodiments are for illustrative purposes only and do not constitute a limitation.

[0088] Based on the trained hot container image prediction model, the management and control node 10 can use the hot container image prediction model to perform hot container image prediction on the historical usage data of the container images in the image repository within the historical time period, so as to determine the hot container images of the container images in the image repository within the prediction time window as the container images to be cached.

[0089] Specifically, the management and control node 10 can use the hot container image prediction model to perform hot container image prediction on the historical usage data of the container images in the image repository within the historical time period to determine the hot and cold identifiers of each container image in the image repository; according to the hot and cold identifiers of each container image in the image repository, select the container image with the hot identifier as the hot identifier from the image repository, that is, the hot container image, as the container image to be cached.

[0090] In some embodiments, the historical usage data of the container image may further include the driver running on the container instance corresponding to the container image. Accordingly, the management and control node 10 may further obtain the driver running on the container instance corresponding to the container image to be cached during the historical time period from the historical usage data of the container image to be cached during the historical time period as the driver to be cached.

[0091] The above embodiments of obtaining the container image to be cached and the driver to be cached are for illustrative purposes only and are not intended to be limiting.

[0092] For the driver to be cached, the control node 10 can compile the driver to be cached to obtain the executable file of the driver to be cached. Specifically, the driver to be cached is compiled into assembly language; further, the assembly language can be translated into target machine language; and each segment contained in the target machine language is written into the segment position corresponding to the relocatable file; thereafter, the name, relative address and size of each segment contained in the target machine language are written into the segment header of the relocatable file, thereby obtaining the relocatable file of the driver to be cached. Furthermore, the relocatable file can be linked to obtain the information segment of the executable file. Furthermore, the information segment of the executable file can be relocated from the relative address to the absolute address to obtain the executable file of the driver to be cached.

[0093] For container images and drivers to be cached, you can store them independently as cache objects in the cache pool, or you can store the executable files of the drivers independently as cache objects in the cache pool. Alternatively, you can combine the container images and the executable files of the drivers to be cached as cache objects and store them in the cache pool.

[0094] In an embodiment where a combination of a container image to be cached and an executable file of a driver to be cached is stored as a cache object in a cache pool, the management node 10 may create a container instance based on the container image to be cached, install the executable file of the driver to be cached in the container instance, and then store a snapshot of the container instance with the executable file of the driver to be cached installed as a cache object in the cache pool. The snapshot of the container instance with the executable file of the driver to be cached installed is referred to as a container instance snapshot, and includes a combination of the container image snapshot corresponding to the container instance and the executable file of the driver running in the container instance.

[0095] The above embodiment exemplifies the process of making cache objects, but does not constitute a limitation. In the embodiment of the present disclosure, in addition to providing a method for making cache objects, dynamic updates of cache objects can also be supported. Specifically, the management and control node 10 can also monitor the usage of cache objects in the cache pool; if there are cache objects in the cache pool that have not been used within a set period of time after the predicted time window is reached, the cache objects that have not been used within the set period of time are deleted from the cache pool to achieve automatic elimination of non-hotspot cache objects, ensure the smallest possible cache quantity, and help to accelerate the startup of containers across the entire network.

[0096] Based on the cache objects in the above-mentioned cache pool, the embodiment of the present disclosure provides a container creation method based on the cache object. This method can read the container image snapshot and the executable file of the driver of the parallel processing unit from the storage cluster through the intranet. Compared with the traditional solution of pulling the container image and driver from the image warehouse through the public network, it reduces the download of the image layer and can speed up the container creation speed. On the other hand, in the traditional solution, during the container startup process, the driver is compiled and installed on the parallel processing unit, while the present disclosure can obtain the driver's executable file directly from the cache pool through the intranet, without the need to compile and install the driver, which can reduce the driver's compilation and installation time and further improve the container startup speed.

[0097] Specifically, as shown in Figure 1, the user terminal 30 can send a container creation request to the management and control node 10 according to its own needs (corresponding to step 1 in Figure 1). Specifically, the target application of the user terminal 30 can be set to request the creation of a container instance that provides the required services. The services required by the target application include but are not limited to: data processing services, video services, and online education services. Data processing services can be model (neural network model) training services or image processing services, etc. The management and control node 10 can determine the target container image snapshot and target driver that meet the container creation request from the cache objects in the cache pool based on the container creation request (corresponding to step 2 in Figure 1).

[0098] In some embodiments, the user can specify the container image to be used through the user terminal 30. Accordingly, the container creation request may include: the container image identifier to be used. The container image identifier is the identifier of the target container image snapshot. Accordingly, the management and control node 10 can obtain the identifier of the target container image snapshot from the container creation request; and use the identifier of the target container image snapshot to match the cache objects stored in the cache pool to determine the target cache object containing the target container image snapshot. Among them, the target cache object can be one or more. Multiple means two or more. The target cache object may include a container image snapshot stored in an independent form, and may also include a container instance snapshot.

[0099] If the target cache object is a container instance snapshot, the target driver can be determined from the container instance snapshot identified as the target cache object. Specifically, in some embodiments, the user can specify the driver type and version information requested, and the container creation request can include the driver type and version information requested. Accordingly, the driver type and version information requested can be obtained from the container creation request; and a driver whose driver type and version information are consistent with the driver type and version information requested can be determined from the container instance snapshot identified as the target cache object as the target driver.

[0100] In some embodiments, the default driver type and version information can be pre-set. If the driver type and version information are not included in the container creation request, the management node 10 can select a driver with a default driver type and default version information from the container instance snapshot determined as the target cache object as the target driver.

[0101] In other embodiments, a driver usage priority, i.e., a driver priority, may be pre-configured. Accordingly, if the container creation request does not include driver type and version information, the management node 10 may select the driver with the highest driver priority from the container instance snapshots identified as the target cache object according to the pre-configured driver priority as the target driver.

[0102] In some embodiments, the target cache object is a target container image snapshot. In some embodiments, the user can specify the driver type and version information requested, and the container creation request may include the requested driver type and version information. Accordingly, the management node 10 can obtain the requested driver type and version information from the container creation request; and from the drivers stored independently in the cache pool, determine the driver whose driver type and version information are consistent with the requested driver type and version information, and use it as the target driver.

[0103] Alternatively, the default driver type and version information may be pre-set. Then, when the driver type and version information are not included in the container creation request, the management node 10 may select a driver whose driver type is the default driver type and whose version information is the default version information from the drivers stored in an independent form in the cache pool as the target driver.

[0104] In other embodiments, a driver usage priority, i.e., a driver priority, may be pre-configured. Accordingly, if the container creation request does not include driver type and version information, the management node 10 may select the driver with the highest driver priority from the independently stored drivers in the cache pool according to the pre-configured driver priority as the target driver.

[0105] The above embodiments illustrate specific implementations for determining the target container image snapshot and target driver that satisfy a container creation request, but do not constitute a limitation. In summary, the disclosed embodiments can automatically select the appropriate container image snapshot and parallel processing unit driver for the container creation request from cache objects in the cache pool based on the container image request. Throughout this process, the user only needs to specify the container image to be used, and the entire selection process is invisible to the user.

[0106] After determining the target container image snapshot and the target driver of the parallel processing unit, the control node 10 may provide the identifier of the target container image snapshot and the identifier of the target driver to the computing node 201 (corresponding to step 3 of FIG. 1 ).

[0107] The computing node 201 can obtain the target container image snapshot and the target driver's executable file from the cache pool of the storage cluster S20 based on the identifier of the target container image snapshot and the identifier of the target driver (corresponding to step 4 in Figure 1); further, based on the target container image snapshot, a target container instance can be created on the target parallel processing unit 202 to which the computing node 201 is communicatively connected; and based on the target driver's executable file, the target driver can be run in the target container instance (corresponding to step 5 in Figure 1).

[0108] Furthermore, the target parallel processing unit 202 may run a target container instance to provide required services to the target application, such as a model training service or an image processing service.

[0109] In this embodiment, the container instance snapshot and the compiled parallel processing unit driver are cached in advance in the cache pool of the storage cluster, that is, the executable file of the cache driver is cached. When the container is created, the container image snapshot and the executable file of the parallel processing unit driver are read from the cache pool through the intranet, without the need to pull the container image and driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the driver executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the compilation and installation time of the driver and further improve the container creation speed. In short, the embodiment of the present disclosure decouples the container image pulling time and the parallel processing unit driver compilation and installation time from the Serverless container cold start time, which can achieve container startup acceleration in the Serverless scenario.

[0110] Furthermore, since container instances provide a sandbox environment, data between users of the container instance is isolated, ensuring data security. In the above embodiment, the cache pool does not restrict the format of the container image and can support caching of container images of various formats, regardless of the container image format.

[0111] In the embodiment of the present disclosure, in addition to providing a method for accelerating container creation, cache pool upgrades are also supported. Accordingly, the management and control node 10 can monitor cache upgrade events for the cache pool. In the embodiment of the present disclosure, the specific implementation form of the cache upgrade event is not limited. In some embodiments, the cache upgrade event can be implemented as an upgrade or update of the cache object. Accordingly, when the management and control node 10 detects the occurrence of a cache update event for the cache pool, it can determine the cache object to be upgraded from the cache pool according to the set grayscale ratio; based on the cache upgrade event, the cache object to be upgraded is cache upgraded.

[0112] In addition to the above system embodiment, the embodiment of the present disclosure also provides a container creation method. The container creation method provided by the embodiment of the present disclosure is exemplarily described below.

[0113] FIG4 is a flow chart of a container creation method according to an embodiment of the present disclosure. As shown in FIG4 , the container creation method mainly includes:

[0114] 401. Get container creation request.

[0115] 402. Based on the container creation request, determine the target container image snapshot and target driver that meet the container creation request from the cache objects in the cache pool.

[0116] 403. Control the computing node to obtain the target container image snapshot and the target driver executable file from the storage cluster; the computing node belongs to the computing cluster in the computing system.

[0117] 404. The control computing node creates a target container instance on a target parallel processing unit to which the computing node is communicatively connected based on the target container image snapshot.

[0118] 405. The control computing node runs the target driver in the target container instance based on the executable file of the target driver.

[0119] The above container creation method is primarily applicable to control nodes in a computing system. The computing system includes a control node and a computing cluster. The computing cluster includes compute nodes. The compute nodes are communicatively connected to parallel processing units (PPUs). For a description of the implementation and connection methods of the control node, compute nodes, and PPUs, please refer to the relevant content of the above system embodiments and will not be repeated here.

[0120] In this embodiment, the computing system and the storage cluster communicate via an intranet, which can increase the communication speed compared to communicating via a public network, thereby increasing the speed at which the computing system accesses the storage cluster.

[0121] In this embodiment, to reduce the workload on the compute nodes and lower the probability of CPU performance bottlenecks, the compute nodes can use virtualization technology to map parallel processing units (PPUs) into virtual devices within the compute nodes. Through these mapped virtual devices, container instances are offloaded to the PPUs. Due to their strong parallel computing capabilities, the PPUs can increase the speed of applications corresponding to the container instances.

[0122] In order for the parallel processing unit to operate, the container instance unloaded to the parallel processing unit must also be installed with the driver of the parallel processing unit. Since the parallel processing unit unloads the container instance and accelerates the operation of the application corresponding to the container instance, the speed of container startup is mainly limited by the pulling of the container image of the container instance and the compilation and installation of the driver of the parallel processing unit. Therefore, in order to achieve accelerated container startup, this embodiment provides a container image cache and a pre-installation function of the driver of the parallel processing unit. The container image to be used can be made into a container image snapshot in advance and stored in a storage cluster. When creating a container instance, the container instance can be created based on the container image snapshot, avoiding or reducing the download of the image layer, improving the creation speed of the container instance, and thus improving the container startup speed. On the other hand, the driver to be used is pre-cached, and the driver is pre-compiled and installed to obtain the executable file of the driver. In this way, after the container instance is created, the driver can be run in the container instance, further improving the container startup speed.

[0123] Based on the above analysis, a cache pool can be set up in the storage cluster. The cached objects in this cache pool may include: container image snapshots and driver executable files. Drivers refer to drivers for parallel processing units. Container image snapshots and driver executable files can be stored in the cache pool independently or as container instance snapshots. Container instance snapshots include a combination of container image snapshots and driver executable files.

[0124] A container image snapshot is a copy of a container image. A container image can be either a generic container image or a user-defined container image, known as a custom container image. Accordingly, container image snapshots can be categorized as generic container image snapshots or custom container image snapshots.

[0125] Users can also customize system configuration information. Some custom container image snapshots are compatible with general system configuration information, while others have special kernel information requirements, requiring users to provide customized system configuration information. General system configuration information refers to the system configuration information provided by the cloud service platform based on general container images. It can be compatible with general container image snapshots or custom container image snapshots that do not have special system configuration information requirements.

[0126] In this embodiment, the driver of the parallel processing unit carries system configuration information, which includes user-defined system configuration information and general system configuration information.

[0127] Based on the custom container image snapshot and the universal container image snapshot, the cache objects in the cache pool may include the following scenarios: (1) a driver carrying custom system configuration information; (2) a driver carrying universal system configuration information; (3) a combination of a driver carrying custom system configuration information and a container image snapshot; (4) a combination of a driver carrying a universal container image and a universal container image snapshot; (5) a custom container image snapshot, etc.

[0128] The aforementioned drivers that carry custom system configuration information can only be used in conjunction with custom container image snapshots and are only available to users who provide custom container images. The combination of drivers that carry custom system configuration information and container image snapshots can only be used by users who provide custom system configuration information.

[0129] Accordingly, in some embodiments, a configuration interface, such as an API, may be provided for container images and system configuration information. Based on the configuration interface for container images and system configuration information, users can independently configure the container image and system configuration information to obtain a customized container image and customized system configuration information. Accordingly, the customized container image and customized system configuration information provided through the configuration interface can be obtained.

[0130] In this embodiment, the control node can create a cache object. Specifically, it can obtain the container image to be cached and the driver to be cached. The container image to be cached can be one or more. "More than one" means two or more. The container image to be cached can include both general-purpose and custom container images.

[0131] Drivers to be cached may include drivers carrying general system configuration information or drivers carrying customized system configuration information. There may be one or more drivers to be cached. "Multiple" means two or more. There may also be one or more drivers carrying general system configuration information. Of course, there may also be one or more drivers carrying customized system configuration information.

[0132] In this embodiment, the specific implementation method for obtaining the container image to be cached and the driver to be cached is not limited. In some embodiments, the container image to be cached may be a hot container image, that is, a container image that is frequently used within a period of time. It can be defined as a container image whose usage frequency within a set time period meets a set frequency requirement. The set frequency requirement can be: usage frequency greater than or equal to a set frequency threshold; it can also be: maximum usage frequency, etc., but is not limited to these.

[0133] Accordingly, historical usage data for container images in the image repository within a set historical time period can be obtained; the historical time period is the same period as the predicted time window within the set scheduling cycle. Based on the historical usage data for container images in the image repository within the set historical time period, hot container images within the predicted time window can be determined from the container images in the image repository as the container images to be cached.

[0134] In some embodiments, a big data statistical method can be used to identify hot container images. Specifically, the usage frequency of container images in the image repository over a historical period can be determined based on the historical usage data of the container images in the image repository over a historical period. Hot container images whose usage frequency meets a set frequency requirement can then be selected from the container images in the image repository as the container images to be cached.

[0135] In other embodiments, a neural network model may be introduced to improve the accuracy of determining hotspot container images. The specific implementation of the neural network model can be found in the above embodiments and will not be further described here.

[0136] A neural network model is configured to predict hot container images, defined as a hot container image prediction model. The hot container image prediction model is trained using historical usage data of container image samples pre-labeled with hot and cold identifiers. The historical usage data of container image samples includes, but is not limited to, the usage time and identifier of the container image samples. When used online, the hot container image prediction model can be fed with historical usage data of container images and historical wakeup behavior data for virtual machines. The output is a hot or cold classification of the container image, i.e., whether the container image is a hot container image or a cold container image.

[0137] In this embodiment, minimizing the loss function is the training objective. Historical usage data of container image samples pre-labeled with hot and cold labels is used as training samples to train the initial model corresponding to the hot container image prediction model, thereby obtaining the hot container image prediction model. The loss function is determined by the difference between the predicted hot and cold labels of the container image samples output by the model training and the pre-labeled hot and cold labels of the container image samples. For the representation of the loss function, please refer to the relevant content of the above embodiment and will not be repeated here.

[0138] Based on the trained hot container image prediction model, the hot container image prediction model can be used to predict hot container images based on the historical usage data of the container images in the image repository within the historical time period, so as to determine the hot container images of the container images in the image repository within the prediction time window as the container images to be cached.

[0139] Specifically, the hot container image prediction model can be used to predict hot container images based on the historical usage data of container images in the image repository within a historical time period, so as to determine the hot and cold identifiers of each container image in the image repository; based on the hot and cold identifiers of each container image in the image repository, the container image with the hot identifier as the cold and hot identifier is selected from the image repository, that is, the hot container image, as the container image to be cached.

[0140] In some embodiments, the historical usage data of the container image may further include the driver running on the container instance corresponding to the container image. Accordingly, the driver running on the container instance corresponding to the container image to be cached during the historical time period may be obtained from the historical usage data of the container image to be cached during the historical time period as the driver to be cached.

[0141] The above embodiments of obtaining the container image to be cached and the driver to be cached are for illustrative purposes only and are not intended to be limiting.

[0142] For the driver to be cached, the driver to be cached can be compiled to obtain the executable file of the driver to be cached. Specifically, the driver to be cached is compiled into assembly language; further, the assembly language can be translated into target machine language; and each segment contained in the target machine language is written into the segment position corresponding to the relocatable file; thereafter, the name, relative address and size of each segment contained in the target machine language is written into the segment header of the relocatable file, thereby obtaining the relocatable file of the driver to be cached. Furthermore, the relocatable file can be linked to obtain the information segment of the executable file. Furthermore, the information segment of the executable file can be relocated from the relative address to the absolute address to obtain the executable file of the driver to be cached.

[0143] For container images and drivers to be cached, you can store them independently as cache objects in the cache pool, or you can store the executable files of the drivers independently as cache objects in the cache pool. Alternatively, you can combine the container images and the executable files of the drivers to be cached as cache objects and store them in the cache pool.

[0144] In an embodiment where a combination of a container image to be cached and an executable file of a driver to be cached is stored as a cache object in a cache pool, a container instance may be created based on the container image to be cached, and the executable file of the driver to be cached may be installed in the container instance. Subsequently, a snapshot of the container instance with the executable file of the driver to be cached installed may be stored as a cache object in the cache pool. The snapshot of the container instance with the executable file of the driver to be cached installed may be referred to as a container instance snapshot, and includes: a snapshot of the container image corresponding to the container instance and the executable file of the driver running in the container instance.

[0145] The above embodiment exemplifies the process of making cache objects, but does not constitute a limitation. In the embodiment of the present disclosure, in addition to providing a method for making cache objects, dynamic updates of cache objects can also be supported. Specifically, the usage of cache objects in the cache pool can also be monitored; if there are cache objects in the cache pool that have not been used within a set period of time after the predicted time window is reached, the cache objects that have not been used within the set period of time are deleted from the cache pool to achieve automatic elimination of non-hotspot cache objects, ensuring the smallest possible cache quantity, and helping to accelerate the startup of containers across the entire network.

[0146] Based on the cache objects in the above-mentioned cache pool, the embodiment of the present disclosure provides a container creation method based on cache objects. This method can read the container image snapshot and the executable file of the driver of the parallel processing unit from the storage cluster through the intranet, without having to pull the container image and driver from the image warehouse through the public network. On the one hand, it reduces the download of the image layer and speeds up the container creation speed; on the other hand, it directly obtains the executable file of the driver without the need to compile and install the driver, which can reduce the compilation and installation time of the driver and further improve the container startup speed.

[0147] Specifically, the user can send a container creation request to the computing system based on its needs. Accordingly, in step 401, the container creation request can be obtained. And in step 402, based on the container creation request, the target container image snapshot and target driver that meet the container creation request are determined from the cache objects in the cache pool.

[0148] In some embodiments, the user can specify the container image to be used through the user terminal. Accordingly, the container creation request may include: the container image identifier to be used. The container image identifier is the identifier of the target container image snapshot. Accordingly, step 402 can be implemented as: obtaining the identifier of the target container image snapshot from the container creation request; and using the identifier of the target container image snapshot, matching the cache objects stored in the cache pool to determine the target cache object containing the target container image snapshot. Among them, the target cache object can be one or more. Multiple means two or more. The target cache object may include a container image snapshot stored in an independent form, and may also include a container instance snapshot.

[0149] If the target cache object is a container instance snapshot, the target driver can be determined from the container instance snapshot identified as the target cache object. Specifically, in some embodiments, the user can specify the driver type and version information requested, and the container creation request can include the driver type and version information requested. Accordingly, the driver type and version information requested can be obtained from the container creation request; and a driver whose driver type and version information are consistent with the driver type and version information requested can be determined from the container instance snapshot identified as the target cache object as the target driver.

[0150] In some embodiments, the default driver type and version information can be pre-set. If the driver type and version information are not included in the container creation request, a driver with a default driver type and default version information can be selected as the target driver from the container instance snapshot determined as the target cache object.

[0151] In other embodiments, a driver usage priority, i.e., a driver priority, may be pre-configured. Accordingly, if the container creation request does not include driver type and version information, the driver with the highest driver priority may be selected as the target driver from the container instance snapshot identified as the target cache object according to the pre-configured driver priority.

[0152] In some embodiments, the target cache object is a target container image snapshot. In some embodiments, the user can specify the driver type and version information requested, and the container creation request can include the driver type and version information requested. Accordingly, the driver type and version information requested can be obtained from the container creation request; and from the drivers stored in a separate form in the cache pool, a driver whose driver type and version information are consistent with the driver type and version information requested can be determined as the target driver.

[0153] Alternatively, the default driver type and version information may be pre-set. Then, if the driver type and version information are not included in the container creation request, a driver having a default driver type and a default version information may be selected from the drivers stored in an independent form in the cache pool as the target driver.

[0154] In other embodiments, a driver usage priority, i.e., a driver priority, may be pre-configured. Accordingly, if the container creation request does not include driver type and version information, the driver with the highest driver priority may be selected from the independently stored drivers in the cache pool according to the pre-configured driver priority and used as the target driver.

[0155] The above embodiments illustrate specific implementations for determining the target container image snapshot and target driver that satisfy a container creation request, but do not constitute a limitation. In summary, the disclosed embodiments can automatically select the appropriate container image snapshot and parallel processing unit driver for the container creation request from cache objects in the cache pool based on the container image request. Throughout this process, the user only needs to specify the container image to be used, and the entire selection process is invisible to the user.

[0156] After determining the target container image snapshot and the target driver for the parallel processing unit, in step 403, the computing node may be controlled to obtain the target container image snapshot and the executable file of the target driver from the cache pool of the storage cluster. Specifically, the identifier of the target container image snapshot and the identifier of the target driver may be provided to the computing node. Based on the identifier of the target container image snapshot and the identifier of the target driver, the computing node may obtain the target container image snapshot and the executable file of the target driver from the cache pool of the storage cluster S20.

[0157] Further, in step 404, the computing node can be controlled to create a target container instance on the target parallel processing unit to which the computing node is communicatively connected based on the target container image snapshot; and in step 405, the target driver is run in the target container instance based on the executable file of the target driver to obtain the target container instance.

[0158] In this embodiment, the container instance snapshot and the compiled parallel processing unit driver are cached in advance in the cache pool of the storage cluster, that is, the executable file of the cache driver is cached. When the container is created, the container image snapshot and the executable file of the parallel processing unit driver are read from the cache pool through the intranet, without the need to pull the container image and driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the driver executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the compilation and installation time of the driver and further improve the container creation speed. In short, the embodiment of the present disclosure decouples the container image pulling time and the parallel processing unit driver compilation and installation time from the Serverless container cold start time, which can achieve container startup acceleration in the Serverless scenario.

[0159] Furthermore, since container instances provide a sandbox environment, data between users of the container instance is isolated, ensuring data security. In the above embodiment, the cache pool does not restrict the format of the container image and can support caching of container images of various formats, regardless of the container image format.

[0160] In the embodiment of the present disclosure, in addition to providing a method for accelerating container creation, cache pool upgrades are also supported. Accordingly, cache upgrade events for the cache pool can be monitored. In the embodiment of the present disclosure, the specific implementation form of the cache upgrade event is not limited. In some embodiments, the cache upgrade event can be implemented as an upgrade or update of the cache object. Accordingly, when a cache update event for the cache pool is detected, the cache object to be upgraded can be determined from the cache pool according to the set grayscale ratio; based on the cache upgrade event, the cache object to be upgraded is cache upgraded.

[0161] Accordingly, for a computing node, the container creation method can be implemented as shown in Figure 5. As shown in Figure 5, the container creation method mainly includes:

[0162] 501. Receive an identifier of a target container image snapshot and an identifier of a target driver sent by a control node in a computing system; the target container image snapshot and the target driver satisfy a container creation request.

[0163] 502. Based on the identifier of the target container image snapshot and the identifier of the target driver, obtain the target container image snapshot and the executable file of the target driver from the cache pool.

[0164] 503. Create a target container instance on the target parallel processing unit based on the target container image snapshot.

[0165] 504. Based on the executable file of the target driver, run the target driver in the target container instance.

[0166] Regarding the specific implementation method of the control node determining the identifier of the target container image snapshot and the identifier of the target driver, please refer to the relevant content of the above embodiment and will not be repeated here. In this embodiment, the container instance snapshot and the compiled parallel processing unit driver are cached in advance in the cache pool of the storage cluster, that is, the cache driver executable file. When the container is created, the computing node can read the container image snapshot and the executable file of the parallel processing unit driver from the cache pool through the intranet, without having to pull the container image and driver from the image warehouse through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the computing node can directly obtain the driver executable file, without the need to compile and install the driver during the instance creation process, which can reduce the driver compilation and installation time and further improve the container creation speed. The increase in container creation speed helps to increase the container startup speed.

[0167] The container creation method provided in the embodiments of the present disclosure can be applied to create container instances for services required by any application. The following example illustrates a scenario where the target application requires a model training service or an image processing service, and the parallel processing unit is a GPU.

[0168] For the control node provided in the above embodiment, the container creation method can be implemented as the container creation method shown in Figure 6. Specifically, the cache objects in the cache pool include: a container image snapshot and an executable file of a GPU driver; the GPU driver is configured to drive the GPU. In this embodiment, the container image snapshot cached by the cache pool includes a container image snapshot of a container instance that provides the service required by the target application. In this embodiment, the service required by the target application is a model training service or an image processing service. Regarding the production process of the cache objects in the cache pool, please refer to the relevant content of the above embodiment and will not be repeated here.

[0169] As shown in Figure 6, the container creation method mainly includes:

[0170] 601. Obtain a container creation request provided by a target application; the container creation request is set to request creation of a target container instance of a model training service or an image processing service required by the target application.

[0171] 602. Based on the container creation request, determine the target container image snapshot and target GPU driver that meet the container creation request from the cache objects in the cache pool;

[0172] 603. Control the computing node to obtain a target container image snapshot and an executable file of a target GPU driver from the storage cluster; the computing node belongs to a computing cluster in the computing system.

[0173] 604. Control the computing node to create a target container instance on a target GPU to which the computing node is communicatively connected based on the target container image snapshot.

[0174] 605. The control computing node runs the target GPU driver in the target container instance based on the executable file of the target driver, so as to run the target container instance to provide model training services or image processing services to the target application.

[0175] Accordingly, for a computing node, the container creation method can be implemented as shown in Figure 7. As shown in Figure 7, the container creation method mainly includes:

[0176] 701. Receive the identifier of the target container image snapshot and the identifier of the target GPU driver sent by the control node in the computing system; the target container image snapshot and the target GPU driver satisfy the container creation request; the container creation request is set to request the creation of a target container instance for the model training service or image processing service required by the target application.

[0177] 702. Based on the identifier of the target container image snapshot and the identifier of the target GPU driver, obtain the target container image snapshot and the executable file of the target GPU driver from the cache pool.

[0178] 703. Based on the target container image snapshot, create a target container instance on the target GPU to which the computing node is connected.

[0179] 704. Based on the executable file of the target GPU driver, run the target GPU driver in the target container instance to run the target container instance to provide model training services or image processing services to the target application.

[0180] In the above embodiment, the target application is an upper-layer application of the control node, which can be an application deployed on a user terminal or, of course, on other computing devices, such as a computing node. In this embodiment, when the target application requires a service, it can request the computing system to create and start a target container instance that provides that service; the target container instance then runs to provide the relevant service. In this embodiment, the service required by the target application is a model training service or an image processing service.

[0181] In this embodiment, the container instance snapshot and the compiled GPU driver that provide the services required by the target application are pre-cached in the cache pool of the storage cluster, that is, the GPU driver executable file is cached. When the container is created, the container image snapshot and the parallel processing unit driver executable file can be read from the cache pool through the intranet, without having to pull the container image and GPU driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the GPU driver executable file can be directly obtained, and there is no need to compile and install the GPU driver during the instance creation process, which can reduce the compilation and installation time of the GPU driver and further improve the container creation speed. The increase in container creation speed helps to increase the container startup speed.

[0182] In this embodiment, a target container instance can be run on a target GPU to provide model training services or image processing services to a target application.

[0183] It should be noted that the execution entity of each step of the method provided in the above embodiment can be the same device, or the method can be executed by different devices. For example, the execution entity of steps 401 and 402 can be device A; for another example, the execution entity of step 401 can be device A, and the execution entity of step 402 can be device B; and so on.

[0184] In addition, some of the processes described in the above embodiments and the accompanying drawings include multiple operations that appear in a specific order. However, it should be clearly understood that these operations may not be executed in the order in which they appear in this document or may be executed in parallel. The sequence numbers of the operations, such as 401 and 402, are used to distinguish different operations and do not represent any execution order. In addition, these processes may include more or fewer operations, and these operations may be executed sequentially or in parallel.

[0185] Accordingly, an embodiment of the present disclosure further provides a computer-readable storage medium storing computer instructions. When the computer instructions are executed by one or more processors, the one or more processors are caused to execute the steps in the above-mentioned container creation method.

[0186] Figure 8 is a schematic diagram of the structure of a computing device provided by an embodiment of the present disclosure. The computing device can be implemented as a control node in a computing system, which is connected to the intranet of a storage cluster. The storage cluster is provided with a cache pool. The cache objects in the cache pool include: container image snapshots and driver executable files. The driver is configured to drive a parallel processing unit.

[0187] As shown in Figure 8, the computing device mainly includes a memory 80a and a processor 80b. The memory 80a is configured to store computer programs.

[0188] The processor 80b is coupled to the memory 80a and is configured to execute a computer program for: obtaining a container creation request; determining, based on the container creation request, a target container image snapshot and a target driver that satisfy the container creation request from cache objects in a cache pool; controlling, through a communication component 80c, a computing node to obtain the target container image snapshot and an executable file of the target driver from a storage cluster; the computing node belongs to a computing cluster in a computing system; and controlling, through the communication component 80c, the computing node to create a target container instance on a target parallel processing unit to which the computing node is communicatively connected based on the target container image snapshot; and controlling the computing node to run the target driver in the target container instance based on the executable file of the target driver.

[0189] In some embodiments, the container image snapshot and the driver's executable file are stored in a cache pool in an independent form; and / or, the container image snapshot and the driver's executable file are stored in the cache pool in the form of a container instance snapshot. When the processor 80b determines the target container image snapshot and the target driver that meet the container creation request from the cache objects of the cache pool set in the storage cluster connected to the intranet based on the container creation request, it is specifically configured to: obtain the identifier of the target container image snapshot from the container creation request; use the identifier of the target container image snapshot to match the cache objects stored in the cache pool to determine the target cache object containing the target container image snapshot; if the target cache object is a container instance snapshot, determine the target driver from the container instance snapshot determined as the target cache object.

[0190] Furthermore, when the processor 80b determines the target driver from the container instance snapshot determined as the target cache object, it is specifically configured to: obtain the type and version information of the driver used in the request from the container creation request; determine, from the container instance snapshot determined as the target cache object, a driver whose driver type and version information are consistent with the type and version information of the driver used in the request as the target driver; or, from the container instance snapshot determined as the target cache object, select a driver whose driver type is a default driver type and whose version information is default version information as the target driver; or, according to a pre-configured driver priority, select a driver with the highest driver priority from the container instance snapshot determined as the target cache object as the target driver.

[0191] Accordingly, the processor 80b is further configured to: if the target cache object is a target container image snapshot, obtain the type and version information of the driver used in the request from the container creation request; determine, from the drivers stored in an independent form in the cache pool, a driver whose driver type and version information are consistent with the type and version information of the driver used in the request as the target driver; or, from the drivers stored in an independent form in the cache pool, select a driver whose driver type is a default driver type and whose version information is default version information as the target driver; or, according to a pre-configured driver priority, select a driver with the highest driver priority from the drivers stored in an independent form in the cache pool as the target driver.

[0192] In some embodiments, the processor 80b is further configured to: obtain a container image to be cached and a driver to be cached; the container image to be cached includes a snapshot of a target container image; the driver to be cached includes: a target driver; compile the driver to be cached to obtain an executable file of the driver to be cached; create a container instance based on the container image to be cached, and install the executable file of the driver to be cached in the container instance; store the snapshot of the container instance with the executable file of the driver to be cached as a container instance snapshot in the cache pool; and store the snapshot of the container image to be cached as a cache object in the cache pool in an independent form; and store the executable file of the driver to be cached as a cache object in the cache pool in an independent form.

[0193] Optionally, when the processor 80b obtains the container image to be cached and the driver to be cached, it is specifically configured to: obtain historical usage data of the container image in the image repository within a set historical time period; the historical time period is the same period as the prediction time window within the set scheduling cycle; based on the historical usage data of the container image in the image repository within the historical time period, determine the hot container image within the prediction time window from the container images in the image repository as the container image to be cached; wherein the hot container image refers to a container image whose usage frequency meets the set frequency requirement; from the historical usage data of the container image to be cached within the historical time period, obtain the driver running the container instance corresponding to the container image to be cached within the historical time period as the driver to be cached.

[0194] Furthermore, when the processor 80b determines the hot container image within the prediction time window from the container images in the image repository based on the historical usage data of the container images in the image repository within the historical time period, the processor 80b is specifically configured to: determine the usage frequency of the container images in the image repository within the historical time period based on the historical usage data of the container images in the image repository within the historical time period; and select, from the container images in the image repository, a container image whose usage frequency meets the set frequency requirement as the hot container image; or, use a hot container image prediction model to perform hot container image prediction on the historical usage data of the container images in the image repository within the historical time period to determine the hot container image of the container images in the image repository within the prediction time window as the container image to be cached.

[0195] Among them, the hot container image prediction model is trained with the minimization of the loss function as the training goal, and is trained using the historical usage data of container image samples pre-labeled with hot and cold labels as training samples; the loss function is determined by the difference between the predicted hot and cold labels of the container image samples output by the model training and the hot and cold labels pre-labeled on the container image samples.

[0196] Optionally, the processor 80b is further configured to: monitor the usage of the cache objects in the cache pool; if there are cache objects that have not been used within a set time period after the predicted time window is reached, delete the cache objects that have not been used within the set time period from the cache pool.

[0197] Optionally, the processor 80b is further configured to: monitor cache upgrade events for the cache pool; when a cache update event for the cache pool is detected, determine the cache object to be upgraded from the cache pool according to a set grayscale ratio; and perform a cache upgrade on the cache object to be upgraded based on the cache upgrade event.

[0198] In some embodiments, the parallel processing unit is a GPU, and the driver is a GPU driver. The GPU driver is configured to drive the GPU. The processor 80b may also be configured to: obtain a container creation request provided by a target application; the container creation request is configured to request the creation of a target container instance for a model training service or an image processing service required by the target application; based on the container creation request, determine a target container image snapshot and a target GPU driver that satisfy the container creation request from a cache object in a cache pool; control the computing node to obtain the target container image snapshot and the executable file of the target GPU driver from a storage cluster; the computing node belongs to a computing cluster in a computing system; control the computing node to create a target container instance on a target GPU to which the computing node is communicatively connected based on the target container image snapshot; control the computing node to run the target GPU driver in the target container instance based on the executable file of the target driver, so as to run the target container instance to provide the model training service or image processing service to the target application.

[0199] In some embodiments of the present disclosure, the computing device may also be implemented as a computing node in a computing cluster. Accordingly, the processor 80b may be configured to: receive, via the communication component 80c, the identifier of the target container image snapshot and the identifier of the target driver sent by the control node in the computing system; the target container image snapshot and the target driver satisfy the container creation request; based on the identifier of the target container image snapshot and the identifier of the target driver, obtain the executable file of the target container image snapshot and the target driver from the cache pool; based on the target container image snapshot, create a target container instance on the target parallel processing unit to which the computing device is communicatively connected; based on the executable file of the target driver, run the target driver in the target container instance.

[0200] In some embodiments, the parallel processing unit is a GPU, and the driver is a GPU driver. The GPU driver is configured to drive the GPU. The processor 80b may also be configured to: receive, through the communication component 80c, an identifier of a target container image snapshot and an identifier of a target driver sent by a control node in the computing system; the target container image snapshot and the target driver satisfy a container creation request; the container creation request is configured to request the creation of a target container instance for a model training service or an image processing service required by a target application; based on the identifier of the target container image snapshot and the identifier of the target driver, obtain the executable file of the target container image snapshot and the target driver from a cache pool; based on the target container image snapshot, create a target container instance on a target GPU to which the computing device is communicatively connected; based on the executable file of the target driver, run the target driver in the target container instance to run the target container instance to provide a model training service or an image processing service to the target application.

[0201] In some optional embodiments, as shown in FIG8 , the computing device may further include components such as a power supply component 80d. In some embodiments, the computing device may be implemented as a terminal device such as a computer or workstation. Accordingly, the computing device may further include components such as a display component 80e and an audio component 80f. The schematic illustration of some components in FIG8 does not imply that the computing device must include all components shown in FIG8 , nor does it imply that the computing device must include only the components shown in FIG8 .

[0202] In this embodiment, the container instance snapshot and the compiled parallel processing unit driver are pre-cached in the cache pool of the storage cluster, that is, the cache driver executable file. When the container is created, the container image snapshot and the parallel processing unit driver executable file are read from the cache pool through the intranet, without having to pull the container image and driver from the image repository through the public network. On the one hand, this reduces the download of the image layer and can speed up the container creation speed; on the other hand, the driver executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the driver compilation and installation time and further improve the container creation speed. The increase in container creation speed helps to increase the container startup speed.

[0203] In an embodiment of the present disclosure, a memory is configured to store a computer program and may be configured to store various other data to support operations on the device where it is located. The processor may execute the computer program stored in the memory to implement corresponding control logic. The memory may be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as a static random-access memory (SRAM), an electrically erasable programmable read-only memory (EEPROM), an erasable programmable read-only memory (EPROM), a programmable read-only memory (PROM), a read-only memory (ROM), a magnetic memory, a flash memory, a magnetic disk, or an optical disk.

[0204] In the embodiments of the present disclosure, the processor may be any hardware processing device that can execute the logic of the above method. Optionally, the processor may be a central processing unit (CPU), a graphics processing unit (GPU), or a microcontroller unit (MCU); or a programmable device such as a field programmable gate array (FPGA), a programmable array logic device (PAL), a general array logic device (GAL), a complex programmable logic device (CPLD); or an application specific integrated circuit (ASIC) chip; or an advanced reduced instruction set (RISC) processor (Advanced RISC Machines, ARM) or a system on chip (SoC), etc., but not limited thereto.

[0205] In an embodiment of the present disclosure, the communication component is configured to facilitate wired or wireless communication between the device in which it is located and other devices. The device in which the communication component is located can access a wireless network based on a communication standard, such as Wireless Fidelity (WiFi), 2G or 3G, 4G, 5G or a combination thereof. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast-related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component can also be based on Near Field Communication (NFC) technology, Radio Frequency Identification (RFID) technology, Infrared Data Association (IrDA) technology, Ultra Wide Band (UWB) technology, Bluetooth (BT) technology or other technologies.

[0206] In an embodiment of the present disclosure, the display component may include a liquid crystal display (LCD) and a touch panel (TP). If the display component includes a touch panel, the display component may be implemented as a touch screen to receive input signals from a user. The touch panel includes one or more touch sensors to sense touches, slides, and gestures on the touch panel. The touch sensor may not sense the boundaries of a touch or slide action, but may also detect the duration and pressure associated with the touch or slide operation.

[0207] In an embodiment of the present disclosure, a power supply component is configured to provide power to various components of the device in which it is located. The power supply component may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power to the device in which the power supply component is located.

[0208] In an embodiment of the present disclosure, the audio component may be configured to output and / or input audio signals. For example, the audio component includes a microphone (MIC), and when the device where the audio component is located is in an operating mode, such as a call mode, a recording mode, and a voice recognition mode, the microphone is configured to receive an external audio signal. The received audio signal may be further stored in a memory or sent via a communication component. In some embodiments, the audio component further includes a speaker configured to output an audio signal. For example, for a device with a language interaction function, voice interaction with a user may be achieved through the audio component.

[0209] It should be noted that 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, stored data, displayed data, etc.) involved in this disclosure are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0210] It should also be noted that the descriptions such as "first" and "second" in this article are used to distinguish different messages, devices, modules, etc., and do not represent the order of precedence, nor do they limit "first" and "second" to different types.

[0211] Those skilled in the art will appreciate that the embodiments of the present disclosure may be provided as methods, systems, or computer program products. Therefore, the present disclosure may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Furthermore, the present disclosure may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, compact disc read-only memory (CD-ROM), optical storage, etc.) containing computer-usable program code.

[0212] The present disclosure is described with reference to the flowcharts and / or block diagrams of the methods, devices (or systems), and computer program products according to embodiments of the present disclosure. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device produce a device configured to implement the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0213] These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a product including an instruction device that implements the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0214] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide steps configured to implement the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0215] In a typical configuration, a computing device includes one or more processors (such as a CPU, etc.), input / output interfaces, network interfaces, and memory.

[0216] Memory may include non-permanent storage in a computer-readable medium, random-access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0217] Computer storage media is readable storage media, also known as readable media. Readable storage media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random-access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be configured to store information that can be accessed by a computing device. According to the definition in this article, computer-readable media does not include temporary computer-readable media (transitory media), such as modulated data signals and carrier waves.

[0218] It should also be noted that the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, commodity, or apparatus comprising a list of elements does not include those elements, but also includes other elements not explicitly listed, or also includes elements inherent to such process, method, commodity, or apparatus. In the absence of further limitations, the elements defined by the phrase "comprising a..." do not exclude the presence of other identical elements in the process, method, commodity, or apparatus comprising the aforementioned elements.

[0219] The above contents are merely examples of the present disclosure and are not intended to limit the present disclosure. Various modifications and variations are possible for those skilled in the art. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present disclosure are intended to be included within the scope of the claims of the present disclosure. Industrial Applicability

[0220] The disclosed embodiments propose a container creation method, device, system and storage medium, which can pre-cache the container instance snapshot and the compiled parallel processing unit driver in the cache pool of the storage cluster, that is, cache the driver's executable file. When the container is created, the container image snapshot and the parallel processing unit driver's executable file are read from the cache pool through the intranet, without the need to pull the container image and driver from the image repository through the public network. On the one hand, the download of the image layer is reduced, which can speed up the container creation speed; on the other hand, the driver's executable file is directly obtained, and there is no need to compile and install the driver during the instance creation process, which can reduce the driver's compilation and installation time and further improve the container creation speed. The increase in container creation speed helps to increase the container startup speed.

Claims

1. A container creation method, applicable to a management and control node in a computing system, wherein: The computing system is connected to the storage cluster intranet; the storage cluster is provided with a cache pool; The cache objects in the cache pool include: container image snapshots and driver executable files; the driver is configured as a driver parallel processing unit; The method comprises: Get the container creation request; Based on the container creation request, determining a target container image snapshot and a target driver that satisfy the container creation request from cache objects in the cache pool; Controlling a computing node to obtain the target container image snapshot and the executable file of the target driver from the storage cluster; the computing node belongs to a computing cluster in the computing system; Controlling the computing node to create a target container instance on a target parallel processing unit to which the computing node is communicatively connected based on the target container image snapshot; The computing node is controlled to run the target driver in the target container instance based on the executable file of the target driver.

2. The method according to claim 1, wherein: The container image snapshot and the driver executable file are stored in the cache pool in an independent form; And / or, the container image snapshot and the executable file of the driver are stored in the cache pool in the form of the container instance snapshot; The determining, based on the container creation request, from the cache objects in the cache pool, a target container image snapshot and a target driver that satisfy the container creation request includes: Obtaining an identifier of the target container image snapshot from the container creation request; Using the identifier of the target container image snapshot, matching is performed in the cache objects stored in the cache pool to determine a target cache object containing the target container image snapshot; If the target cache object is a container instance snapshot, the target driver is determined from the container instance snapshot determined as the target cache object.

3. The method according to claim 2, wherein: The step of determining the target driver from the container instance snapshot determined as the target cache object includes: Acquire the type and version information of the driver used in the request from the container creation request; determine, from the container instance snapshot determined as the target cache object, a driver whose driver type and version information are consistent with the type and version information of the driver used in the request as the target driver; or, From the container instance snapshot determined as the target cache object, select a driver whose driver type is a default driver type and whose version information is a default version information as the target driver; or, According to the pre-configured driver priority, a driver with the highest driver priority is selected from the container instance snapshot determined as the target cache object as the target driver.

4. The method according to claim 2, wherein: Also includes: If the target cache object is a target container image snapshot stored in an independent form, from the container creation request, Obtaining the type and version information of the driver used in the request; determining, from the drivers cached in the cache pool in an independent form, a driver whose driver type and version information are consistent with the type and version information of the driver used in the request as the target driver; or, From the drivers cached in the cache pool in an independent form, select a driver whose driver type is a default driver type and whose version information is a default version information as the target driver; or, According to the pre-configured driver priorities, a driver with the highest driver priority is selected from the drivers cached in the cache pool in an independent form as the target driver.

5. The method according to claim 1, wherein: Also includes: Get the container image and driver to be cached; The container image to be cached includes the target container image snapshot; The driver to be cached includes: the target driver; Compiling the driver to be cached to obtain an executable file of the driver to be cached; Based on the container image to be cached, create a container instance, and install the executable file of the driver to be cached in the container instance; Using a snapshot of the container instance in which the executable file of the driver to be cached is installed as the container instance snapshot, and storing it in the cache pool; And, storing the snapshot of the container image to be cached as a cache object in the cache pool in an independent form; The executable file of the driver to be cached is taken as a cache object and stored in the cache pool in an independent form.

6. The method according to claim 5, wherein: The obtaining of the container image to be cached and the driver to be cached includes: Obtain historical usage data of container images in the image repository within a set historical time period; the historical time period is the same period as the prediction time window within the set scheduling cycle; According to the historical usage data of the container images in the image repository within the historical time period, determine the hot container images within the predicted time window from the container images in the image repository as the container images to be cached; wherein the hot container images refer to container images whose usage frequency meets the set frequency requirements; A driver running on a container instance corresponding to the container image to be cached in the historical time period is obtained from historical usage data of the container image to be cached in the historical time period as the driver to be cached.

7. The method according to claim 6, wherein: The determining, from the container images in the image warehouse according to the historical usage data of the container images in the image warehouse during the historical time period, the hotspot container images within the predicted time window includes: Determine the usage frequency of the container images in the image repository within the historical time period according to the historical usage data of the container images in the image repository within the historical time period; and select, from the container images in the image repository, a container image whose usage frequency meets the set frequency requirement as the hotspot container image; or, Using a hot container image prediction model, perform hot container image prediction on historical usage data of container images in the image repository within the historical time period to determine hot container images of container images in the image repository within the prediction time window as the container images to be cached; Among them, the hot container image prediction model is trained with the minimization of the loss function as the training goal, and the historical usage data of container image samples pre-labeled with hot and cold identifications are used as training samples; the loss function is determined by the difference between the predicted hot and cold identifications of the container image samples output by the model training and the hot and cold identifications pre-labeled by the container image samples.

8. The method according to claim 6, wherein: Also includes: Monitoring usage of cache objects in the cache pool; If there is a cache object that has not been used within a set time period after the predicted time window is reached, the cache object that has not been used within the set time period is deleted from the cache pool.

9. The method according to any one of claims 1 to 8, wherein: Also includes: Monitoring cache upgrade events for the cache pool; When a cache update event for the cache pool is detected, a cache object to be upgraded is determined from the cache pool according to a set grayscale ratio; Based on the cache upgrade event, the cache object to be upgraded is cache upgraded.

10. A container creation method, applicable to a computing node in a computing system, wherein: The computing system is connected to the storage cluster intranet; the storage cluster is provided with a cache pool; The cache objects in the cache pool include: container image snapshots and driver executable files; the driver is configured as a driver parallel processing unit; The method comprises: Receiving an identifier of a target container image snapshot and an identifier of a target driver sent by a control node in the computing system; the target container image snapshot and the target driver satisfy the container creation request; Based on the identifier of the target container image snapshot and the identifier of the target driver, obtaining the target container image snapshot and the executable file of the target driver from the cache pool; Based on the target container image snapshot, create a target container instance on a target parallel processing unit communicatively connected to the computing node; Based on the executable file of the target driver, the target driver is run in the target container instance.

11. A container creation method, applicable to a management and control node in a computing system, wherein: The computing system is connected to the storage cluster intranet; the storage cluster is provided with a cache pool; The cache objects in the cache pool include: container image snapshots and executable files of a graphics processing unit (GPU) driver; the GPU driver is configured to drive the GPU; The method comprises: Obtain a container creation request provided by a target application; the container creation request is set to request creation of a target container instance of a model training service or an image processing service required by the target application; Based on the container creation request, determining a target container image snapshot and a target GPU driver that satisfy the container creation request from cache objects in the cache pool; Control the computing node to obtain the target container image snapshot and the target GPU driver from the storage cluster executable file; the computing node belongs to a computing cluster in the computing system; Control the computing node to create a target container instance on a target GPU to which the computing node is communicatively connected based on the target container image snapshot; The computing node is controlled to run the target GPU driver in the target container instance based on the executable file of the target driver, so as to run the target container instance to provide the model training service or the image processing service to the target application.

12. A container creation method, applicable to a computing node in a computing system, wherein: The computing system is connected to the storage cluster intranet; the storage cluster is provided with a cache pool; The cache objects in the cache pool include: container image snapshots and executable files of a graphics processing unit (GPU) driver; the GPU driver is configured to drive the GPU; The method comprises: Receiving an identifier of a target container image snapshot and an identifier of a target GPU driver sent by a control node in the computing system; the target container image snapshot and the target GPU driver satisfy a container creation request; the container creation request is set to request creation of a target container instance of a model training service or an image processing service required by the target application; Based on the identifier of the target container image snapshot and the identifier of the target driver, obtaining the target container image snapshot and the executable file of the target GPU driver from the cache pool; Based on the target container image snapshot, create a target container instance on a target GPU to which the computing node is communicatively connected; Based on the executable file of the target GPU driver, the target GPU driver is run in the target container instance to run the target container instance to provide the model training service or the image processing service to the target application.

13. A computing system comprising: Manage and control nodes and computing clusters; The computing system and storage cluster communicate via the intranet; The computing cluster includes: computing nodes; the computing nodes are communicatively connected with the target parallel processing units; The storage cluster is provided with a cache pool; the cache objects in the cache pool include: container image snapshots and driver executable files; the driver is configured as a driver parallel processing unit; The control node is configured to execute the steps of the method according to any one of claims 1 to 9 or 11; The computing node is configured to execute the steps in the method of claim 10 or 12.

14. A computing device comprising: A memory and a processor; wherein the memory is configured to store a computer program; The processor is coupled to the memory and is configured to execute the computer program to perform the steps of the method according to any one of claims 1 to 12.

15. A computer-readable storage medium storing computer instructions, which, when executed by one or more processors, causes the one or more processors to execute the steps of the method according to any one of claims 1 to 12.

Images