KR20210061633A - Apparatus and method for scheduling containers of virtualization system - Google Patents

Abstract

Disclosed are an apparatus and method for scheduling a container of a virtualization system that provides a computer resource virtualization service using a plurality of worker nodes. An apparatus for scheduling a container of a virtualization system according to an embodiment of the present invention includes a package checking unit for checking program packages of the new pod through images in a hierarchical format used to create a new pod including at least one container; for each of a plurality of worker nodes, a node selector that calculates the package redundancy between the worker node and the new pod by comparing the program packages of the new pod with the active package group including all program packages of all pods executing on the worker node, wherein the node selector selects a worker node in which the new pod is to be placed from among the plurality of worker nodes in consideration of the package redundancy calculated for each worker node; and a node information providing unit that provides information on the worker node selected by the node selector to the master node that manages the plurality of worker nodes, so that the master node places the new pod on the selected worker node.

Description

Apparatus and method for scheduling containers of virtualization system

The present invention relates to an apparatus and method for scheduling a container in a virtualization system, and more particularly, to an apparatus and method for scheduling a container in a virtualization system that provides computer resource virtualization services using a plurality of worker nodes.

The computer resource virtualization technology refers to a technology that provides an abstracted layer between physical resources and applications for the purpose of efficiently using physical resources and enhancing security. A virtualization system that provides computer resource virtualization services using such virtualization technology is a system that provides a virtual machine based on a hypervisor that virtualizes hardware resources and a container that virtualizes an operating system. It can be classified as Among the above systems, in a virtualization system that provides containers, scheduling for optimizing container placement in order to efficiently use resources of worker nodes in which containers are executed must be performed.

However, as disclosed in Korean Patent Application Publication No. 10-2017-0085072, Korean Patent Application Publication No. 10-2019-0066516, and the like, the existing technology does not consider program packages used in each worker node when scheduling a container. Therefore, the redundancy between the data stored in the memory when the container is executed in each worker node is low, and the effect of saving memory through KSM (Kernel Same-page Merging) is not sufficient. As a result, the container or Pod running on the worker node There is a problem of reducing the number or causing frequent swapping between worker nodes due to insufficient memory.

The technical problem to be solved by the present invention is to increase the redundancy between data stored in memory when the container is executed in each worker node, thereby improving the memory saving effect through Kernel Same-page Merging (KSM), and It is to provide a container scheduling apparatus and method for a virtualization system that improves performance of a virtualization system by preventing a swapping operation between worker nodes.

The container scheduling apparatus of a virtualization system according to an embodiment of the present invention is an apparatus for scheduling a container of a virtualization system that provides a computer resource virtualization service using a plurality of worker nodes, comprising: A package checking unit that checks program packages of the new pod through images of a hierarchical format used to create a new pod including a container; For each of the plurality of worker nodes, the active package group including all program packages of all Pods running in the corresponding worker node and the program packages of the new Pod are compared to calculate a package redundancy between the worker node and the new Pod. And a node selection unit that selects a worker node in which the new Pod is to be placed among the plurality of worker nodes in consideration of a package redundancy calculated for each worker node; And providing information on the worker node selected by the node selection unit to a master node that manages the plurality of worker nodes, so that the master node places the new Pod in the selected worker node. Includes wealth.

In one embodiment, the node selection unit, for each of the plurality of worker nodes, compares a label of a corresponding worker node or a label of an existing Pod running in the worker node with a label of the new Pod, and compares the label of the new Pod with the worker node. It is configured to determine a label association between new Pods, and to select a worker node in which the new Pod is to be placed in further consideration of the label association determined for each worker node.

In an embodiment, the node selection unit is configured to select a worker node in which the new Pod is to be placed based on a score calculated by assigning weights to the package redundancy and the label association, respectively.

In an embodiment, the node information providing unit includes information on the selected worker node as a controller manager located in the master node and interworking with the plurality of worker nodes to place pods in each worker node. It is configured to provide.

