CN108205481B

CN108205481B - Application container instance creation method and device

Info

Publication number: CN108205481B
Application number: CN201611178866.7A
Authority: CN
Inventors: 刘宏; 夏海
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2016-12-19
Filing date: 2016-12-19
Publication date: 2022-03-08
Anticipated expiration: 2036-12-19
Also published as: CN108205481A

Abstract

The embodiment of the invention provides a method and a device for creating an applied container instance, wherein the method comprises the following steps: the method comprises the steps that an arrangement scheduler receives an application media package, wherein the application media package comprises an application container mirror image file and an application arrangement description file, and the application arrangement description file is used for indicating that the number of container instances of an application needing to be created is N; respectively sending mirror image pushing instructions to the N servers according to the application arrangement description file, wherein the mirror image pushing instructions comprise container mirror image files of the application, and the mirror image pushing instructions are used for indicating the container mirror image files of the storage application; when the container instances of the applications need to be created, creating instructions are sent to the N servers respectively, and the creating instructions are used for indicating that the container instances of the applications are created according to the stored container image files of the applications. The deployment efficiency of the container instance is improved, the starting speed of the container is improved, and the overall reliability of the container image file is enhanced.

Description

Application container instance creation method and device

Technical Field

The embodiment of the invention relates to the technical field of application containers, in particular to a method and a device for creating an application container instance.

Background

In recent years, the container technology and related tools thereof have the defects that the platform is very explosive, and more typical container engines comprise container management platforms such as docker, socket, kubernets, swam and the like. Under the existing mechanism, a container mirror image warehouse is independently deployed, a user uploads a locally manufactured mirror image file to the container mirror image warehouse through a container command, all container mirror image files are stored in the container mirror image warehouse in a centralized mode, when a server needs to create a container instance of an application, the server needs to pull the container mirror image file of the application from the container mirror image warehouse to the local, and after the container mirror image file is stored in the local, the container instance of the application is created through the mirror image. However, in the prior art, when a container instance is created, the container instance is created only after the container image file is pulled from the remote container image repository, which causes the container instance creating inefficiency.

Disclosure of Invention

The embodiment of the invention provides a container instance creating method and device for an application, which are used for improving the deployment efficiency of creating container instances.

In a first aspect, an embodiment of the present invention provides a method for creating a container instance of an application, including:

the method comprises the steps that an arrangement scheduler receives an application media package, wherein the application media package comprises an application container mirror image file and an application arrangement description file, and the application arrangement description file is used for indicating that the number of container instances of an application needing to be created is N; n is an integer greater than or equal to 1; the arrangement scheduler sends mirror image pushing instructions to the N servers respectively according to the application arrangement description files, wherein the mirror image pushing instructions comprise container mirror images of the applications, and the mirror image pushing instructions are used for indicating the container mirror images of the applications to be stored; when the container instance of the application needs to be created, the scheduling scheduler sends creation instructions to the N servers respectively, wherein the creation instructions are used for instructing the creation of the container instance of the application according to the stored container image file of the application.

Optionally, after the arrangement scheduler sends the mirror image pushing instructions to the N servers respectively according to the application arrangement description file, the arrangement scheduler further determines M servers that back up the container mirror image file of the application, where M is an integer greater than or equal to 1; and respectively sending the mirror image pushing instruction to the M servers.

Optionally, when the number of the container instances of the application increases, the orchestration scheduler further receives an address query instruction sent by a server creating the newly added container instance of the application, where the address query instruction is used for querying an address of a server storing an image file of the application; and sending an address response instruction to the server which creates the newly added container instance of the application, wherein the address response instruction comprises the address of one server in the N servers.

In a second aspect, an embodiment of the present invention provides a method for creating a container instance of an application, including: the first server receives a mirror image pushing instruction sent by the arrangement scheduler, wherein the mirror image pushing instruction comprises a container mirror image file of the first application, and the mirror image pushing instruction is used for indicating the container mirror image file storing the first application; storing a container mirror image file of the first application according to the mirror image pushing instruction; when a container instance of a first application needs to be created, a first server receives a creation instruction sent by an orchestration scheduler, wherein the creation instruction is used for indicating that the container instance of the first application is created according to a stored container image file of the first application; and the first server creates a container instance of the first application according to the creation instruction and the stored container image file of the first application.

Optionally, the first server also shuts down the container instance of the first application when the number of container instances of the first application needs to be reduced.

Optionally, when the number of container instances of the first application increases, the first server further receives a first image pull instruction sent by the second server, where the first image pull instruction is used to pull a container image file of the first application; the second server is a server for creating a container instance of the newly added first application; and the first server returns the container image file of the first application to the second server according to the first image pulling instruction.

Optionally, when the first server needs to create the container instance of the second application, and when the container image file of the second application is stored in the first server, the first server further creates the container instance of the second application according to the stored container image file of the second application.

Optionally, when the first server needs to create a container instance of the second application and when the first server does not store the container image file of the second application, the first server further sends an address query instruction to the orchestration scheduler, where the address query instruction is used to query an address of a server storing the container image file of the second application; the first server receives an address response instruction sent by the arrangement scheduler, wherein the address response instruction comprises an address of a third server, and the third server is a server storing a container mirror image file of a second application; the first server sends a second mirror image pulling instruction to the third server according to the address response instruction, wherein the second mirror image pulling instruction is used for pulling a container mirror image file of the second application; the first server receives a container mirror image file of the second application returned by the third server; the first server creates a container instance of the second application according to the container image file of the second application.

Optionally, the first server further obtains an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; when the occupancy rate is larger than a first threshold value, the first server cleans the storage space according to a preset rule, and the preset rule is used for indicating to clean the unused container image file within a preset time.

Optionally, when the occupancy rate of the cleaning storage space to the storage space is less than a second threshold, the first server stops cleaning the storage space.

