JP2013210683A - Autoscaling method, autoscaling program and computer node - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a technology for allowing application of a system with excellent efficiency of charging.SOLUTION: A master node 110 manages tasks to be executed by the respective slave nodes 120. A schedule information storage part 113 stores management information for managing the tasks to be executed by the respective slave nodes 120. A schedule processing part 112 verifies whether or not there is a slave node 120 capable of terminating processing of a task of a processing request in a delivery. In addition, the schedule processing part 112 verifies whether or not a computer node capable of terminating processing of the task of the processing request can be prepared in the delivery when a task whose processing can be terminated even by other computer nodes is moved. As results of verification, when both are negative, a scale out processing part 114 increases the slave nodes 120 by scale out.

Description

  The present invention relates to an autoscaling method, an autoscaling program, and a computer node for controlling the number of computer nodes provided in a system.

  In a conventional on-premises system, the amount of resources that the system has is fixed, so it is impossible to accept processing requests from clients that exceed the amount of resources that the system has.

  On the other hand, in a system using cloud computing, which has been developing in recent years, the amount of resources that the system has can be changed dynamically. Therefore, even if the system resource consumption exceeds the amount of resources that the system has by executing the processing requested by the client, requests from the client can be accepted by dynamically increasing the system resources. It becomes possible.

  As a technique for increasing / decreasing the resources of such a system, there is a technique called scale up / scale down for increasing / decreasing the amount of resources of a virtual computer node in the system. However, the increase in resources of virtualized computer nodes has a limit on the amount of physical machine resources.

  As another technique for increasing / decreasing system resources, there is a technique called scale-out / scale shrink that increases / decreases the number of computer nodes in the system. With this technology, there is no limit to the amount of physical machine resources in increasing the amount of system resources. There is also a technology called autoscaling that automatically scales out and shrinks according to the resource consumption rate of the system.

  In a distributed batch system, when a new batch process is requested, the batch process being executed on one processing server is transferred to another server, and the new batch process is executed on the server that can be processed. Technology for managing deadlines in batch processing is known.

JP 2002-342098 A

  However, as described above, if autoscaling is performed according to the resource consumption rate of the system, unnecessary computer nodes are added due to scale-out, or processing that is being executed by the system is forcibly interrupted due to erroneous scale shrinkage. There is a case. In cloud computing, when pay-per-use according to the number of computer nodes is performed, useless charge may occur due to useless scale-out.

  In one aspect, an object of the present invention is to provide a technique that enables operation of a system with high charging efficiency.

  In one aspect, in the autoscaling method, in a system that executes the requested processing distributed to a plurality of computer nodes, the computer node that manages the tasks executed in the system accepts the processing request for which the delivery date is specified. The management information stored in the storage unit that manages the tasks executed by the computer nodes included in the system is referred to, a simulation for allocating the task of the processing request to the computer nodes is executed, and the simulation is performed by the allocation simulation. There is no computer node that can finish processing the requested task within the due date, and there is a computer node that can finish processing the requested task within the due date even if another computer node moves the task that can finish within the due date. If it is determined that the system cannot be prepared, It executes a process of adding a computer node.

  In one aspect, it is possible to operate a system with good charging efficiency.

It is a figure explaining the subject of the system implement | achieved by on-premises. It is a figure explaining the subject of the system implement | achieved by cloud computing. It is a figure which shows the structural example of the system by this Embodiment. It is a figure which shows the function structural example of each node by this Embodiment. It is a figure which shows the example of the virtual machine system which implement | achieves the node by this Embodiment. It is a figure explaining the example of the task allocation simulation of the process request by the schedule process part in the master node of this Embodiment. It is a figure explaining the example of the task allocation simulation of the process request by the schedule process part in the master node of this Embodiment. It is a figure explaining the example of the task allocation simulation of the process request by the schedule process part in the master node of this Embodiment. It is a figure explaining the example of the task allocation simulation of the process request by the schedule process part in the master node of this Embodiment. It is a figure explaining the example of the movement simulation of the task by the reschedule process part in the master node of this Embodiment. It is a figure explaining the example of the movement simulation of the task by the reschedule process part in the master node of this Embodiment. It is a figure explaining the example which performs lock setting to the slave node by the reschedule process part in the master node of this Embodiment. It is a figure explaining the example which performs lock setting to the slave node by the reschedule process part in the master node of this Embodiment. It is a figure explaining the example which performs lock release of the slave node by the schedule process part in the master node of this Embodiment. It is a process flowchart at the time of the processing request reception by the master node of this Embodiment. It is a process flowchart at the time of the processing request reception by the master node of this Embodiment. It is a process flowchart of the reschedule by the master node of this Embodiment.

  Hereinafter, the present embodiment will be described with reference to the drawings.

  FIG. 1 is a diagram illustrating a problem of a system realized on-premises.

In the example shown in FIG. 1, the vertical length of the figure indicating the task indicates the resource consumption amount of the task, and the horizontal length indicates the processing time of the task. In the example shown in FIG. 1, the vertical axis of the graph indicates the system resource consumption, and the horizontal axis indicates the passage of time. t _{0 to} t ₃ indicate equally spaced times.

  In an on-premises system, the amount of resources that the system has is fixed. In other words, it is not possible to perform processing of resource consumption exceeding the resource amount of the system in advance. In the example shown in FIG. 1, the system resource line indicates the amount of resources the system has.