In one embodiment, the scheduling device further includes a package information management unit that stores and manages active package group information of each of the plurality of worker nodes, and provides the active package group information to the node selection unit.

In an embodiment, the package information management unit is configured to update active package group information of the selected worker node by reflecting program packages of the new Pod when the new Pod is disposed in the selected worker node.

In one embodiment, the package information management unit, when a Pod running in any one worker node among the plurality of worker nodes is suspended or deleted, reflects the program packages of the pod that has been suspended or deleted, and reflects the program packages of the pod that has been suspended or deleted. It is configured to update the active package group information.

A container scheduling method of a virtualization system according to an embodiment of the present invention is a method in which a scheduling device of a virtualization system providing a computer resource virtualization service using a plurality of worker nodes schedules a container, wherein the scheduling device comprises at least one (A) checking program packages of the new pod through images of a hierarchical format used to create a new pod including a container; For each of the plurality of worker nodes, the scheduling device compares the active package group including all program packages of all Pods running in the worker node with the program packages of the new Pod, and the package between the worker node and the new Pod (B) calculating the degree of redundancy; (C) selecting, by the scheduling device, a worker node in which the new Pod is to be placed among the plurality of worker nodes in consideration of a package redundancy calculated for each worker node; And the scheduling device provides information on the worker node selected in step (c) to a master node that manages the plurality of worker nodes, so that the master node deploys the new pod to the selected worker node. Step (d).

In one embodiment, the method comprises, before step (c), the scheduling device, for each of the plurality of worker nodes, the label of the worker node or the label of the existing Pod running in the worker node and the new Pod. (B1) determining a label association between a corresponding worker node and the new pod by comparing the labels of, and the step (c) further considers the label association determined for each worker node, and the new pod is placed. And selecting a worker node to be used.

In an embodiment, the step (c) includes selecting a worker node in which the new Pod is to be placed based on a score calculated by assigning a weight to each of the package redundancy and the label association.

In one embodiment, the step (d) relates to the selected worker node as a controller manager that is located in the master node and interlocks with the plurality of worker nodes to place pods in each worker node. And providing information.

In one embodiment, the method further includes the step (e) of storing and managing active package group information of each of the plurality of worker nodes by the scheduling device.

In an embodiment, in the step (e), when the new Pod is placed in the selected worker node, the scheduling device reflects the program packages of the new Pod and reflects the active package group information of the selected worker node. And updating.

In one embodiment, in the step (e), when a Pod running in one of the plurality of worker nodes is suspended or deleted, the scheduling device reflects the program packages of the Pod that has been suspended or deleted. And updating active package group information of the one worker node.

Embodiments of the present invention may be implemented using a computer program recorded on a computer-readable recording medium as a computer program that executes the above-described operation or method through a computer.

According to the present invention, for each of a plurality of worker nodes operated in a container-based virtualization system, packages of a corresponding worker node are compared with an active package group including all packages of all Pods running in the corresponding worker node and packages of a new Pod. By calculating the degree of redundancy and selecting a worker node to which the new Pod will be placed among the plurality of worker nodes in consideration of the degree of package redundancy calculated for each worker node, the data stored in the memory when the container is executed in each worker node By increasing redundancy, memory usage reduction through KSM (Kernel Same-page Merging) can be improved, and performance of a virtualization system can be improved by increasing the number of executable containers or pods including containers per worker node.

In addition, it is possible to further improve the memory saving effect by selecting the worker node in which the new Pod will be placed by considering the package redundancy and label association with the new Pod for each worker node, and swapping between worker nodes due to memory shortage. It can prevent operation.

Furthermore, those of ordinary skill in the art to which the present invention pertains will clearly understand from the following description that various embodiments according to the present invention can solve various technical problems not mentioned above.