In a third aspect, an embodiment of the present invention provides an orchestration scheduler, including: the system comprises a receiving module, a creating module and a creating module, wherein the receiving module is used for receiving an application media package, the application media package comprises an application container mirror image file and an application layout description file, and the application layout description file is used for indicating that the number of container instances of an application needing to be created is N; n is an integer greater than or equal to 1; the sending module is used for respectively sending mirror image pushing instructions to the N servers according to the application arrangement description files, wherein the mirror image pushing instructions comprise container mirror image files of the applications, and the mirror image pushing instructions are used for indicating the container mirror image files of the applications to be stored; and when the container instance of the application needs to be created, respectively sending a creation instruction to the N servers, wherein the creation instruction is used for indicating that the container instance of the application is created according to the stored container image file of the application.

Optionally, the orchestration scheduler further comprises: the determining module is used for determining M servers for backing up the container mirror image files of the application after the sending module sends mirror image pushing instructions to the N servers respectively according to the application arrangement description files, wherein M is an integer greater than or equal to 1; and the sending module is also used for sending mirror image pushing instructions to the M servers respectively.

Optionally, the receiving module is further configured to receive, when the number of the container instances of the application increases, an address query instruction sent by a server that creates the newly added container instances of the application, where the address query instruction is used to query an address of a server that stores an image file of the application; and the sending module is further used for sending an address response instruction to the server for creating the container instance of the newly added application, wherein the address response instruction comprises the address of one server in the N servers.

In a fourth aspect, an embodiment of the present invention provides a server, including: the receiving module is used for receiving a mirror image pushing instruction sent by the arrangement scheduler, wherein the mirror image pushing instruction comprises a container mirror image file of the first application, and the mirror image pushing instruction is used for indicating the container mirror image file storing the first application; the storage module is used for storing a container mirror image file of the first application according to the mirror image pushing instruction; the receiving module is further used for receiving a creating instruction sent by the arranging scheduler when the container instance of the first application needs to be created, wherein the creating instruction is used for indicating that the container instance of the first application is created according to the stored container image file of the first application; and the processing module is used for creating a container instance of the first application according to the creation instruction and the stored container image file of the first application.

Optionally, the processing module is further configured to shut down the container instance of the first application when the number of container instances of the first application needs to be reduced.

Optionally, the receiving module is further configured to receive a first mirror image pull instruction sent by the second server when the number of container instances of the first application increases, where the first mirror image pull instruction is used to pull a container mirror image file of the first application; the second server is a server for creating a container instance of the newly added first application; the server further comprises: and a sending module. And the sending module is used for returning the container image file of the first application to the second server according to the first image pulling instruction.

Optionally, the processing module is further configured to create a container instance of the second application according to the stored container image file of the second application when the first server needs to create the container instance of the second application and when the container image file of the second application is stored in the first server.

Optionally, the server further comprises: and a sending module. The sending module is used for sending an address query instruction to the arranging scheduler when the first server needs to create a container instance of the second application and when the first server does not store the container image file of the second application, wherein the address query instruction is used for querying the address of the server storing the container image file of the second application; the receiving module is further configured to receive an address response instruction sent by the scheduling scheduler, where the address response instruction includes an address of a third server, and the third server is a server storing a container mirror image file of a second application; the sending module is further used for sending a second mirror image pulling instruction to the third server according to the address response instruction, wherein the second mirror image pulling instruction is used for pulling a container mirror image file of the second application; the receiving module is further used for receiving the container mirror image file of the second application returned by the third server; and the processing module is also used for creating a container instance of the second application according to the container image file of the second application.

Optionally, the processing module is further configured to obtain an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; and when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

Optionally, the processing module is further configured to stop cleaning the storage space when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold.

In a fifth aspect, an embodiment of the present invention provides an orchestration scheduler, including: a processor and a communication interface. The processor is used for receiving the application media package through the communication interface, the application media package comprises an application container image file and an application layout description file, and the application layout description file is used for indicating that the number of container instances of the application needing to be created is N; n is an integer greater than or equal to 1; according to the application arrangement description file, respectively sending mirror image pushing instructions to the N servers through the communication interfaces, wherein the mirror image pushing instructions comprise container mirror image files of the application, and the mirror image pushing instructions are used for indicating the container mirror image files of the application to be stored; and when the application container instance needs to be created, sending a creation instruction to the N servers through the communication interface respectively, wherein the creation instruction is used for indicating that the application container instance is created according to the stored application container image file.

Optionally, the processor is further configured to determine, after sending the image push instruction to the N servers through the communication interface respectively according to the application arrangement description file, M servers that backup the container image file of the application, where M is an integer greater than or equal to 1; and respectively sending mirror image pushing instructions to the M servers through the communication interfaces.

Optionally, the processor is further configured to receive, through the communication interface, an address query instruction sent by a server that creates a newly added container instance of the application when the number of container instances of the application increases, where the address query instruction is used to query an address of a server that stores an image file of the application; and sending an address response instruction to the server for creating the container instance of the newly added application through the communication interface, wherein the address response instruction comprises the address of one server in the N servers.

In a sixth aspect, an embodiment of the present invention provides a server, including: a processor and a communication interface. The processor is used for receiving a mirror image pushing instruction sent by the arrangement scheduler through the communication interface, wherein the mirror image pushing instruction comprises a container mirror image file of the first application, and the mirror image pushing instruction is used for indicating the container mirror image file for storing the first application; storing a container mirror image file of the first application according to the mirror image pushing instruction; when a container instance of the first application needs to be created, receiving a creation instruction sent by an arranging scheduler through a communication interface, wherein the creation instruction is used for indicating that the container instance of the first application is created according to a stored container image file of the first application; and creating a container instance of the first application according to the creation instruction and the stored container image file of the first application.