For example, in FIG. 1 (A), the relative system, the processing requirements of the task # 1 Task # 4, and what was almost at the same time t _0. At this time, the system starts processing in the order in which processing requests are received, in this case, task # 1, task # 2, task # 3, and task # 4. However, as shown in FIG. 1 (A), when the processing of task # 3 is started, the resource consumption of the system reaches the resource amount of the system and the processing of task # 4 cannot be started. The processing request cannot be accepted.

  The example shown in FIG. 1B is an example of a system that performs scheduling. In a scheduling system, the processing time of a task is estimated when a processing request is received, and even if there is no available resource when the processing request occurs, the task of the processing request that is received after the termination of other tasks that are running Schedule the task to execute

For example, it is assumed that the delivery date of the process of task # 4 received last is time t ₃ . As shown in FIG. 1 (B), since the processing end time of the most processing end time is earlier task # 3 is a t _1, when scheduling tasks # 4 Following task # 3, the processing end time of the task # 4 Becomes t _{3 and} is in time for delivery. In this case, the processing request for task # 4 can be accepted by the system.

However, in the example shown in FIG. 1 (C), the most processing end time to schedule tasks # 4 after an early task # 2, the processing end time of the task # 4 exceeds the t _3, not in time for delivery. In this case, the processing request for task # 4 is not accepted by the system. In an on-premises system, processing requests may not be accepted even if scheduling is performed.

  The opposite of such on-premises technology is cloud computing technology. The amount of system resources realized by cloud computing is variable.

  In cloud computing, each computer node included in the system is realized by, for example, a virtual machine (VM). In the following, a computer node provided in the system is also simply referred to as a node.

  In cloud computing, as a technology for changing the amount of system resources, for example, there is a scale-up / scale-down technology. Scale-up is a technology that increases the resource amount of a node. Scale-down is a technology that reduces the amount of resources in a node. If scale-up technology is used, for example, even if a task with a new processing request is not executed in time for the current resource, increasing the resource amount of the node will increase the amount of new processing request. Tasks can be executed in time for delivery.

  However, the resources that can be scaled up are limited by the resources of the physical machine that implements the node that is the virtual machine, and there is a limit to scaling up the node. Also, usually when multiple virtual machine nodes are placed on a single physical machine and physical machine resources are allocated to each node and there is no surplus, it can be specified without reducing the performance of other nodes. It is impossible to improve the performance of the node. For example, in a multi-tenant environment, multiple tenant virtual machines operate on one physical machine, and the resource amount of other tenants is reduced in order to increase the resource amount of a certain tenant's virtual machine. Is not easy. Therefore, even if scale-up technology is used, not all requested processing tasks can be executed with guaranteed delivery times.

  In cloud computing, there are scale-out and scale-shrink technologies as well as scale-up and scale-down technologies. Scale-out is a technology for adding nodes to the system. Scale shrink is a technology that removes nodes from the system. By using scale-out technology, it is possible to execute almost all required processing tasks with guaranteed delivery times.

  However, in the cloud computing world, service usage fees are usually pay-as-you-go, and service usage fees increase as the number of nodes in a system increases due to scale-out.

  FIG. 2 is a diagram for explaining a problem of a system realized by cloud computing.

In the example shown in FIG. 2, the vertical length of the graphic indicating the task indicates the resource consumption of the task, and the horizontal length indicates the processing time of the task. In the example shown in FIG. 2, the vertical axis of the graph represents the total resource consumption of the nodes constituting the system, and the horizontal axis represents the passage of time. t _{0 to} t ₃ indicate equally spaced times. In the example shown in FIG. 2, the system resource line indicates the total amount of resources possessed by the nodes constituting the system.

In FIG. 2A, it is assumed that the system initially includes three nodes VM # 1 to VM # 3. Here, the system, the processing requirements of the task # 1 Task # 4, and what was almost at the same time t _0. At this time, in the system, tasks are assigned to the nodes in the order in which processing requests are received, in this case, task # 1, task # 2, task # 3, and task # 4, and processing is started. However, as shown in FIG. 2A, when task # 3 processing is assigned to the node of VM # 3, the resource consumption of all nodes in the system becomes the upper limit, and task # 4 processing can be assigned. There are no nodes.

  At this time, for example, as shown in FIG. 2A, scale-out is performed in the system, and a node of VM # 4 is added to the system. As shown in FIG. 2A, when a VM # 4 node is added to the system by scale-out, the requested task # 4 can be executed. For example, in cloud computing, as a service of an IaaS (Infrastructure as a Service) vendor that provides infrastructure such as virtual machines and networks as a service, it automatically scales out when the system resource consumption rate exceeds a predetermined level There is service. In cloud computing, the technology for automatically expanding / reducing a system is also called autoscaling.