1 is a diagram showing the structure of a container orchestration platform of a virtualization system to which the present invention is applied.
2 is a block diagram showing a scheduling device according to an embodiment of the present invention.
3 is a flowchart illustrating a scheduling method according to an embodiment of the present invention.
4 is a diagram showing an example of a Docker container created using a Docker image.
5 is a diagram illustrating Pods arranged for each worker node.
6 is a diagram illustrating an example of a Pod specification used in a scheduling method according to an embodiment of the present invention.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings in order to clarify a solution to the technical problem of the present invention. However, in describing the present invention, if the description of the related known technology rather obscure the subject matter of the present invention, a description thereof will be omitted. In addition, terms used in the present specification are terms defined in consideration of functions in the present invention, and these may vary according to intentions or customs of designers, manufacturers, and the like. Therefore, the definition of terms to be described later should be made based on the contents throughout the present specification.

1 illustrates an exemplary container orchestration platform structure of a virtualization system 2 to which the present invention is applied.

As shown in Fig. 1, the virtualization system 2 is a master in order to perform container management or orchestration such as creating, placing, executing, stopping execution, and deleting containers when providing computer resource virtualization services. It may include a master node 10 and a worker node 20.

The container provided by the virtualization system 2 is a subject that executes a user's workload, and may be a Docker, a Linux container (LXC), a rocket, or a clean container. In addition, the virtualization system 2 may include a container orchestration platform to perform management or orchestration of such containers.

In this specification, for convenience of explanation, the virtualization system 2 includes Kubernetes, an open source platform designed by Google as a container orchestration platform and managed by the Linux Foundation, and Docker as a container. ), but the technical idea of the present invention can be applied to other container orchestration platforms or virtualization systems using other containers.

In addition, in the present specification, a pod is a container set including at least one container, and refers to a container set constituting a basic unit of container scheduling.

First, the master node 10 is configured to manage the entire cluster consisting of a plurality of worker nodes 20. To this end, the master node 10 may include an API server 12, Etcd 14, a controller manager 16, and the like, as well as the scheduling device 100 according to the present invention.

The API server 12 receives a user request through a user interface (UI) or communicates between a master node and a worker node. Etcd(14) plays the role of a database that stores the configuration values and states of each node and cluster. The controller manager 16, as a subject executing a user's workload, adjusts the storage space of a pod including at least one container, and assigns a label of a pod to be added or deleted.

The worker node 20 is configured to receive an instruction from the master node 10 and perform an actual operation. To this end, the worker node 20 includes a Kubelet 22, a proxy or Kube-proxy 24, and the like, and the worker node 20 includes at least one container 28. Pod 26 is placed.

The Kublet 22 communicates with the API server 12 of the master node 10 and receives a command or transmits the state of the worker node 20 to the master node 10. The proxy 24 routes network traffic incoming to the worker node 20 to the container 28 in the pod 26 and manages network communication between the master node 10 and the worker node 20.

For example, when a command to execute a Pod is received through a user's web browser or a shell command line interface, the API server 12 of the master node 10 sends the received command to the controller manager 16. Then, the controller manager 16 queries the scheduling device 100 on which worker nodes to place and execute the target Pod. When the scheduling device 100 selects a worker node to execute the corresponding Pod, the controller manager 16 interlocks with the Kublet 22 of the worker node 20 to place and execute the target Pod on the corresponding worker node 20. .

In this case, the scheduling device 100 adds a filtering step to check worker nodes that satisfy the requirements of the target Pod among several worker nodes, and add scores to worker nodes that have passed the filtering according to a certain criterion. Thus, through a scoring step of selecting an optimal worker node, a worker node to execute the target Pod can be selected. For example, in the filtering step, a rule (PodFitsResources) that restricts only worker nodes capable of providing the CPU and memory capacity required by the target Pod to candidate nodes may be applied. In addition, in the scoring step, a rule (LeastRequestedPriority) that gives a high score to candidate nodes that are expected to have a large amount of spare resources because the number of previously deployed Pods among candidate nodes that have passed filtering may be applied. When two or more worker nodes having the same score exist after completing the scoring step, the scheduling apparatus 100 may randomly select one of the two or more worker nodes.