Optionally, the processor is further configured to shut down the container instance of the first application when the number of container instances of the first application needs to be reduced.

Optionally, the processor is further configured to receive, through the communication interface, a first image pull instruction sent by the second server when the number of container instances of the first application increases, where the first image pull instruction is used to pull a container image file of the first application; the second server is a server for creating a container instance of the newly added first application; and returning the container image file of the first application to the second server through the communication interface according to the first image pulling instruction.

Optionally, the processor is further configured to create a container instance of the second application according to the stored container image file of the second application when the first server needs to create the container instance of the second application and when the container image file of the second application is stored in the first server.

Optionally, the processor is further configured to send, when the first server needs to create a container instance of the second application and when the first server does not store the container image file of the second application, an address query instruction to the orchestration scheduler through the communication interface, where the address query instruction is used to query an address of a server storing the container image file of the second application; receiving an address response instruction sent by the arrangement scheduler through a communication interface, wherein the address response instruction comprises an address of a third server, and the third server is a server storing a container mirror image file of a second application; according to the address response instruction, sending a second mirror image pulling instruction to a third server through a communication interface, wherein the second mirror image pulling instruction is used for pulling a container mirror image file of a second application; receiving a container mirror image file of the second application returned by the third server through the communication interface; and creating a container instance of the second application according to the container image file of the second application.

Optionally, the processor is further configured to obtain an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; and when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

Optionally, the processor is further configured to stop cleaning the storage space when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold.

According to the method and the device for creating the container instance of the application, provided by the embodiment of the invention, before the container instance of the application needs to be created, the container image files of the application are respectively stored in the servers with the same number as the container instances of the application, and when the container instance of the application is created, each server can directly create the container instance of the application according to the local container image files, the container image files do not need to be pulled from a far end, the container instance deployment efficiency is improved, the container starting speed is improved, a warehouse for storing the container image files does not need to be separately deployed, and the utilization rate of server resources can be indirectly improved. And the container mirror image files are respectively stored in the N servers, when the container mirror image file of one server cannot be used due to failure, the desired container mirror image file can be pulled by accessing other servers, so that the overall reliability of the container mirror image file is enhanced.

Drawings

Fig. 1 is a flowchart of a container instance creating method for an application according to an embodiment of the present invention;

fig. 2 is a flowchart of a container instance creating method for an application according to a second embodiment of the present invention;

fig. 3 is a flowchart of a container instance creating method for an application according to a third embodiment of the present invention;

FIG. 4 is a schematic diagram of an arrangement scheduler according to an embodiment of the present invention;

FIG. 5 is a schematic structural diagram of an arrangement scheduler according to a second embodiment of the present invention;

fig. 6 is a schematic structural diagram of a server according to an embodiment of the present invention;

fig. 7 is a schematic structural diagram of a server according to a second embodiment of the present invention.

Detailed Description

Fig. 1 is a flowchart of a method for creating a container instance of an application according to an embodiment of the present invention, and as shown in fig. 1, the method according to this embodiment may include:

s101, receiving an application media package by an arrangement scheduler.

In this embodiment, the container mirror image file of the application may be uploaded to a container mirror image warehouse for storage after being manufactured, where the container mirror image warehouse is deployed on a server. The container image file of the application is manufactured and uploaded to the server, and the process is scheduled and completed through the scheduling scheduler. The method comprises the steps that a user uploads an application media package to an arrangement scheduler, correspondingly, the arrangement scheduler can receive the application media package, the application media package comprises an application container image file and an application arrangement description file, and the application arrangement description file is used for indicating that the number of container instances of an application needing to be created is N; n is an integer greater than or equal to 1. Optionally, the application layout description file includes the number N of container instances of the application that needs to be created. Optionally, the container image file is a standardized container image package, and has no special requirement on format (no distinction between appc or docker format images).

S102, the arrangement scheduler sends mirror image pushing instructions to the N servers respectively according to the application arrangement description file. The mirror image push instruction comprises a container mirror image file of the application, and the mirror image push instruction is used for indicating the container mirror image file of the storage application.

In this embodiment, the arrangement scheduler sends mirror image push instructions (belonging to container commands) to the N servers respectively according to the application arrangement description files in the application media package, where the mirror image push instructions include container mirror files of the applications, and the mirror image push instructions are used to instruct to store the container mirror files of the applications. Where each server is used to create a container instance of the application.

Optionally, the orchestration scheduler may determine, before executing S102, from a plurality of servers, N servers that need to create the container instance of the application, for example: the N servers that need to create the container instance of the application can be determined according to the resource occupation situation of each server. Optionally, the application orchestration description file is also used to indicate a server that can store a container image file of the application, such as: the application orchestration description file also includes affinity/anti-affinity description information. The pass affinity/anti-affinity information is used to indicate a type of server that may or may not store the container image of the application. The affinity/anti-affinity description information is generally used in a deployment scenario of stateful services, for example, an IO-intensive application is generally deployed on a server with a strong disk IO capability, and correspondingly, a container image file of the application also needs to be stored on the server with the strong disk IO capability through affinity. Optionally, the application layout description file further includes application container resource description information, which is used to indicate the number of CPU cores, the size of memory and disk space occupied by the container, and the like.

It should be noted that the application layout description file is not limited to include the above information.

It should be noted that fig. 1 only shows the interaction flow between the orchestration scheduler and one server, and the interaction flow between other servers and the orchestration server is similar and not shown here.

S103, the server stores the container mirror image file of the application according to the mirror image pushing instruction.

In this embodiment, after receiving the mirror image push instruction sent by the orchestration scheduler, the server stores the container mirror image file of the application in the mirror image push instruction according to the mirror image push instruction. For example: the server analyzes the container mirror image file according to the format of the container mirror image file, and stores the analyzed container mirror image file into a storage space (a storage directory therein) of a local mirror image file of the server. For the AUFS file system, the storage directory of the parsed container image file in the local is as follows:

root@ubuntu:/var/lib/docker/aufs#11

total 76

drwxr-xr-x 5root root 4096Aug 31 14:06./

drwx------10root root 4096Oct 10 14:52../

drwxr-xr-x 164root root 20480Oct 10 14:52diff/

drwxr-xr-x 2root root 20480Oct 10 14:52layers/

drwxr-xr-x 164root root 20480Oct 10 14:52mnt/

root$ubuntu:/var/lib/docker/aufs#

wherein diff is the original data of the container mirror image file, layers describe the relationship of layered mirror images, and mnt stores rootfs after merging mirror image layers.

Optionally, the server successfully stores the container image of the application, and further sends a response instruction to the orchestration scheduler for indicating that the container image of the application has been successfully stored.

Optionally, the orchestration scheduler further stores a correspondence between the container image file and an address of a server storing the container image file, so as to indicate which servers store the container image file.

And S104, when the container instances of the applications need to be created, the scheduling scheduler sends creation instructions to the N servers respectively.

When the container instance of the application needs to be created, the scheduling scheduler sends a creation instruction (belonging to a container command) to the N servers respectively, wherein the creation instruction is used for instructing to create the container instance of the application according to the stored container image file of the application.

And S105, the server creates a container instance of the application according to the creation instruction and the stored container mirror image file of the application.

In this embodiment, after the server receives the creation instruction sent by the scheduling scheduler, since the server already stores the container image file of the application, the server does not need to pull the container image file remotely. Therefore, the server can directly create the container instance of the application according to the creation instruction and the stored container image file of the application.

Optionally, the server sends a response instruction to the orchestration scheduler after the container instance of the application is successfully created, for indicating that the container instance of the application has been successfully created.

In summary, in the method for creating the container instance of the application provided in this embodiment, before the container instance of the application needs to be created, the container image files of the application are stored in the servers with the same number as the container instances of the application, and when the container instance of the application is created, each server may directly create the container instance of the application according to the local container image file, and the container image file does not need to be pulled from a remote end, so that the deployment efficiency of the container instance is improved, and the container starting speed is increased. And the container mirror image files are respectively stored in the N servers, when the container mirror image file of one server cannot be used due to failure, the desired container mirror image file can be pulled by accessing other servers, so that the overall reliability of the container mirror image file is enhanced.

Optionally, after executing the above S102, the orchestration scheduler further determines M servers that backup the container image file of the application, where M is an integer greater than or equal to 1; and then respectively sending mirror image pushing instructions to the M servers, wherein the mirror image pushing instructions comprise the container mirror image files of the application, and the mirror image pushing instructions are used for indicating the container mirror image files for storing the application.

The scheduling scheduler may determine M servers that back up the container image file of the application according to resource occupation of the servers, and optionally, the scheduling scheduler further determines the M servers by combining affinity/inverse affinity description information in the application scheduling description file, and then sends an image push instruction to the M servers. Optionally, prior to this operation, the orchestration scheduler determines that said N is less than a maximum number of servers for which application instances can be deployed; and if N is larger than or equal to the maximum number of servers capable of deploying the application instances, no redundant server is available for backing up the container image file at the moment, and the container image file is not backed up any more. And the storage quantity of the container image files of the same application is not less than 2 parts at least.

And after receiving the mirror image pushing instruction, the M servers store the container mirror image file of the application according to the mirror image pushing instruction. The orchestration scheduler does not send create instructions to the M servers only when a container instance of the application needs to be created. This improves the storage reliability of the container image file.

Fig. 2 is a flowchart of a container instance creating method for an application according to a second embodiment of the present invention, and as shown in fig. 2, the method according to the present embodiment may include:

s201, receiving the application media package by the scheduling scheduler.

The application media package includes a container image file of a first application and a first application orchestration description file.

S202, the arrangement scheduler sends first mirror image push instructions to the N first servers respectively according to the application arrangement description file. The first image push instruction comprises a container image file of the first application.

S203, the first server stores the container mirror image file of the first application according to the first mirror image pushing instruction.

S204, when the container instance of the first application needs to be created, the scheduling scheduler sends creation instructions to the N first servers respectively.

S205, the first server creates a container instance of the first application according to the creation instruction and the stored container mirror image file of the first application.

In this embodiment, the specific implementation process of S201-S205 may refer to the related description of the embodiment shown in fig. 1, and is not described herein again.

Optionally, in a capacity shrinkage scenario, the traffic is shrinking, and the system also needs to shut down some of the application container instances to reduce the operation cost. When the number of container instances of the first application needs to be reduced, for example: if K1 needs to be reduced, each of the K1 of the N first servers shuts down the container instance of the first application, for example: the first server shuts down the container instance of the first application according to the shutdown instruction sent by the orchestration schedule. Optionally, the K1 first servers still store the image file of the first application, and are not deleted actively, so that the scheduling scheduler deploys the container instance of the first application to the servers of the K1 first servers preferentially when capacity expansion is performed next time, for example, when the container instance of the first application is added, thereby reducing the copy number of the image file of the first application and improving deployment efficiency.

Optionally, in a capacity expansion scenario, when traffic volume expands, the originally deployed container instance of the application cannot meet a service requirement, and at this time, capacity expansion is required to increase the container instance of the application. When the number of container instances of the first application increases, for example: adding K2, then correspondingly requiring another K2 servers to create a container instance for the newly added application in a one-to-one correspondence. The scheduling scheduler preferentially selects the server which stores the container image file of the first application for capacity expansion deployment, and in this case, the container image file of the application is local to the server, and the container is directly created and operated. If the container instance of the expanded first application is deployed in a new server, the server does not store the container image file of the first application, and at this time, the container image file needs to be stored locally from other servers storing the container image file of the first application, and the process needs to be completed by arranging a scheduler; the server that creates the newly added container instance of the first application is referred to herein as a second server, where each of the K2 second servers may execute the scheme shown below.