Here, it is assumed delivery of processing of the task # 4 is time t _3. As shown in FIG. 2 (A), since the processing end time of the most processing end time is earlier task # 3 is a t _1, when scheduling tasks # 4 Following task # 3, the processing end time of the task # 4 Becomes t _{3 and} is in time for delivery.

  As described above, if task scheduling can be performed, it is possible to execute the processing of task # 4 in time for the delivery date without adding a VM # 4 node due to scale-out. However, such a determination cannot be made only by looking at resource consumption like the above-described IaaS service. As described above, in cloud computing, the usage fee increases as the number of nodes increases, so if you can execute task processing in time for delivery without adding nodes, you do not want to add nodes. There is a request.

  Further, in order to reduce the use fee of the useless node, the scale shrink is performed on the node which is determined not to be operated in the system, and the node is removed from the system. For example, in cloud computing, as a service of an IaaS vendor, when a node's CPU (Central Processing Unit) usage rate falls below a predetermined level, task processing is not performed on the node and only middleware such as an OS operates. There is a service that automatically performs scale shrinkage.

  However, just because the resource consumption of the node is small, the requested task is not necessarily processed. For example, in the example shown in FIG. 2B, in the node of VM # 3, when the processing of task # 3 is completed, the resource consumption is extremely reduced. However, in the example shown in FIG. 2B, task # 4 with a small amount of resource consumption is executed in parallel with task # 3 in the node of VM # 3. If scale shrink is performed on the node of VM # 3 simultaneously with the end of the process of task # 3, the process of task # 4 is forcibly terminated. In this way, when scale shrinkage is determined just by looking at resource consumption as in the above-described IaaS vendor service, for example, processing of a task with low resource consumption, such as task # 4 shown in FIG. There is a possibility of accidentally removing a node that is being executed.

  In the following, an autoscaling technique according to this embodiment for solving such a problem will be described.

  FIG. 3 is a diagram illustrating a configuration example of a system according to the present embodiment.

  In this embodiment, the system 100 shown in FIG. 3 is assumed to be a computer system composed of nodes of virtual machines provided from the IaaS side in cloud computing. The system 100 executes processing requested by the client 200 in a distributed manner at a plurality of nodes. The system 100 and the client 200 are connected by a network 300 such as a LAN (Local Area Network) or the Internet. The system 100 includes a master node 110 and a slave node 120.

  The master node 110 receives a processing request from the client 200 and assigns a task to each slave node 120 and manages a task executed by the system 100. Note that the master node 110 according to the present embodiment performs auto-scaling processing such as scale-out and scale shrink of the slave node 120. Note that the master node 110 may be one of the slave nodes 120 at the same time.

  The slave node 120 is a computer node that executes a processing request task assigned by the master node 110. The slave node 120 can process a plurality of tasks in parallel. The slave node 120 is added to the system 100 or deleted from the system 100 by the auto scaling process. For example, in FIG. 3, when the slave node 120a of #a and the slave node 120b of #b are executing task processing, if there are processing requests that cannot be executed by those slave nodes 120, #c A slave node 120 c is added to the system 100. For example, if there is no task to be executed by the slave node 120c of #c, the slave node 120c of #c is deleted from the system 100.

  The client 200 is a computer having a host application that makes a request to the system 100 to execute a process provided by the system 100. In the example illustrated in FIG. 1, the client 200 is a device outside the system 100, but the client 200 may be a node inside the system 100, for example.

  FIG. 4 is a diagram illustrating a functional configuration example of each node according to the present embodiment.

  The master node 110 includes a client communication unit 111, a schedule processing unit 112, a schedule information storage unit 113, a scale-out processing unit 114, a slave communication unit 115, a reschedule processing unit 116, and a scale shrink processing unit 117.

  The client communication unit 111 receives a processing request from the client 200. The client communication unit 111 passes the received request processing to the schedule processing unit 112 if it can be executed in the system 100. If the received request process cannot be executed in the system 100, the client communication unit 111 responds to the client 200 to that effect. The processing that cannot be executed in the system 100 is, for example, processing of an application that does not exist in the slave node 120 or large-scale processing that cannot be completed by the delivery date in the slave node 120 of one virtual machine. A technique for executing a large-scale process in a distributed manner at a plurality of nodes is out of the scope of the technique according to the present embodiment, and will not be described here. The client communication unit 111 notifies the client 200 of the processing result received from the slave node 120.

  When the client communication unit 111 receives a processing request for which a delivery date is specified, the schedule processing unit 112 refers to the management information stored in the schedule information storage unit 113, and sends the task of the processing request to the slave node 120. Run the assigned simulation.

  The schedule information storage unit 113 is a management information storage unit that manages tasks executed by the slave nodes 120 included in the system 100. In the management information stored in the schedule information storage unit 113, schedules of tasks to be executed by all the slave nodes 120 are recorded.

  More specifically, the schedule processing unit 112 first detects the slave node 120 that can finish processing the task of the received processing request within the specified delivery date in the current state. Here, the schedule processing unit 112 includes not only the slave node 120 that can execute processing immediately, but also the slave node 120 that can end the processing within the delivery date even if the processing request task is executed after the processing of other tasks ends. To detect. The schedule processing unit 112 selects the slave node 120 to which the task of the processing request is assigned from the slave nodes 120 detected here. Here, the locked slave node 120 is not subject to detection. In this embodiment, the lock means that the slave node 120 is set out of the task allocation target of the processing request.

  If there is no slave node 120 that can finish the processing request task within the due date in the current state, the schedule processing unit 112 detects the task that can finish the processing within the due date even if the slave node 120 moves to another slave node 120. . The schedule processing unit 112 determines whether it is possible to prepare a slave node 120 that can complete the processing of the requested task within the due date by moving the detected task. If it is determined that the slave node 120 capable of completing the processing request task within the due date can be prepared by moving the task, the schedule processing unit 112 performs the process of moving the task to another slave node 120. This is executed via the slave communication unit 115. The task may be moved by, for example, a method in which processing of the task is stopped at the source slave node 120 and restarted at the destination slave node 120, or an image of the task being executed at the source slave node 120. A method of transferring data to the destination slave node 120 may also be used. In the present embodiment, it is assumed that the task is moved by a method in which the task processing is restarted by the slave node 120 of the movement destination. The schedule processing unit 112 determines the slave node 120 that has become free due to the movement of the task as the slave node 120 to which the task requested to be processed is assigned.

  If the schedule processing unit 112 cannot prepare a slave node 120 that can complete the processing of the requested task within the delivery date even if the task is moved, if there is a slave node 120 that is locked, if the lock is released, the schedule processing unit 112 Determine whether the requested task can be completed within the due date. When it is determined that the processing request task can be completed within the due date due to the unlocking, the schedule processing unit 112 unlocks the locked slave node 120. The schedule processing unit 112 determines the slave node 120 whose lock has been released as the slave node 120 to which the task requested to be processed is assigned.

  The schedule processing unit 112 determines that the slave node 120 is to be added to the system 100 by scale-out when the slave node 120 to which the processing request task is assigned cannot be found in the processing so far.

  The scale-out processing unit 114 performs processing for adding computer nodes to the system 100 by scale-out. More specifically, the scale-out processing unit 114 accesses the management computer on the IaaS side using an interface prepared on the IaaS side, and requests scale-out to the own system 100.

  The slave communication unit 115 performs communication with the slave node 120. For example, the slave communication unit 115 requests processing of the task to the slave node 120 to which the task of the received processing request is assigned. Further, the slave communication unit 115 receives the processing result of the requested task from the slave node 120 as a response. Further, when the task is moved, the slave communication unit 115 notifies the movement-source slave node 120 of the stop of the corresponding task and notifies the movement-destination slave node 120 of the execution of the corresponding task. .

  For example, the reschedule processing unit 116 periodically refers to the management information stored in the schedule information storage unit 113 and sets the slave node 120 having no task to be executed as a target of scale shrink.

  In addition, the reschedule processing unit 116 refers to the management information stored in the schedule information storage unit 113 and executes a simulation of moving a task operating on a certain slave node 120 to another slave node 120. The reschedule processing unit 116 detects a task that can be processed within the delivery date even if it moves to another slave node 120.

  The reschedule processing unit 116 determines whether the slave node 120 having no task to be executed can be prepared by moving the detected task. If it is determined that the slave node 120 having no task to be executed can be prepared by moving the task, the reschedule processing unit 116 performs the process of moving the corresponding task to another slave node 120 via the slave communication unit 115. And execute. The movement of the task is the same as in the case of the schedule processing unit 112 described above. The reschedule processing unit 116 sets the slave node 120 in which there is no task to be executed due to the movement of the task as a target of scale shrink.

  In addition, the reschedule processing unit 116 determines whether or not the slave node 120 in which the number of tasks to be executed is a predetermined number or less can be prepared by moving the detected task. When it is determined that the slave node 120 whose number of tasks to be executed is less than or equal to the predetermined number can be prepared by moving the task, the reschedule processing unit 116 performs the process of moving the corresponding task to another slave node 120 by slave communication This is executed via the unit 115. The reschedule processing unit 116 sets a lock on the slave node 120 in which the number of tasks to be executed is less than or equal to a predetermined number due to task movement. As a rule, a task with a new processing request is not assigned to the slave node 120 that is locked, so that after the processing of the remaining task is completed, the slave node 120 becomes a target of scale shrink.

  The scale shrink processing unit 117 performs processing for deleting the target slave node 120 from the system 100 by scale shrink. More specifically, the scale shrink processing unit 117 accesses the management computer on the IaaS side using an interface prepared on the IaaS side, and requests scale shrink of the target slave node 120.

  The slave node 120 includes a master communication unit 121 and an application 122. As shown in FIG. 4, the slave node 120 can operate a plurality of types of applications 122a, b,. When a processing request task is assigned, the task processing is executed by the application 122 corresponding to the processing request.

  The master communication unit 121 communicates with the master node 110. For example, the master communication unit 121 receives a task execution request or stop request from the master node 110, and performs task start or stop processing. When the task processing is completed, the master communication unit 121 returns a processing result response to the master node 110.

  FIG. 5 is a diagram illustrating an example of a virtual machine system that implements a node according to the present embodiment.

  The virtual machine system shown in FIG. 5 is a system in which one or a plurality of virtual machines operate on one physical machine, for example. In the example of the virtual machine system illustrated in FIG. 5, a plurality of virtual machines 30 including a master node 110 and a slave node 120 are operating using resources of the computer 10 that is a physical machine such as the CPU 11 and the memory 12. . In the virtual machine system shown in FIG. 5, the master node 110 and the slave node 120 are realized by the same physical machine. However, in the cloud computing environment, the master node 110 and each slave node 120 are different from each other. Often implemented with physical machines.

  In the virtual machine system shown in FIG. 5, the hypervisor 20 is software that realizes a virtual environment using the computer 10. The virtual machine 30 including the master node 110 and the slave node 120 can be constructed on the hypervisor 20.

  The computer 10 that realizes the master node 110 and the slave node 120 shown in FIG. 4 as virtual machines includes, for example, a CPU 11, a memory 12 serving as a main memory, a storage device 13, a communication device 14, a medium reading / writing device 15, and an input device. 16 and hardware such as an output device 17 are provided. The storage device 13 is an external storage device such as an HDD (Hard Disk Drive), an auxiliary storage device, or the like. The medium reading / writing device 15 is, for example, a CD-R (Compact Disc Recordable) drive or a DVD-R (Digital Versatile Disc Recordable) drive. The input device 16 is, for example, a keyboard / mouse. The output device 17 is a display device such as a display. Note that the hardware configuration of the computer 10 can be arbitrarily designed as necessary.

  The master node 110, the slave node 120, and the functional units included in each node illustrated in FIG. 4 can be realized by hardware such as the CPU 11 and the memory 12 included in the computer 10 and a software program. A program executable by the computer 10 is stored in, for example, the storage device 13, read into the memory 12 at the time of execution, and executed by the CPU 11.

  The computer 10 can also read a program directly from a portable recording medium and execute processing according to the program. In addition, each time the program is transferred from the server computer, the computer 10 can sequentially execute processing according to the received program. Furthermore, this program can be recorded on a computer-readable recording medium.

  Hereinafter, processing by the master node 110 according to the present embodiment will be described using a more specific example.

  FIG. 6 to FIG. 9 are diagrams for explaining an example of processing request task allocation simulation by the schedule processing unit in the master node of this embodiment.

  FIG. 6A shows an example of task notation. In FIG. 6A, a filled graphic represents task processing. The vertical length of the graphic indicating the task processing indicates the resource consumption of the task, and the horizontal length indicates the processing time of the task. In FIG. 6A, the right end of the white figure indicates the delivery date of the task. The delivery date is a time limit for ending the processing of the task specified in the client 200. In the following description, all tasks are represented as shown in FIG.