In addition, the scheduling apparatus 100 may further apply various scheduling rules in addition to the above-described rules in order to select a worker node in which a new Pod is to be placed. For example, the scheduling device 100 may apply a NodeAffinity rule or a PodAffinity rule. The NodeAffinity rule is a rule for placing a new Pod in a worker node having a label corresponding to a label indicated in the specification of the new Pod among worker nodes. The PodAffinity rule is a rule that places a new Pod in a worker node running by a Pod with a label corresponding to the label indicated in the specification of the new Pod. That is, the NodeAffinity rule and the PodAffinity rule are rules for selecting a worker node in which a new Pod will be installed in consideration of the label association between the worker node and the new Pod.

In this way, a rule is given to the specification of the new Pod to consider whether there is an association between the label of each worker node or an existing Pod running in each worker node and the label of the new Pod, and the scheduling device 100 causes the worker It is possible to select a worker node to place a new Pod according to the label association between the node and the new Pod. In this case, the scheduling device 100 may perform a matching operation between the label of the worker node or the existing Pod that is already running and the label of the new Pod using various operators, and a label is attached to the worker node or the existing Pod in advance. It may be configured to store information about whether or not in advance.

However, in a cloud service that needs to provide a container execution environment to a large number of users, such as MEC (Multi-access Edge Computing) of 5G communication, it is difficult not only to check what label the Pods running by each user have. Rather, since it is not possible to accurately define what a label that can be described freely by the user is used, situations in which it is impossible to determine the association with the label of the new Pod may occur.

Meanwhile, the KSM (Kernel Same-page Merging) function provided by the Linux kernel scans the memory to find duplicate pages in which the same kernel codes are stored among the pages of the memory, and merges the duplicate pages into one page. It is a function to reduce memory usage by reducing the amount of data stored through a number of processes by providing only memory address mapping information composed of relatively little data.

However, when a new Pod is placed in a worker node selected based on the label association between the worker node and the new Pod, even if the KSM function is used, the effect of reducing the memory usage may be insignificant or not. This is because container scheduling or Pod scheduling relies on label values that can be freely described by the user. For example, if User A's Database Pod, labeled db, uses MySQL, and User B's new Database Pod uses Oracle, then User B's new Database Pod is on the worker node where User A's Database Pod is running. Even if is deployed and executed, the kernel codes stored in the memory are different, so the effect of reducing the memory usage of the KSM function cannot be expected.

Therefore, in the virtualization system (2) supporting Multi-Tenants, an automated algorithm that determines the association between the new Pod and the worker node in a more formal manner, and places the new Pod on the selected worker node by reflecting the determined association. Need to provide.

Accordingly, the scheduling device 100 according to the present invention checks the program packages of the container or Pod running in each worker node 20 and the program packages of the new Pod, and the new Pod in the worker node with high package redundancy. It is possible to maximize the effect of KSM (Kernel Same-page Merging) by performing scheduling so that they are deployed.

The scheduling apparatus 100 may be implemented as a combination between hardware including a memory and a processor, and software stored in the memory and executed by the processor. In addition, the scheduling device 100 may be implemented in a form integrated with the master node 10 as shown in FIG. 1, or may be implemented as a separate device distinct from the master node 10 according to embodiments.

2 is a block diagram of a scheduling apparatus 100 according to an embodiment of the present invention.

As shown in FIG. 2, the scheduling apparatus 100 according to an embodiment of the present invention uses a plurality of worker nodes 20 to schedule containers of a virtualization system 2 that provides a computer resource virtualization service. As an example, it includes a package confirmation unit 110, a node selection unit 120, and a node information providing unit 130, and may further include a package information management unit 140.

The package checking unit 110 is configured to check program packages used when the new pod is executed through images of a hierarchical format used in a new pod including at least one container.