S206, the second server sends a first address query instruction to the arranging scheduler.

In this embodiment, when the second server does not store the container image file of the first application, the second server sends a first address query instruction to the scheduling scheduler, where the first address query instruction is used to query an address of a server storing the container image file of the first application.

And S207, sending a first address response instruction to the second server by the scheduling scheduler. The first address response instruction includes an address of the first server.

In this embodiment, after receiving the first address query instruction, the scheduling scheduler may determine an address of a first server storing the container image of the first application, and then send a first address response instruction to the second server, where the first address response instruction includes an address of one of the N first servers. The address of which first server is specifically included in the first address response instruction may be determined according to the resource occupation condition of each first server.

S208, the second server sends a first mirror image pulling instruction to the first server according to the first address response instruction.

In this embodiment, after receiving the first address response instruction, the second server sends a first mirror image pull instruction to the first server according to the address of the first server in the first address response instruction, where the first mirror image pull instruction is used to pull the container mirror image file of the first application.

S209, the first server returns the container image file of the first application to the second server according to the first image pulling instruction.

S210, the second server creates a container instance of the first application according to the container mirror image file of the first application.

In this embodiment, after receiving the first image pull instruction, the first server returns the container image file of the first application stored in the first server to the second server according to the first image pull instruction. And after receiving the container image file of the first application, the second server creates a container instance of the first application according to the container image file of the first application. Optionally, the second server further stores a container image file of the first application. Therefore, the capacity expansion scheme of the container instance of the first application is realized.

In summary, according to the embodiment, through the above scheme, the problem that in the prior art, concurrent pressure is high and performance is easy to generate due to centralized remote operation for acquiring the applied container image file is solved; in the capacity expansion of the embodiment, the container mirror image file of the application is pulled from a plurality of scattered servers, the concurrency pressure is reduced, and the performance is ensured.

Fig. 3 is a flowchart of an application container instance creating method according to a third embodiment of the present invention, and as shown in fig. 3, in the method according to the present embodiment, after S201 to S205 shown in fig. 2, when a first server needs to create a container instance of a second application, if a container image file of the second application is stored in the first server, the first server creates the container instance of the second application according to the stored container image file of the second application. If the first server does not store the container image file of the second application, the following steps are executed.

S301, the first server sends a second address query instruction to the arranging scheduler.

The second address querying instruction is used for querying the address of the server storing the container image file of the second application.

S302, the arrangement scheduler sends a second address response instruction to the first server. The first address response instruction includes an address of the third server. The third server is a server storing the container image file of the second application.

And S303, the first server sends a second mirror image pulling instruction to the third server according to the second address response instruction. The second image pull instruction is used for pulling a container image file of the second application.

S304, the third server returns the container mirror image file of the second application to the first server according to the second mirror image pulling instruction.

S305, the first server creates a container instance of the second application according to the container mirror image file of the second application.

In this embodiment, the specific implementation process of S301-S305 may refer to the related description in the embodiment shown in fig. 2, and is not described herein again.

Optionally, on the basis of the foregoing method embodiments of the present invention, the server further obtains an occupancy rate of a storage space of the server; the storage space is used for storing container image files, and the storage space can be used for storing container image files of various applications. And when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

The storage space of each server is limited, and if container image files are added to the servers without being cleared, the storage space of the servers is insufficient, and normal use of applications is affected. For example, the server may periodically check the storage space to obtain the occupancy rate of the storage space. When the occupancy rate is greater than a first threshold, for example, 90%, the server may clean the container image file in the local storage space according to a least recently used algorithm (LRU) to delete the container image file that is not used within a preset time. Optionally, the storage container image file is rejected during the process of cleaning up the storage space by the server.

Optionally, when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold, the server stops cleaning the storage space, thereby ensuring that the new container image file stored at this time is safe. For example, the second threshold is 80%. Optionally, if the occupancy rate of the storage empty space is still not less than the second threshold after the cleaning, the server reports the error information to the scheduling scheduler, and the scheduling scheduler reports an alarm to the user for manual inspection.

Optionally, before the server stores the container image file, it is detected whether the container image file is locally saved, and if so, the storage is rejected, and a corresponding error code is returned.

The scheme of the embodiment of the invention is suitable for application deployment scenes based on the container warehouse, comprises container technologies such as docker and RKT, and is also suitable for the bottom container technology without the container warehouse, such as LXC.

In addition, aspects of embodiments of the present invention are similarly useful in conventional non-containerized applications.

Fig. 4 is a schematic structural diagram of an orchestration scheduler according to an embodiment of the present invention, and as shown in fig. 4, the orchestration scheduler according to the embodiment may include: a receiving module 11 and a transmitting module 12.

A receiving module 11, configured to receive an application media package, where the application media package includes a container image file of the application and an application layout description file, and the application layout description file is used to indicate that the number of container instances of the application that need to be created is N; n is an integer greater than or equal to 1;

a sending module 12, configured to send image pushing instructions to the N servers respectively according to the application arrangement description file, where the image pushing instructions include a container image file of the application, and the image pushing instructions are used to instruct to store the container image file of the application; and when the container instance of the application needs to be created, respectively sending a creation instruction to the N servers, wherein the creation instruction is used for indicating that the container instance of the application is created according to the stored container image file of the application.

Optionally, the scheduling scheduler of this embodiment further includes: a determination module 13.

A determining module 13, configured to determine, after the sending module 12 sends the mirror image push instructions to the N servers respectively according to the application arrangement description file, M servers that backup container mirror image files of the application, where M is an integer greater than or equal to 1;