FIG. 6 (B) at the time of accepting the processing request from the client 200 at time t _0, indicating the schedule of tasks each slave node 120a system 100 is provided, b is executed. As shown in FIG. 6B, the slave nodes 120 included in the system 100 at this time are two slave nodes: the slave node 120a of #a and the slave node 120b of #b. Note that the schedule information storage unit 113 stores management information obtained by converting the schedule of tasks executed by the slave node 120 included in the system 100 as shown in the graph of FIG. 6B, for example. In FIG. 6B, the vertical axis of the graph indicates the resource consumption of the slave node, and the horizontal axis indicates the passage of time. t _{−1 to} t ₃ indicate equally spaced times.

FIG. 6C is a diagram showing the task X of the processing request received from the client 200 at time t ₀ . As shown in FIG. 6C, the processing of the processing request task X is indicated by hatching so that it can be distinguished from other tasks. As shown in FIG. 6C, for the task X of the processing request, the delivery date at time t ₃ is designated.

  Note that there are many known techniques for estimating task processing time and resource consumption, such as a method obtained from past results or a method obtained theoretically, and a detailed description thereof will be omitted here. The estimation of task processing time differs depending on the processing targeted by the task. For example, the processing time of image processing is affected by the image file size. Processing using a database is affected by the number of accesses to the database. For example, when the resource consumption amount of a task is determined for each application 122 that performs task processing, the value can be used. The slave node 120 may be inquired about the resource consumption. In addition, various known techniques can be used.

  In the master node 110, when receiving the processing request, the schedule processing unit 112 first verifies whether the task of the processing request can be assigned to the slave node 120 at present.