The node selection unit 120, for each of the plurality of worker nodes 20, selects an active package group including all program packages of all Pods running in the worker node and program packages of the new Pods. In comparison, the package redundancy between the worker node and the new Pod is calculated, and the worker node to which the new Pod is to be placed is selected from among the plurality of worker nodes 20 in consideration of the package redundancy calculated for each worker node. do. In this case, the node selection unit 120 may select a worker node having the highest package redundancy among the plurality of worker nodes 20. That is, the node selection unit 120 may select a worker node having the most program packages overlapping with the program packages of the new Pod among the plurality of worker nodes 20 as a worker node in which the new Pod will be placed. .

In an embodiment, the node selection unit 120 includes, for each of the plurality of worker nodes 20, a label of a corresponding worker node or a label of an existing Pod running in the worker node and a label of the new Pod. By comparison, a label affinity between a corresponding worker node and the new pod may be determined, and a worker node in which the new pod will be placed may be selected by further considering the label association determined for each worker node.

In this case, the node selection unit 120 may select a worker node in which the new Pod is to be placed based on a score calculated by assigning a weight to each worker node's package redundancy and label association. That is, the node selection unit 120 may select a worker node with the highest score calculated by assigning weights to package redundancy and label association among the plurality of worker nodes 20 as the worker node in which the new Pod will be placed. have.

The node information providing unit 130 provides information on the worker node selected by the node selection unit 120 to the master node 10 managing the plurality of worker nodes 20, and the master node 10 ) To place the new Pod in the selected worker node. In this case, the node information providing unit 130 is located in the master node 10 and interlocked with the plurality of worker nodes 20 to place pods in each worker node, as the selected controller manager. It can be configured to provide information about worker nodes.

Meanwhile, the package information management unit 140 is configured to store and manage active package group information of each of the plurality of worker nodes, and to provide the active package group information to the node selection unit 120.

In this case, the package information management unit 140 reflects the program packages of the new pod when the new pod is placed on the worker node selected by the node selection unit 120, and stores active package group information of the selected worker node. It can be configured to update. That is, if a program package that is not included in the active package group of the selected worker node among the program packages of the new Pod exists, the package information management unit 140 stores information on the program package of the selected worker node. Can be added to the active package group information.

In addition, the package information management unit 140 reflects the program packages of the pod that has been suspended or deleted when the pod running in any one worker node among the plurality of worker nodes 20 is stopped or deleted. It can be configured to update the active package group information. That is, if there is a program package that does not overlap with program packages of other Pods still running in the worker node among the program packages of the Pod that has been suspended or deleted, the package information management unit 140 provides information on the corresponding program package. Can be deleted from the active package group information of the worker node.

As described above, the package identification unit 110, the node selection unit 120, the node information providing unit 130, and the package information management unit 140 included in the scheduling device 100 include hardware including a memory, a processor, and the like, and It can be implemented as a combination between software stored in and executed by the processor.

3 is a flowchart illustrating a scheduling method according to an embodiment of the present invention. Detailed operations of the scheduling device 100 will be described in time series with reference to FIG. 3.

As shown in FIG. 3, the package checking unit 110 of the scheduling device 100 checks the program packages of the new Pod through images in a hierarchical format used to create a new Pod including at least one container. (S310).

4 shows an example of a docker container Y created by using the docker image X.

As shown in FIG. 4, a docker, which is a kind of container provided in the above-described virtualization system 2, contains images in a hierarchical format such as overlay2 or AUFS (Advanced multi-layered Unification File System). use.

For example, the docker container Y may be generated through a docker image X consisting of three layers. In this case, the Docker image X is generated through the creation of a Dockerfile and a Docker build command, and is composed of a base image 1 and added layer images 2 and 3. The base image 1 is identified by the Linux distribution and its version number, and the added hierarchical images 2 and 3 can be identified by the installed package name and the version number of the corresponding package. Pods contain one or more of these Docker containers.

Accordingly, when the pod is executed, the scheduling device 100 may grasp the Linux distribution used in the pod and the installed program packages from the Docker image used by the containers included in the pod. For example, the scheduling device 100 may use a command such as “docker image inspect $DockerImageName” to check information on each image layer or a program package list included in the docker image of a new Pod.