the sending module 12 is further configured to send the mirror image pushing instruction to the M servers respectively.

Optionally, the receiving module 11 is further configured to receive, when the number of the application container instances increases, an address query instruction sent by a server that creates the newly added application container instance, where the address query instruction is used to query an address of a server that stores the image file of the application;

the sending module 12 is further configured to send an address response instruction to the server that creates the newly added container instance of the application, where the address response instruction includes an address of one server in the N servers.

The scheduling scheduler of this embodiment may be configured to execute the technical solution executed by the scheduling scheduler in the above-mentioned method embodiments of the present invention, and the implementation principle and the technical effect are similar, which are not described herein again.

Fig. 5 is a schematic structural diagram of an orchestration scheduler according to a second embodiment of the present invention, and as shown in fig. 5, the orchestration scheduler according to this embodiment may include: a processor 21 and a communication interface 22. A processor 21, configured to receive an application media package through the communication interface 22, where the application media package includes a container image file of an application and an application layout description file, and the application layout description file is used to indicate that the number of container instances of the application that needs to be created is N; n is an integer greater than or equal to 1; according to the application arrangement description file, respectively sending image pushing instructions to the N servers through the communication interface 22, wherein the image pushing instructions comprise container image files of the application, and the image pushing instructions are used for indicating the container image files of the storage application; and when the container instance of the application needs to be created, sending a creation instruction to the N servers through the communication interface 22, wherein the creation instruction is used for instructing to create the container instance of the application according to the stored container image file of the application.

Optionally, the processor 21 is further configured to determine M servers that backup container image files of the application after sending image push instructions to the N servers through the communication interface 22 according to the application arrangement description file, where M is an integer greater than or equal to 1; and respectively sending mirror image pushing instructions to the M servers through the communication interfaces.

Optionally, the processor 21 is further configured to receive, through the communication interface 22, an address query instruction sent by a server that creates a container instance of the newly added application when the number of container instances of the application increases, where the address query instruction is used to query an address of a server that stores an image file of the application; an address response instruction is sent to the server that created the container instance of the newly added application via the communication interface 22, the address response instruction including the address of one of the N servers.

Optionally, the orchestration scheduler of the present embodiment further includes a memory 23, where the memory 23 is configured to store codes of a container instance creation method for executing an application, and the processor 21 is configured to call the codes stored in the memory 23 to execute the above scheme.

Fig. 6 is a schematic structural diagram of a server according to an embodiment of the present invention, and as shown in fig. 6, the server according to this embodiment may include: a receiving module 31, a storage module 32 and a processing module 33.

A receiving module 31, configured to receive a mirror image push instruction sent by an orchestration scheduler, where the mirror image push instruction includes a container mirror image file of a first application, and the mirror image push instruction is used to instruct to store the container mirror image file of the first application;

the storage module 32 is configured to store a container image file of the first application according to the image push instruction;

the receiving module 31 is further configured to receive, when a container instance of the first application needs to be created, a creation instruction sent by the orchestration scheduler, where the creation instruction is used to instruct to create the container instance of the first application according to the stored container image file of the first application;

and the processing module 33 is configured to create a container instance of the first application according to the creation instruction and the stored container image file of the first application.

Optionally, the processing module 33 is further configured to shut down the container instance of the first application when the number of container instances of the first application needs to be reduced.

Optionally, the server of this embodiment further includes: and a sending module 34.

Optionally, the receiving module 31 is further configured to receive a first image pull instruction sent by a second server when the number of container instances of the first application increases, where the first image pull instruction is used to pull a container image file of the first application; the second server is a server for creating a container instance for newly adding the first application;

the sending module 34 is configured to return the container image file of the first application to the second server according to the first image pull instruction.

Optionally, the processing module 33 is further configured to create a container instance of a second application according to the stored container image file of the second application when the first server needs to create the container instance of the second application and when the container image file of the second application is stored in the first server.

Optionally, the sending module 34 is configured to send, to the orchestration scheduler, an address query instruction when the first server needs to create a container instance of a second application and when the first server does not store a container image of the second application, where the address query instruction is used to query an address of a server storing the container image of the second application;

the receiving module 31 is further configured to receive an address response instruction sent by the scheduling scheduler, where the address response instruction includes an address of a third server, and the third server is a server in which a container image file of the second application is stored;

the sending module 34 is further configured to send a second mirror image pull instruction to the third server according to the address response instruction, where the second mirror image pull instruction is used to pull the container mirror image file of the second application;

the receiving module 31 is further configured to receive a container image file of the second application returned by the third server;

the processing module 33 is further configured to create a container instance of the second application according to the container image file of the second application.

Optionally, the processing module 33 is further configured to obtain an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; and when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

Optionally, the processing module 33 is further configured to stop cleaning the storage space when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold.

The server of this embodiment may be configured to execute the technical solution executed by the server in the foregoing method embodiments of the present invention, and the implementation principle and the technical effect are similar, which are not described herein again.

Fig. 7 is a schematic structural diagram of a server according to a second embodiment of the present invention, and as shown in fig. 7, the server according to this embodiment may include: a processor 41 and a communication interface 42. A processor 41, configured to receive, through the communication interface 42, a mirror push instruction sent by the orchestration scheduler, where the mirror push instruction includes a container mirror file of the first application, and the mirror push instruction is used to instruct to store the container mirror file of the first application; storing a container mirror image file of the first application according to the mirror image pushing instruction; when the container instance of the first application needs to be created, receiving a creation instruction sent by the orchestration scheduler through the communication interface 42, wherein the creation instruction is used for instructing to create the container instance of the first application according to the stored container image file of the first application; and creating a container instance of the first application according to the creation instruction and the stored container image file of the first application.

Optionally, the processor 41 is further configured to shut down the container instance of the first application when the number of container instances of the first application needs to be reduced.