FIG. 7 (A) is a task X of processing requests, to initiate the process performed at the time t _0, an example of a verification that assigned to the slave node 120a of # a. Further, FIG. 7 (B), the task X of processing requests, to initiate the process performed at the time t _0, an example of a verification that assigned to the slave node 120b of # b. In both cases, the resource consumption amount of the node exceeds the resource limit amount of the node, so the verification result is NG.

FIG. 7C shows an example of verification in which the task X of the processing request is scheduled after the processing of the task A # 1 executed by the slave node 120a of #a, which ends processing earliest. In this case, since the processing end time of the task X of the processing request exceeds the delivery date t ₃ , the verification result is NG.

  Next, the schedule processing unit 112 performs verification to move a task that can be completed by the delivery date even if restarted by another task. As shown in FIG. 8A, the task B # 3 executed by the slave node 120b of #b can be moved to the slave node 120a of #a in terms of resource consumption, and the slave node 120a of #a Even after restarting, the process can be completed by the delivery date. FIG. 8B shows an example of verification in which the task X of the processing request is assigned to the slave node 120b of #b whose resource consumption has decreased due to the movement of the task shown in FIG. 8A. Even if the task is moved, the resource consumption of the node exceeds the resource limit of the node, so the verification result is NG.

  Since there is no other slave node 120 that is locked, the schedule processing unit 112 determines to add the slave nodes 120 by the scale-out processing by the scale-out processing unit 114. FIG. 9 shows a state in which the task X of the processing request is assigned to the #c slave node 120c added by the scale-out processing unit 114.

  As described above, the master node 110 according to the present embodiment completes the processing within the delivery date regardless of whether the verification including scheduling is performed in the current state of the slave node 120 or further verification of moving the task is performed. Execute scale-out only when a task with a processing request cannot be assigned. As a result, useless scale-out can be suppressed, so that it is possible to operate the system 100 efficiently without useless charging.

  10 and 11 are diagrams for explaining an example of task movement simulation by the reschedule processing unit in the master node of the present embodiment.