Referring back to FIG. 3, the node selection unit 120 of the scheduling device 100 includes, for each of the plurality of worker nodes 20, an active package group including all program packages of all Pods running in the corresponding worker node ( active package group) and the program packages of the new Pod are compared to calculate the degree of package redundancy between the corresponding worker node and the new node (S320).

In addition, the node selector 120 selects a worker node in which the new Pod is to be placed among the plurality of worker nodes in consideration of the package redundancy calculated for each worker node (S330).

Then, the node information providing unit 130 of the scheduling device 100 transfers the information on the worker node selected by the node selection unit 120 to the master node 10 that manages the plurality of worker nodes 20. By providing, it causes the master node 10 to place the new Pod in the selected worker node (S340). In this case, the node information providing unit 130 is located in the master node 10 and interlocked with the plurality of worker nodes 20 to place pods in each worker node, as the selected controller manager. Can provide information about worker nodes

Then, the package information management unit 140 of the scheduling device 100 stores and manages active package group information of each of the plurality of worker nodes. That is, when the new Pod is placed on a worker node selected by the node selection unit 120, the package information management unit 140 updates the active package group information of the selected worker node by reflecting the program packages of the new Pod. Do (S350). For example, if a program package that is not included in the active package group of the selected worker node among the program packages of the new Pod exists, the package information management unit 140 stores information on the program package of the selected worker node. Can be added to the active package group information.

In addition, the package information management unit 140 reflects the program packages of the pod that has been suspended or deleted when the pod running in any one worker node among the plurality of worker nodes 20 is stopped or deleted. Active package group information can also be updated. For example, if there is a program package that does not overlap with program packages of other Pods still running in the worker node among program packages of a Pod that has been suspended or deleted, the package information management unit 140 provides information on the corresponding program package. Can be deleted from the active package group information of the worker node.

Then, the scheduling apparatus 100 may repeat the above-described steps (S310 to S350) when there is another new pod to be disposed in the worker node.

5 illustrates Pods arranged for each worker node.

As shown in Fig. 5, two pods A are arranged and executed in worker node 1 (20a), and one pod A and one pod B are arranged and executed in worker node 2 (20b). In a situation in which two Pod Bs are arranged and executed in node N (20n), the scheduling device 100 selects a worker node to deploy a new Pod C from among a plurality of worker nodes 20a, 20b, and 20n. I can.

Table 1 below shows program packages included in the Docker image of Pods A, B, and C shown in FIG. 5.

Pod A's image Pod B's image Pod C's image Package 1 Package 4 Package 3 Package 2 Package 5 Package 4 Package 3 Package 5

As shown in Table 1, the docker image used by Pod A includes packages 1, 2, and 3, the docker image used by Pod B includes packages 4 and 5, and the docker image used by Pod C. If packages 3, 4, and 5 are installed in, the active package group of each worker node can be displayed as shown in Table 2 below.

Worker node 1 Worker node 2 … Worker node N Package 1 Package 1 Package 4 Package 2 Package 2 Package 5 Package 3 Package 3 … Package 4 Package 5

That is, the active package group of worker node 1 (20a) includes packages 1, 2, and 3, and the active package group of worker node 2 (20b) includes packages 1, 2, 3, 4, 5, The active package group of worker node N (20n) includes packages 4 and 5.

In this case, as described above, the scheduling apparatus 100 may select a worker node in which Pod C is to be placed by applying a so-called PackageAffinity rule that selects a worker node to place a new Pod based on package redundancy as described above.

That is, package 3 is the overlapping package between the packages of Pod C and the active package group of worker node 1 (20a), and Package 3 is the overlapping package between packages of Pod C and the active package group of worker node 2 (20b). , 4 and 5, and packages 4 and 5 are overlapping packages between the packages of Pod C and the active package group of the worker node 3 (20c). Accordingly, the node selector 120 of the scheduling apparatus 100 may select the worker node 2 (20b) having the highest package redundancy with Pod C as the worker node in which Pod C is to be placed.