Optionally, the processor 41 is further configured to receive, through the communication interface 42, a first image pull instruction sent by the second server when the number of container instances of the first application increases, where the first image pull instruction is used to pull a container image file of the first application; the second server is a server for creating a container instance of the newly added first application; the container image file of the first application is returned to the second server via the communication interface 42 according to the first image pull instruction.

Optionally, the processor 41 is further configured to create a container instance of the second application according to the stored container image file of the second application when the first server needs to create the container instance of the second application and when the container image file of the second application is stored in the first server.

Optionally, the processor 41 is further configured to send, when the first server needs to create a container instance of the second application and when the first server does not store the container image file of the second application, an address query instruction to the orchestration scheduler through the communication interface 42, where the address query instruction is used to query an address of a server storing the container image file of the second application; receiving an address response instruction sent by the scheduling scheduler through the communication interface 42, where the address response instruction includes an address of a third server, and the third server is a server storing a container image file of the second application; according to the address response instruction, sending a second mirror image pulling instruction to the third server through the communication interface 42, wherein the second mirror image pulling instruction is used for pulling a container mirror image file of the second application; receiving the container image file of the second application returned by the third server through the communication interface 42; and creating a container instance of the second application according to the container image file of the second application.

Optionally, the processor 41 is further configured to obtain an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; and when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

Optionally, the processor 41 is further configured to stop cleaning the storage space when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold.

Optionally, the orchestration scheduler of the present embodiment further includes a memory 43, the memory 43 is configured to store codes of a container instance creation method for executing the application, and the processor 41 is configured to call the codes stored in the memory 43 to perform the above scheme.

Those of ordinary skill in the art will understand that: all or a portion of the steps of implementing the above-described method embodiments may be performed by hardware associated with program instructions. The program may be stored in a computer-readable storage medium. When executed, the program performs steps comprising the method embodiments described above; and the aforementioned storage medium includes: Read-Only Memory (ROM), Random Access Memory (RAM), magnetic or optical disk, and other various media capable of storing program codes.

Finally, it should be noted that: the above embodiments are only used to illustrate the technical solution of the present invention, and not to limit the same; while the invention has been described in detail and with reference to the foregoing embodiments, it will be understood by those skilled in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for creating a container instance of an application, comprising:

the method comprises the steps that an arrangement scheduler receives an application media package, wherein the application media package comprises a container image file of a first application and a first application arrangement description file, and the first application arrangement description file is used for indicating that the number of container instances of the first application needing to be created is N; n is an integer greater than or equal to 1;

the arrangement scheduler sends mirror image pushing instructions to N first servers respectively according to the first application arrangement description file, wherein the mirror image pushing instructions comprise container mirror images of the first applications, and the mirror image pushing instructions are used for indicating the container mirror images of the first applications to be stored;

when the container instance of the first application needs to be created, the arranging scheduler sends creating instructions to the N first servers respectively, wherein the creating instructions are used for instructing to create the container instance of the first application according to the stored container image file of the first application;

when the first server needs to create a container instance of a second application and the first server does not store a container image file of the second application needing to be created, the orchestration scheduler receives an address query instruction sent by the first server, wherein the address query instruction is used for querying an address of a server storing the container image file of the second application;

the scheduling scheduler sends an address response instruction to the first server, so that the first server sends a second mirror image pulling instruction to a third server according to the address response instruction; the address response instruction comprises an address of a third server, the third server is a server storing the container image file of the second application, and the second image pull instruction is used for pulling the container image file of the second application; the container image file of the second application is used for the first server to create a container instance of the second application.

2. The method of claim 1, wherein after the orchestration scheduler sends mirror push instructions to the N first servers according to the first application orchestration description file, the method further comprises:

the scheduling scheduler determines M third servers backing up the container image file of the first application, wherein M is an integer greater than or equal to 1;

and the arrangement scheduler sends the mirror image push instruction to the M third servers respectively.

3. The method of claim 1 or 2, further comprising:

when the number of the container instances of the first application is increased, the arranging scheduler receives an address query instruction sent by a second server which creates the newly increased container instances of the first application, wherein the address query instruction is used for querying the address of a server which stores the image file of the first application;

and the arranging scheduler sends an address response instruction to the second server which creates the newly added container instance of the first application, wherein the address response instruction comprises the address of any server in the N first servers.

4. A method for creating a container instance of an application, comprising:

the method comprises the steps that a first server receives a mirror image pushing instruction sent by an orchestration scheduler, wherein the mirror image pushing instruction comprises a container mirror image file of a first application, and the mirror image pushing instruction is used for indicating the container mirror image file of the first application to be stored;

the first server stores a container mirror image file of the first application according to the mirror image pushing instruction;

when a container instance of the first application needs to be created, the first server receives a creation instruction sent by the orchestration scheduler, wherein the creation instruction is used for instructing to create the container instance of the first application according to the stored container image file of the first application;

the first server creates a container instance of the first application according to the creation instruction and the stored container mirror image file of the first application;

when the first server needs to create a container instance of a second application, the method further comprises:

when the container mirror image file of the second application is not stored in the first server, the first server sends an address query instruction to the arrangement scheduler, wherein the address query instruction is used for querying an address of a server storing the container mirror image file of the second application;

the first server receives an address response instruction sent by the arrangement scheduler, wherein the address response instruction comprises an address of a third server, and the third server is a server storing a container mirror image file of the second application;

the first server sends a second mirror image pulling instruction to the third server according to the address response instruction, wherein the second mirror image pulling instruction is used for pulling the container mirror image file of the second application;

the first server receives the container mirror image file of the second application returned by the third server;

and the first server creates a container instance of the second application according to the container image file of the second application.

5. The method of claim 4, further comprising:

when the number of container instances of the first application needs to be reduced, the first server shuts down the container instances of the first application.