Figure 10 shows the at time t _0, each slave node 120a of system 100 is provided, b, a schedule for the tasks that c runs. As shown in FIG. 10, there are three slave nodes 120 included in the system 100 at this time point: a slave node 120a of #a, a slave node 120b of #b, and a slave node 120c of #c.

  First, in the master node 110, the reschedule processing unit 116 periodically checks the schedule information storage unit 113 to check whether there is a slave node 120 that has no task to be executed. As shown in FIG. 10, since all the slave nodes 120 are executing the process at this time, there is no slave node 120 having no task to be executed. At this time, the reschedule processing unit 116 determines that there is no slave node 120 that can be scale-shrinked as it is.

  Next, the reschedule processing unit 116 performs verification to move a task that can be completed by the delivery date even if restarted by another task.

FIG. 11A shows an example of verification in which the task B # 1 executed by the slave node 120b of #b is restarted by the slave node 120a of #a. As shown in FIG. 11 (A), and restarting the task B # 1 in other slave nodes 120, end time of the processing for exceeds the delivery time t _2, the verification result is NG. The reschedule processing unit 116 determines that the scale shrink cannot be performed on the slave node 120b of #b by moving the task.

FIG. 11B shows an example of verification in which the task C # 1 executed by the slave node 120c of #c is restarted by the slave node 120a of #a. As shown in FIG. 11 (B), the task C # 1 is capable of handling ends up delivery t ₃ Restarting the slave node 120a of # a. Further, when the task C # 1 is moved to the slave node 120a of #a, there is no task executed by the slave node 120c of #C, so that scale shrink can be performed on the slave node 120c of #C.

  The reschedule processing unit 116 instructs the #C slave node 120c to stop the task C # 1 and instructs the #A slave node 120a to execute the task C # 1 via the slave communication unit 115. Since there is no task to be executed by the #C slave node 120c, the reschedule processing unit 116 sets the #C slave node 120c as the target of scale shrink. The scale shrink processing unit 117 executes scale shrink processing for the slave node 120c of #C.

  As described above, the master node 110 according to the present embodiment actively creates the slave node 120 having no task to be executed and moves the scale shrink by moving the task to another slave node 120. As a result, the useless slave node 120 can be positively deleted, so that the system 100 can be efficiently operated without generating useless charging.

  12 and 13 are diagrams illustrating an example in which lock setting is performed on a slave node by a reschedule processing unit in the master node of the present embodiment.

12, at the time of time t _0, indicating the schedule of tasks each slave node 120a system 100 is provided, b is executed. As shown in FIG. 12, the slave nodes 120 included in the system 100 at this time are the slave node 120a of #a and the slave node 120b of #b.

  In the master node 110, the reschedule processing unit 116, when a slave node 120 that does not have a task to be executed even if a task is moved cannot be prepared, a slave whose number of tasks to be executed by moving the task becomes a predetermined number or less. It is verified whether the node 120 can be prepared. For example, the predetermined number is 1 here.