Then, the node information providing unit 130 of the scheduling device 100 provides information on the worker node 2 to the controller manager 16 of the master node 10, and the controller manager 16 provides the worker node 2 Place Pod C in (20b) to make it run.

In one embodiment, the node selection unit 120 of the scheduling device 100 is for each of a plurality of worker nodes (20a, 20b, 20n), the label of the worker node or the existing running on the worker node. By comparing the label of the Pod and the label of the new Pod C, the label affinity between the corresponding worker node and the new Pod is determined, and the worker node where the new Pod C is to be placed is further considered by further considering the label association determined for each worker node. It can also be configured to select.

6 shows an example of a Pod specification used in a scheduling method according to an embodiment of the present invention.

As shown in FIG. 6, in the process of selecting a worker node in which a new Pod is to be deployed, a worker node according to a label association with a new Pod along with a PackageAffinity rule for selecting a worker node according to a package redundancy with a new Pod NodeAffinity rule or PodAffinity rule for selecting a may be applied. That is, the Pod specification (S) shown in FIG. 6 shows a case where the PodAffinity rule (S1) and the PackageAffinity rule (S2) are applied at the same time. Since the packageAffinity rule S2 does not require a label matching process, lableSelector subfields used in the NodeAffinity rule or PodAffinity rule are omitted.

In this case, the scheduling device 100 assigns a first weight of 10 to the label association according to the PodAffinity rule (S1), and a second weight of 90 to the package redundancy according to the PackageAffinity rule (S2) for each worker node. The score may be calculated, and a worker node having the highest calculated score may be selected as a worker node in which the new Pod is to be placed.

Meanwhile, the embodiments according to the present invention may be implemented as a computer system and a computer program that drives the computer system. When the embodiments of the present invention are implemented as a computer program, the components of the present invention are program segments that execute a corresponding operation or task through a corresponding computer system. These computer programs or program segments may be stored in various computer-readable recording media. The computer-readable recording medium includes all types of media that record data that can be read by a computer system. For example, the computer-readable recording medium may include ROM, RAM, EEPROM, register, flash memory, CD-ROM, magnetic tape, hard disk, floppy disk, or optical data recording device. In addition, such a recording medium can be distributed and arranged in computer systems connected through various networks to store or execute program codes in a distributed manner.

According to the present invention, for each of a plurality of worker nodes operated in a container-based virtualization system, packages of a corresponding worker node are compared with an active package group including all packages of all Pods running in the corresponding worker node and packages of a new Pod. By calculating the degree of redundancy and selecting a worker node to which the new Pod will be placed among the plurality of worker nodes in consideration of the degree of package redundancy calculated for each worker node, the data stored in the memory when the container is executed in each worker node By increasing redundancy, memory usage reduction through KSM (Kernel Same-page Merging) can be improved, and performance of a virtualization system can be improved by increasing the number of executable containers or pods including containers per worker node.

In addition, it is possible to further improve the memory saving effect by selecting the worker node in which the new Pod will be placed by considering the package redundancy and label association with the new Pod for each worker node, and swapping between worker nodes due to memory shortage. It can prevent operation.

Further, it goes without saying that the embodiments according to the present invention can solve various technical problems other than those mentioned in the present specification in the related technical field as well as in the relevant technical field.

The present invention has been described with reference to specific examples. However, those skilled in the art will clearly understand that various modified embodiments may be implemented within the technical scope of the present invention. Therefore, the embodiments disclosed above should be considered from an explanatory point of view rather than a limiting point of view. That is, the scope of the true technical idea of the present invention is shown in the claims, and all differences within the scope of equivalents thereto should be interpreted as being included in the present invention.

100: scheduling device 110: package confirmation unit
120: node selection unit 130: node information providing unit
140: package information management unit

Claims (15)