6. The method of claim 4, further comprising:

when the number of container instances of the first application is increased, the first server receives a first mirror image pulling instruction sent by a second server, wherein the first mirror image pulling instruction is used for pulling a container mirror image file of the first application; the second server is a server for creating a container instance for newly adding the first application;

and the first server returns the container mirror image file of the first application to the second server according to the first mirror image pulling instruction.

7. The method according to any of claims 4-6, wherein when the first server needs to create a container instance of a second application, the method further comprises:

when the container image file of the second application is stored in the first server, the first server creates a container instance of the second application according to the stored container image file of the second application.

8. The method of any one of claims 4-6, further comprising:

the first server acquires the occupancy rate of the storage space of the first server; the storage space is used for storing container mirror image files;

and when the occupancy rate is greater than a first threshold value, the first server cleans the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container mirror image file within a preset time.

9. The method of claim 8, further comprising:

when the occupancy rate of cleaning the storage space to the storage space is smaller than a second threshold value, the first server stops cleaning the storage space.

10. An orchestration scheduler, comprising:

the system comprises a receiving module, a creating module and a display module, wherein the receiving module is used for receiving an application media package, the application media package comprises a container image file of a first application and a first application arrangement description file, and the first application arrangement description file is used for indicating that the number of container instances of the first application needing to be created is N; n is an integer greater than or equal to 1;

a sending module, configured to send a mirror image pushing instruction to N first servers respectively according to the first application layout description file, where the mirror image pushing instruction includes a container mirror image file of the first application, and the mirror image pushing instruction is used to indicate that the container mirror image file of the first application is stored; when the container instance of the application needs to be created, creating instructions are sent to the N first servers respectively, and the creating instructions are used for indicating that the container instance of the first application is created according to the stored container image file of the first application;

when the first server needs to create a container instance of a second application, and when the first server does not store a container image file of the second application that needs to be created, the receiving module is further configured to receive an address query instruction sent by the first server, where the address query instruction is used to query an address of a server that stores the container image file of the second application;

the sending module is further configured to send an address response instruction to the first server, so that the first server sends a second mirror image pull instruction to a third server according to the address response instruction; the address response instruction comprises an address of a third server, the third server is a server storing the container image file of the second application, and the second image pull instruction is used for pulling the container image file of the second application; the container image file of the second application is used for the first server to create a container instance of the second application.

11. The orchestration scheduler of claim 10, further comprising:

a determining module, configured to determine, after the sending module sends the mirror image push instructions to the N first servers respectively according to the first application arrangement description file, M third servers that backup container mirror image files of the first application, where M is an integer greater than or equal to 1;

the sending module is further configured to send the mirror image pushing instruction to the M third servers, respectively.

12. The orchestration scheduler according to claim 10 or 11, wherein the receiving module is further configured to receive, when the number of container instances of the first application increases, an address query instruction sent by a second server that creates a newly added container instance of the first application, the address query instruction being configured to query an address of a server that stores an image file of the first application;

the sending module is further configured to send an address response instruction to the second server that creates the newly added container instance of the first application, where the address response instruction includes an address of one of the N servers.

13. A server, comprising:

the system comprises a receiving module, a scheduling scheduler and a pushing module, wherein the receiving module is used for receiving a mirror image pushing instruction sent by the scheduling scheduler, the mirror image pushing instruction comprises a container mirror image file of a first application, and the mirror image pushing instruction is used for indicating the container mirror image file of the first application to be stored;

the storage module is used for storing the container mirror image file of the first application according to the mirror image pushing instruction;

the receiving module is further configured to receive a creation instruction sent by the orchestration scheduler when a container instance of the first application needs to be created, where the creation instruction is used to instruct to create the container instance of the first application according to the stored container image file of the first application;

the processing module is used for creating a container instance of the first application according to the creation instruction and the stored container mirror image file of the first application;

a sending module, configured to send an address query instruction to the orchestration scheduler when the first server needs to create a container instance of a second application and when the first server does not store a container image file of the second application, where the address query instruction is used to query an address of a server that stores the container image file of the second application;

the receiving module is further configured to receive an address response instruction sent by the scheduling scheduler, where the address response instruction includes an address of a third server, and the third server is a server in which a container image file of the second application is stored;

the sending module is further configured to send a second mirror image pulling instruction to the third server according to the address response instruction, where the second mirror image pulling instruction is used to pull the container mirror image file of the second application;

the receiving module is further configured to receive the container image file of the second application returned by the third server;

the processing module is further configured to create a container instance of the second application according to the container image file of the second application.

14. The server according to claim 13, wherein the processing module is further configured to shut down the container instance of the first application when the number of container instances of the first application needs to be reduced.

15. The server according to claim 13,

the receiving module is further configured to receive a first mirror image pulling instruction sent by a second server when the number of container instances of the first application increases, where the first mirror image pulling instruction is used to pull a container mirror image file of the first application; the second server is a server for creating a container instance for newly adding the first application;

the server further comprises: and the sending module is used for returning the container image file of the first application to the second server according to the first image pulling instruction.

16. The server according to any one of claims 13 to 15, wherein the processing module is further configured to create a container instance of a second application according to the stored container image file of the second application when the first server needs to create the container instance of the second application and when the container image file of the second application is stored in the first server.

17. The server according to any one of claims 13 to 15, wherein the processing module is further configured to obtain an occupancy rate of a storage space of the first server; the storage space is used for storing container mirror image files; and when the occupancy rate is greater than a first threshold value, cleaning the storage space according to a preset rule, wherein the preset rule is used for indicating to clean the unused container image file within a preset time.

18. The server according to claim 17, wherein the processing module is further configured to stop cleaning the storage space when the occupancy rate of cleaning the storage space to the storage space is less than a second threshold.