FIG. 13A shows an example of verification in which the task B # 2 executed by the slave node 120b of #b is restarted by the slave node 120a of #a. Figure 13 (A), the task B # 2 is capable of handling ends up delivery t ₃ Restarting the slave node 120a of # a. Incidentally, the task B # 1 to the slave node 120b of # b is executed, If you try to restart the slave node 120a of # a, since the end time of processing exceeds the delivery time t _2, the task B # 1 is moved Can not.

  If the task B # 2 is moved to the slave node 120a of #a, as shown in FIG. 13B, the number of tasks executed by the slave node 120b of #b is 1 or less. At this time, the reschedule processing unit 116 instructs the slave node 120b of #B to stop task B # 2 and instructs the slave node 120a of #A to execute task B # 2 via the slave communication unit 115. To do.

  In addition, as shown in FIG. 13B, a lock is set on the slave node 120b of #b in which the task to be executed is only B # 1. The information of the slave node 120 to which the lock is set is recorded in a storage unit accessible by the schedule processing unit 112, such as the schedule information storage unit 113. Thus, in principle, a new processing request task is not assigned to the slave node 120b of #b. Therefore, after the remaining # B1 task is finished, the scale shrink processing unit 117 performs the slave node 120b of #b. Can be deleted.

  As described above, the master node 110 according to the present embodiment moves a task to another slave node 120, actively creates a slave node 120 with few tasks to be executed, and issues a new processing request to the slave node 120. Suppress task assignments. As a result, the environment of the system 100 becomes an environment in which the slave node 120 having no task to be executed can be easily created, and the unnecessary slave node 120 can be positively deleted. The system 100 can be operated.

  FIG. 14 is a diagram illustrating an example in which the slave node is unlocked by the schedule processing unit in the master node according to the present embodiment.

  Here, it is assumed that the system 100 receives a task X processing request shown in FIG. 6C from the client 200 in the state shown in FIG. At this time, the schedule processing unit 112 tries to assign the task X of the processing request to the slave node 120a of #a which is not locked as shown in FIG. 14A, but the resource consumption of the node is Cannot allocate because the resource limit is exceeded. Further, there is no other slave node 120 that can move the task.

  At this time, the schedule processing unit 112 verifies whether the task X of the processing request can be completed by the delivery date at the slave node 120b of #b if the lock of the locked slave node 120b of #b is released. As shown in FIG. 14B, since the task X of the processing request can be completed by the due date on the slave node 120b of #b, the schedule processing unit 112 locks the slave node 120b of #b being locked. And the task X of the processing request is assigned to the slave node 120b of #b.

  As described above, the processing request task is assigned to the locked slave node 120 only when the processing request task cannot be assigned to another slave node 120. As a result, the occurrence of scale-out can be suppressed while maintaining an environment in which scale shrinking is easily performed to the limit, so that it is possible to operate the system 100 with high efficiency without causing unnecessary charging.

  The master node 110 according to the present embodiment places the highest priority on the completion of task processing within the delivery date, and therefore the system 100 always maintains the minimum processing performance.

  FIG. 15 and FIG. 16 are processing flowcharts when a processing request is accepted by the master node of this embodiment.

  In the master node 110, the client communication unit 111 receives a processing request from the client (step S10). A delivery date is specified in the processing request accepted here. The client communication unit 111 determines whether the processing request can be accepted (step S11). If the processing request is not acceptable (NO in step S11), the client communication unit 111 responds to the client that the processing request cannot be accepted (step S12) and ends the processing.

  If the processing request is acceptable (YES in step S11), the schedule processing unit 112 refers to the management information in the schedule information storage unit 113, and performs a simulation of assigning the processing request task to the current slave node 120 (step). S13). Here, for example, verification including scheduling is performed as shown in FIG.

  The schedule processing unit 112 determines whether it is possible to assign a processing request task to the current slave node 120 (step S14). If the processing request task can be allocated (YES in step S14), the schedule processing unit 112 determines the slave node 120 to which the processing request task is allocated (step S15). The slave communication unit 115 requests the determined slave node 120 to process the processing request task (step S22).

  If the processing request task cannot be assigned (NO in step S14), the schedule processing unit 112 refers to the management information in the schedule information storage unit 113, moves the existing task, and assigns the processing request task. A simulation is performed (step S16). Here, for example, as shown in FIG. 8, if there is an existing task that can be completed within the delivery date even if it is moved to another slave node 120 and re-executed, the existing task is moved to the resource It is verified whether it is possible to assign a processing request task to the slave node 120 that has become free.

  The schedule processing unit 112 determines whether or not it is possible to assign a processing request task by moving an existing task (step S17). If the processing request task can be assigned (YES in step S17), the schedule processing unit 112 moves the existing task (step S18). More specifically, the schedule processing unit 112 requests the slave node 120 that is the source of the existing task to stop the task via the slave communication unit 115. In addition, the schedule processing unit 112 requests the execution of the task to the slave node 120 to which the existing task is moved via the slave communication unit 115. The slave communication unit 115 requests the processing of the requested task to the slave node 120 whose resources have become free due to the movement of the existing task (step S22).

  If it is not possible to assign the processing request task (NO in step S17), the schedule processing unit 112 determines that the processing request is not issued if the slave node 120 being locked exists and the slave node 120 is unlocked. It is determined whether task assignment is possible (step S19). If it is possible to release the lock and assign the processing request task (YES in step S19), the schedule processing unit 112 unlocks the locked slave node 120 (step S20). The slave communication unit 115 requests the processing of the processing request task to the slave node 120 whose lock has been released (step S22). This case is the case shown in the example of FIG.

  If there is no slave node 120 that is locked, or if it is not possible to assign a processing-requested task even if the lock is released (NO in step S19), the scale-out processing unit 114 executes a scale-out process ( Step S21). Due to the scale-out, slave nodes 120 are added to the system 100. The slave communication unit 115 requests the added slave node 120 to process the processing request task (step S22). This case is the case shown in the example of FIG.

  When the slave communication unit 115 receives a response to the processing request from the slave node 120 (Step S23), the client communication unit 111 transmits the response to the client (Step S24).

  FIG. 17 is a flowchart of rescheduling processing by the master node according to this embodiment.

  In the master node 110, the reschedule processing unit 116 starts this processing at a predetermined timing.

  The reschedule processing unit 116 refers to the management information in the schedule information storage unit 113 and determines whether there is a slave node 120 that does not have a task to be executed at present (step S30). If there is a slave node 120 that has no task to execute (YES in step S30), the scale shrink processing unit 117 executes a scale shrink process for the slave node 120 (step S31). The slave node 120 is deleted from the system 100 by the scale shrink.

  The reschedule processing unit 116 refers to the management information in the schedule information storage unit 113 and performs a simulation of moving the task (step S32). Here, for example, as shown in FIG. 11, when there is a task that can finish processing within the delivery date even if it is moved to another slave node 120 and re-executed, there is no task to move and execute that task. It is verified whether the slave node 120 can be generated. For example, as shown in FIG. 13, when there is a task that can be completed within the delivery date even if it is moved to another slave node 120 and re-executed, a predetermined number of tasks are moved and executed. It is verified whether the following slave node 120 can be generated.

  The reschedule processing unit 116 determines whether it is possible to generate a slave node 120 that does not have a task to be executed by moving a task, that is, whether the task can be moved and scale shrink can be performed (step S33). If the scale shrink can be performed by moving the task (YES in step S33), the reschedule processing unit 116 executes the movement of the corresponding task (step S34). More specifically, the reschedule processing unit 116 requests the task's source slave node 120 to stop the task via the slave communication unit 115. Further, the reschedule processing unit 116 requests the execution of the task from the slave node 120 to which the task is moved via the slave communication unit 115. The scale shrink processing unit 117 executes scale shrink processing for the slave node 120 that has no task to be executed due to task movement (step S35). The slave node 120 is deleted from the system 100 by the scale shrink.

  If the scale shrink is not possible even if the task is moved (NO in step S33), the reschedule processing unit 116 determines whether there is a slave node 120 that moves the task and executes a predetermined number of tasks or less. (Step S36). If there is no slave node 120 in which the number of tasks to be executed is less than or equal to the predetermined number even if the task is moved (NO in step S36), the reschedule processing unit 116 ends the process.

  If there is a slave node 120 in which the number of tasks to be moved and executed is less than or equal to the predetermined number (YES in step S36), the reschedule processing unit 116 moves the corresponding task (step S37). More specifically, the reschedule processing unit 116 requests the task's source slave node 120 to stop the task via the slave communication unit 115. Further, the reschedule processing unit 116 requests the execution of the task from the slave node 120 to which the task is moved via the slave communication unit 115. The reschedule processing unit 116 sets a lock on the slave node 120 whose task to be executed by moving the task is equal to or less than a predetermined number (step S38). If all of the tasks remaining without being unlocked are completed, the slave node 120 to which the lock is set becomes the target of scale shrink in the subsequent steps S30 and S31.

  Although the present embodiment has been described above, the present invention can naturally be modified in various ways within the scope of the gist thereof.