As a scheduling device for scheduling a container of a virtualization system that provides computer resource virtualization services using a plurality of worker nodes,
A package identification unit that checks program packages of the new pod through images of a hierarchical format used to create a new pod including at least one container;
For each of the plurality of worker nodes, the active package group including all program packages of all Pods running in the corresponding worker node and the program packages of the new Pod are compared to calculate a package redundancy between the corresponding worker node and the new Pod. And a node selection unit that selects a worker node in which the new Pod is to be placed among the plurality of worker nodes in consideration of a package redundancy calculated for each worker node; And
A node information providing unit that provides information on the worker node selected by the node selection unit to a master node that manages the plurality of worker nodes, and causes the master node to place the new pod in the selected worker node. Scheduling device comprising. The method of claim 1,
For each of the plurality of worker nodes, the node selection unit compares a label of a corresponding worker node or a label of an existing Pod running in the worker node with a label of the new Pod to determine a label association between the worker node and the new Pod. And selecting a worker node in which the new Pod is to be placed by further considering the label correlation determined for each worker node. The method of claim 2,
And the node selection unit is configured to select a worker node to which the new Pod is to be placed based on a score calculated by assigning weights to the package redundancy and the label association, respectively. The method of claim 1,
The node information providing unit is configured to provide information on the selected worker node to a controller manager located at the master node and interlocking with the plurality of worker nodes to place pods in each worker node. Scheduling device. The method of claim 1,
The scheduling apparatus further comprises a package information management unit that stores and manages active package group information of each of the plurality of worker nodes, and provides the active package group information to the node selection unit. The method of claim 5,
And the package information management unit is configured to update active package group information of the selected worker node by reflecting program packages of the new Pod when the new Pod is disposed in the selected worker node. The method of claim 5,
The package information management unit, when a Pod running in one of the plurality of worker nodes is stopped or deleted, the active package group information of the one worker node reflects the program packages of the pod that has been stopped or deleted. Scheduling device, characterized in that configured to update. As a scheduling method in which a scheduling device of a virtualization system providing a computer resource virtualization service using a plurality of worker nodes schedules a container,
(A) checking, by the scheduling device, program packages of the new pod through images of a hierarchical format used to create a new pod including at least one container;
For each of the plurality of worker nodes, the scheduling device compares the active package group including all program packages of all Pods running in the worker node with the program packages of the new Pod, and the package between the worker node and the new Pod (B) calculating the degree of redundancy;
(C) selecting, by the scheduling device, a worker node in which the new Pod is to be placed among the plurality of worker nodes in consideration of a package redundancy calculated for each worker node; And
The scheduling device provides information on the worker node selected in step (c) to a master node that manages the plurality of worker nodes, causing the master node to place the new pod in the selected worker node. (d) a scheduling method comprising the step. The method of claim 8,
In the method, before step (c), the scheduling device compares the label of the worker node or the label of the existing Pod running in the worker node with the label of the new Pod for each of the plurality of worker nodes. Further comprising (b1) determining a label association between the worker node and the new Pod,
The step (c) further comprises the step of selecting a worker node in which the new Pod is to be placed in consideration of a label correlation determined for each worker node. The method of claim 9,
The step (c) includes selecting a worker node in which the new Pod is to be placed based on a score calculated by assigning weights to the package redundancy and the label association, respectively. The method of claim 8,
The step (d) includes providing information on the selected worker node to a controller manager that is located in the master node and interlocks with the plurality of worker nodes to place pods in each worker node. Scheduling method comprising a. The method of claim 8,
The method further comprises the step (e) of storing and managing active package group information of each of the plurality of worker nodes by the scheduling device. The method of claim 12,
In the step (e), when the new Pod is placed in the selected worker node, the scheduling device includes updating active package group information of the selected worker node by reflecting program packages of the new Pod. Scheduling method, characterized in that. The method of claim 12,
In the step (e), when a Pod running in any one of the plurality of worker nodes is stopped or deleted, the scheduling device reflects the program packages of the Pod that has been stopped or deleted, And updating active package group information. A computer program recorded on a computer-readable recording medium as a computer program for executing the method according to any one of claims 8 to 14 through a computer.

Images