DESCRIPTION OF SYMBOLS 100 System 110 Master node 111 Client communication part 112 Schedule processing part 113 Schedule information storage part 114 Scale out processing part 115 Slave communication part 116 Reschedule processing part 117 Scale shrink processing part 120 Slave node 121 Master communication part 122 Application 200 Client 300 Network

Claims (6)

In a system in which requested processing is distributed to and executed by a plurality of computer nodes, a computer node that manages tasks executed in the system includes:
When a processing request with a specified delivery date is received, the management information stored in the storage unit for managing the task executed by the computer node of the system is referred to, and the task of the processing request is assigned to the computer node. Run the simulation,
According to the simulation of the assignment, there is no computer node that can finish the processing request task within the due date, and even if another computer node moves the task that can finish the processing within the due date, the processing request task is delivered. An auto-scaling method comprising: executing a process of adding a computer node to the system when it is determined that a computer node capable of terminating the process cannot be prepared in the system. A computer node that manages the task further includes:
Referring to the management information, a simulation for moving a task operating on a certain computer node to another computer node is executed,
When it is determined by the simulation of the movement that a computer node having no task to be executed can be prepared by moving a task that can be completed within the delivery date even at another computer node, the other computer node can also be within the delivery date. Move the task that can finish processing,
The autoscaling method according to claim 1, further comprising: deleting a computer node having no task to be executed from the system. A computer node that manages the task further includes:
When it is determined by the simulation of the movement that a computer node can be prepared in which the number of tasks to be executed is less than or equal to a predetermined number by moving a task that can be completed within the delivery date even by another computer node. Move the task that can be completed within the delivery date even at the computer node,
The autoscaling method according to claim 2, wherein a process of setting a computer node having a number of tasks to be executed to a predetermined number or less as a task request assignment target is executed. In the process of adding a computer node to the system, a computer capable of completing the processing request task within the delivery date even if the setting of the computer node set to be excluded from the processing request task allocation target is canceled. 4. The autoscaling method according to claim 3, further comprising adding a computer node to the system when it is determined that a node cannot be prepared. In a system in which requested processing is distributed to a plurality of computer nodes, a computer node that manages tasks executed in the system is provided.
When a processing request with a specified delivery date is received, the management information stored in the storage unit for managing the task executed by the computer node of the system is referred to, and the task of the processing request is assigned to the computer node. Run the simulation,
According to the simulation of the assignment, there is no computer node that can finish the processing request task within the due date, and even if another computer node moves the task that can finish the processing within the due date, the processing request task is delivered. An auto-scaling program that causes the system to execute a process to add a computer node when it is determined that a computer node that can complete the process cannot be prepared. In a system having a plurality of computer nodes, a computer node for managing tasks executed in the system,
A management information storage unit for managing tasks executed by computer nodes included in the system;
A schedule processing unit that executes a simulation of referring to the management information and allocating a task of the processing request to a computer node when a processing request with a specified delivery date is received;
There is no computer node capable of completing the processing request task within the due date by the schedule processing unit, and even if another computer node moves a task capable of completing the processing within the due date, the processing request task is delivered. A computer node comprising: a scale-out processing unit that executes processing for adding a computer node to the system when it is determined that a computer node capable of terminating processing cannot be prepared in the system.

Images