Information processing device and program

Abstract

To provide an information processing device and program for reducing load of an edge server on which micro service is operated.SOLUTION: In an information processing device for carrying out dispersion of load between a plurality of edge servers, load on one or more micro services which are operated on the plurality of edge servers is acquired, and a specific rate of requests among one or more request issued to a first micro service operated on a first server and on which load equal to or more than a specific amount is applied is transferred to a second micro service operated on one or more of second servers.SELECTED DRAWING: Figure 1

Description

Technical Field

[0001] This disclosure relates to edge computing.

Background Art

[0002] In an information processing system that performs processing by a plurality of edge servers, there is a technique for load distribution among edge servers. For example, Patent Document 1 discloses an apparatus for predictively deploying microservices in a network including a plurality of edge servers.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] As new technologies such as machine learning become widespread, it is considered that the importance of edge servers that provide computing resources to mobile bodies will increase.

[0005] This disclosure aims to reduce the load on edge servers where microservices are operating.

Means for Solving the Problems

[0006] One aspect of an embodiment of this disclosure is obtaining the load on one or more microservices operating in each of a plurality of edge servers, and determining to transfer a predetermined proportion of requests among one or more requests issued for a first microservice operating in a first edge server and having a load of a predetermined amount or more to a second microservice operating in one or more second edge servers, and an information processing apparatus including a control unit that executes the above.

[0007] One embodiment of the present disclosure is: This program causes a computer to perform the following actions: obtain the load on one or more microservices running on each of multiple edge servers; and decide to forward a predetermined percentage of the one or more requests issued to a first microservice running on a first edge server that is experiencing a load exceeding a predetermined amount to a second microservice running on one or more second edge servers.

[0008] Other embodiments include a method by which the above-mentioned device is executed, and a computer-readable storage medium that non-temporarily stores the above-mentioned program. [Effects of the Invention]

[0009] According to this disclosure, the load on edge servers running microservices can be reduced. [Brief explanation of the drawing]

[0010] [Figure 1] A schematic diagram of the edge computing system according to the embodiment. [Figure 2] Configuration diagram of load balancing controller and edge server. [Figure 3] An overview diagram of microservices running on edge servers. [Figure 4] A diagram illustrating the forwarding of requests between microservices. [Figure 5] A diagram illustrating the process of identifying bottlenecks. [Figure 6] A flowchart of the processes performed by the load balancing controller. [Modes for carrying out the invention]

[0011] One architecture that reduces latency and traffic is an edge computing system, which places edge servers between the terminal and the cloud, and has the edge servers process requests from the terminal. For example, if the terminal is installed in a vehicle (connected car), the amount of access from the vehicle to each edge server changes in conjunction with traffic volume, which may cause an uneven load on some edge servers. If the load is unevenly distributed to some edge servers, those edge servers may not be able to perform at their intended level.

[0012] To address this, a system has been devised to forward requests from terminals between edge servers based on the volume of requests issued to each edge server and the resources available to each edge server, so that the load is not concentrated on certain edge servers.

[0013] Incidentally, in recent years, the adoption of microservices architecture in edge servers has been increasing. Microservices architecture is an architecture in which requests are processed in a distributed manner by multiple microservices. In a microservices architecture, for example, multiple microservices work together on a single edge server to provide a single application.

[0014] In such an architecture, resources are allocated on a microservice basis, making it difficult to accurately determine whether an overload condition is occurring by simply looking at the total volume of requests arriving at the edge server from the terminal or the remaining hardware resources of the edge server. For example, even if a particular microservice is experiencing a heavy load and processing via that microservice is delayed, this cannot be detected. To solve this problem, it is necessary to perform load assessments for each microservice running on the edge server.

[0015] The information processing device relating to the first aspect of this disclosure is: Obtaining the load on one or more microservices operating on each of a plurality of edge servers, and determining to transfer a predetermined percentage of requests among one or more requests issued to a first microservice operating on a first edge server and having a load of a predetermined amount or more, to a second microservice operating on one or more second edge servers. A control unit that executes the above is provided.

[0016] The information processing apparatus according to the present disclosure is a control device for performing load distribution among a plurality of edge servers. The control unit is configured to be able to individually monitor the loads of a plurality of microservices operating on each of the plurality of edge servers, for example. The load of each microservice can be obtained, for example, by measuring the round-trip time for a request. The control unit transfers a predetermined percentage of one or more requests issued to a microservice (also referred to as the first microservice) determined to have a load of a predetermined amount or more, to a second microservice. The second microservice can be, for example, a microservice operating on another edge server and having sufficient resources.

[0017] Note that the control unit may detect the existence of the first microservice by using as a trigger that a value related to the performance of the application has deteriorated from a predetermined value. For example, when the throughput of the first application falls below a predetermined value, the control unit may measure the time required for processing each of one or more microservices. The control unit can identify, for example, a microservice whose time exceeds a predetermined value as the first microservice (having a load of a predetermined amount or more).

[0018] In addition, when transferring a request, the control unit may determine a predetermined ratio in consideration of the load of the second microservice. For example, the control unit can determine a predetermined ratio such that both the load on the first microservice and the load on the second microservice are below a predetermined value.

[0019] Also, after starting the transfer of the request, the control unit may change the predetermined ratio according to the load situation, or may stop the transfer of the request depending on the situation. For example, after the transfer starts, if the load on the second microservice exceeds a predetermined value, the transfer may be stopped.

[0020] Hereinafter, specific embodiments of the present disclosure will be described based on the drawings. The hardware configuration, module configuration, functional configuration, etc. described in each embodiment are not intended to limit the technical scope of the disclosure only to those, unless otherwise specified.

[0021] (First Embodiment) The outline of the edge computing system according to the first embodiment will be described with reference to FIG. 1. The edge computing system according to the present embodiment includes a plurality of edge servers 2 and a load balancer 1. In the edge computing system according to the present embodiment, each of the plurality of vehicles A is connected to one of the plurality of edge servers 2 via wireless communication.

[0022] Vehicle A is an automobile equipped with a terminal capable of wireless communication with the edge server 2. Vehicle A (in-vehicle terminal) can provide a predetermined service to the passengers by communicating with one of the plurality of edge servers 2.

[0023] Multiple edge servers 2 are positioned in each area so that they can process requests from terminals at a location closer to the terminals than the cloud. For example, an edge server 2 receives a request sent from vehicle A, performs predetermined processing, and returns the result to vehicle A. Although omitted in Figure 1 for simplicity, relay devices such as base stations, access points, or routers may exist between edge server 2 and vehicle A. Requests from vehicle A reach edge server 2 via these relay devices.

[0024] The load balancing controller 1 is a device that manages multiple edge servers 2. In this embodiment, the load balancing controller 1 monitors the load on each edge server 2, and if the load becomes concentrated on a particular edge server 2, it forwards requests sent from vehicle A to other edge servers 2 to distribute the load. In this embodiment, as an example of the load, the number of requests issued to applications within the edge server 2 per unit time is used as an example.

[0025] The load balancing controller 1 and each edge server 2 are configured to communicate with each other via a network. The network is, for example, a public network such as the Internet, or a backbone network such as an optical network.

[0026] In this embodiment, multiple edge servers 2 are geographically distributed. Each edge server 2 may have a defined geographical area or communication area it is responsible for. For example, an edge server 2 may cooperate with base stations and relay devices such as routers, in which case it may be responsible for the area covered by the cooperating relay device. The edge server 2 receives and processes data from vehicles A located within its assigned area.

[0027] On edge server 2, multiple microservices are running, and these microservices work together to provide the services of a given application. Although multiple applications may run on edge server 2, in this embodiment, for the sake of simplicity, we will assume that only one application runs on edge server 2. In this embodiment, the same application is running on multiple edge servers 2, and identical microservices are running to provide that application.

[0028] Requests entered into the application are distributed to each microservice, and processing progresses as multiple microservices send and receive requests.

[0029] Furthermore, the edge server 2 is configured to notify the load balancing controller 1 of information regarding the load on the running microservices. The notification of load information may be triggered by either the edge server 2 or the load balancing controller 1. Based on the information received from each edge server 2, the load balancing controller 1 detects if any of the edge servers 2 are experiencing an overloaded state. An overloaded state refers to a condition where each microservice receives more requests per unit of time than it can handle.

[0030] When the load balancing controller 1 detects that a microservice is overloaded, it forwards a predetermined percentage of the requests issued to that microservice per unit time to other microservices running on other edge servers 2 in order to reduce the load on that microservice. The predetermined percentage is determined appropriately depending on the load status of the source and destination microservices.

[0031] For example, if a microservice is experiencing an overload, the load balancing controller 1 will distribute more requests to microservices running on other edge servers 2. Furthermore, if the microservice to which the requests are forwarded has limited surplus resources, the forwarding rate will be set lower compared to when resources are abundant. This prevents other microservices that receive requests from an overloaded microservice from becoming overloaded themselves, thus enabling efficient load balancing.

[0032] [Device configuration] Next, the configuration of each device that makes up the system will be described. Figure 2 is a schematic diagram showing an example of the configuration of the load balancing controller 1 and edge server 2 according to this embodiment.

[0033] First, let's explain the load balancing controller 1. The load balancing controller 1 controls the processor (CPU, GPU, etc.), main memory (RAM, ROM, etc.), and auxiliary storage (EPROM, hard disk drive, removable media). It can be configured as a computer having (a, etc.). The auxiliary storage device stores the operating system (OS), various programs, various tables, etc., and by executing the programs stored there, various functions (software modules) that match a predetermined purpose, as described later, can be realized. However, some or all of the functions may be realized as hardware modules by hardware circuits such as ASICs and FPGAs.

[0034] The load balancing controller 1 is configured to include a control unit 11, a storage unit 12, and a communication unit 13.

[0035] The control unit 11 is a computing unit that realizes various functions of the load balancing controller 1 by executing a predetermined program. The control unit 11 can be implemented by a hardware processor such as a CPU. The control unit 11 may also be configured to include RAM, ROM (Read Only Memory), cache memory, etc.

[0036] The control unit 11 is comprised of two software modules: a monitoring unit 111 and a traffic control unit 112. Each software module may be implemented by the control unit 11 (e.g., CPU) executing a program stored in the storage unit 12, which will be described later.

[0037] The monitoring unit 111 monitors the load on the managed edge servers 2. In this embodiment, the monitoring unit 111 periodically communicates with each edge server 2 to obtain information on the load on the running microservices, and based on this data, determines whether or not there are any microservices running on each edge server 2 that are in an overloaded state.

[0038] If the traffic control unit 112 determines, through the processing described above, that a microservice is in an overloaded state, it decides to forward requests to that microservice to another microservice running on another edge server 2. The traffic control unit 112 also generates a command (hereinafter referred to as a forwarding command) for this forwarding and sends it to the target edge server 2. A forwarding command is a command to forward requests issued to a microservice running on a predetermined edge server 2 to another microservice running on another edge server 2. Upon receiving a forwarding command, the edge server 2 forwards requests to the target microservice to the other edge server 2. The specific method will be described later.

[0039] The memory unit 12 is a means for storing information and is composed of storage media such as RAM, magnetic disks, and flash memory. The memory unit 12 stores programs executed by the control unit 11, data used by those programs, and so on. Furthermore, the storage unit 12 stores a configuration database 12A, which contains information indicating the configuration of the edge servers 2 under its management. The configuration database 12A includes, for example, information about the network configuration, hardware configuration, software configuration, and applications running on each edge server 2.

[0040] The communication unit 13 is a communication module that communicates with a predetermined network. The communication unit 13 is, for example, a NIC (Network Interface Card), an optical fiber interface, etc. The communication unit 13 is connected to an access network such as a LAN (Local Area Network) or an optical fiber network by wire, for example, and connects the load balancing controller 1 to the network through the access network.

[0041] Next, we will describe the configuration of Edge Server 2. The edge server 2, like the load balancing controller 1, can be configured as a computer having a processor (CPU, GPU, etc.), main memory (RAM, ROM, etc.), and auxiliary memory (EPROM, hard disk drive, removable media, etc.). Also like the load balancing controller 1, some or all of the functions of the edge server 2 may be implemented as hardware modules using hardware circuits such as ASICs and FPGAs.

[0042] The edge server 2 is configured to include a control unit 21, a storage unit 22, and a communication unit 23.

[0043] The control unit 21 is a computing unit that realizes various functions of the edge server 2 by executing a predetermined program. The control unit 21 can be implemented by a hardware processor such as a CPU. The control unit 21 may also be configured to include RAM, ROM (Read Only Memory), cache memory, etc.

[0044] The control unit 21 is comprised of three software modules: a load notification unit 211, a gateway 212, and an application execution unit. Each software module may be implemented by the control unit 21 (e.g., CPU) executing a program stored in the storage unit 12, which will be described later.

[0045] The load notification unit 211 transmits information regarding the performance of applications running on the edge server 2 or the load of microservices to the load balancing controller 1. The load notification unit 211 may measure a value related to the performance of a predetermined application based on an inquiry from the load balancing controller 1 and notify the load balancing controller 1. Examples of values ​​related to the application's performance include processing throughput. Furthermore, the load notification unit 211 may measure values ​​related to the load of the microservices based on an inquiry from the load balancing controller 1 and notify the load balancing controller 1. Examples of information related to the load of the microservices include the number of requests received by the target microservice per unit time and the time required for processing.

[0046] The gateway 212 receives requests from terminals included in the edge computing system. A request is a request issued to an application executed on the edge server 2. In this embodiment, the terminal sending the request is typically an in-vehicle terminal mounted on a vehicle within the area covered by the edge server 2. The target terminal may also be a terminal connected to a base station and relay devices such as routers installed within the area covered by the edge server 2. The gateway 212 outputs the request received from the terminal to the application execution unit 213.

[0047] The application execution unit 213 executes a predetermined application in response to a request. The predetermined application processes the request from the terminal and returns the result, thereby providing the terminal with a predetermined service. Multiple microservices are executed within the application execution unit 213, and these microservices implement the predetermined application. The application execution unit 213 may be configured to execute multiple microservices using, for example, container orchestration software such as Kubernetes.

[0048] Figure 3 is a diagram illustrating the overview of the application executed by the application execution unit 213. As shown in the diagram, requests received by the gateway 212 are input to the microservices that make up the target application. Furthermore, between the microservices... The final calculation result is obtained by passing the processing results and requests. In the illustrated example, the request received by gateway 212 reaches microservice 2132 via two paths, and microservice 2132 issues requests to microservices 2133 and 2134, respectively. The processing results from microservices 2133 and 2134 are sent to the terminal via gateway 212.

[0049] In this embodiment, as shown in Figure 3, the application execution unit 213 sends and receives requests between multiple microservices along a predetermined path, and also changes the destination of requests to avoid overloaded microservices based on forwarding commands received from the load balancing controller 1. Specifically, when the application execution unit 213 receives a forwarding command from the load balancing controller 1, it forwards the requests issued to the target microservice to other edge servers 2 based on the content of the received forwarding command.

[0050] [Load balancing methods] Next, we will describe a specific example of how the load balancing controller 1 detects overload conditions in multiple edge servers 2 included in the system and performs load balancing by forwarding requests between the edge servers.

[0051] Figure 4 illustrates a method of load balancing between edge servers. In this example, the source edge server that forwards the request is referred to as Edge Server 2A, and the destination edge server to which the request is forwarded is referred to as Edge Server 2B. The same application is running on both Edge Server 2A and Edge Server 2B. Furthermore, the same configuration of microservices is running on both Edge Server 2A and Edge Server 2B. Edge Server 2A and Edge Server 2B may be located in geographically separated locations.

[0052] Here, we assume that one of the microservices running on edge server 2A (let's call it microservice 2132) has become overloaded. An overloaded state occurs, for example, when the number of terminals simultaneously connecting to edge server 2A increases excessively. If microservice 2132 becomes overloaded, it will become a bottleneck, affecting subsequent processing. For example, in this example, the processing of microservices 2133 and 2134 may be delayed. As a result, the performance of the application provided by edge server 2A may be significantly degraded.

[0053] In this embodiment, the load balancing controller 1 monitors the performance of the applications running on each edge server 2. For example, the load balancing controller 1 stores performance values ​​(e.g., throughput) of the applications running on each edge server 2 under normal conditions, and detects when a performance degradation occurs in the running applications.

[0054] Let's explain an example of a specific method. Figure 5 shows the relationship between requests and response times passed between multiple microservices. Here, we assume there are four microservices, a0 to a3. Response time can also be called round-trip time. For example, the response time for microservice a0 is the time from when the request is input to microservice a0 until the request reaches microservice a3 and a response is returned.

[0055] Under normal circumstances, after a terminal issues a request to microservice a0 and receives a response... Let slat[a0] be the response time until the response is received. Similarly, let slat[a1] be the response time from when microservice a0 makes a request to microservice a1 until a response is received. By subtracting slat[a0] from slat[a1], we can obtain the processing time d_slat[a0] for microservice a0 itself. The same applies to other microservices. The load balancing controller 1 stores the processing time (the processing time under normal conditions) for each microservice, calculated using this method.

[0056] Furthermore, the load balancing controller 1 causes the edge server 2 (load notification unit 211) to measure the processing time of each microservice when a load is applied, using the same method. By comparing these, it is possible to identify microservices whose processing time has increased by more than a predetermined value compared to normal conditions.

[0057] Let's return to Figure 4 and continue the explanation. Here, we assume that the load balancing controller 1 (monitoring unit 111) has determined that microservice 2132 is in an overloaded state. In order to reduce the load on microservice 2132, it is necessary to reduce the number of requests sent from microservice 2131 to microservice 2132, or the number of requests sent from gateway 212 to microservice 2132. Therefore, the load balancing controller 1 (traffic control unit 112) sends a forwarding command to the application execution unit 213 of edge server 2A, causing some of the requests addressed to microservice 2132 to be forwarded to another edge server (edge ​​server 2B in this example).

[0058] Load balancing is achieved by redirecting a certain percentage of the multiple requests directed to the target microservice to another edge server 2 (in this example, microservice 2132 running on edge server 2B).

[0059] For example, the traffic control unit 112 of the load balancing controller 1 decides to forward N% of the requests sent from microservice 2131 to microservice 2132 running on edge server 2B. It also decides to forward M% of the requests sent from gateway 212 to microservice 2132 to microservice 2132 running on edge server 2B. This ratio (hereinafter referred to as the forwarding ratio) is determined appropriately within a range that satisfies the following conditions.

[0060] (Condition A) The load on the source microservice decreases to below a predetermined value. For example, this could mean that the number of requests per unit of time input to the source microservice decreases to below a predetermined value. (Condition B) The load on the destination microservice does not exceed a predetermined value. For example, the number of requests accepted per unit of time by the destination microservice does not exceed a predetermined value.

[0061] For example, the load balancing controller 1 stores a threshold for when a microservice is considered overloaded (e.g., a threshold for the number of requests per unit time), and determines the forwarding ratio so that the load on the target microservice falls below that threshold. For example, if the overload threshold for a given microservice is 50 requests per second, and the microservice is receiving 75 requests per second, the load balancing controller 1 decides to forward 25 requests per second to other edge servers.

[0062] The load balancing controller 1 is configured to monitor the load of the destination microservice, and it determines the transfer ratio while taking the load of the destination microservice into consideration. For example, the load balancing controller 1 determines the transfer ratio when the load of the destination microservice reaches a threshold. The forwarding ratio is determined within a limit that does not exceed a certain threshold. If forwarding the request could overload the destination microservice, another edge server 2 can be added as a candidate destination.

[0063] The traffic control unit 112 of the load balancing controller 1 generates a forwarding command based on the information determined above and sends it to the target edge server 2. The forwarding command includes, for example, the following items: • Identifier of the source edge server • The source of the request within the source edge server (the entity sending the request to an overloaded microservice) • The destination of the request within the source edge server (i.e., the overloaded microservice) • Identifier of the destination edge server • Identifier of the destination microservice • The percentage of requests to be forwarded (e.g., a percentage between 0 and 100)

[0064] When edge server 2 (application execution unit 213) receives a forwarding command, it forwards the requests according to the command's contents. For example, suppose edge server 2A receives 50 requests per second from microservice 2131 to microservice 2132, and a forwarding rate of 50% is specified. Based on the forwarding command, the application execution unit 213 of edge server 2A forwards 25 of the 50 requests per second to microservice 2132 running on edge server 2B. Also, suppose gateway 212 receives 30 requests per second to microservice 2132, and a forwarding rate of 16.7% is specified. Based on the forwarding command, the application execution unit 213 of edge server 2A forwards 5 of the 30 requests per second from gateway 212 to microservice 2132 running on edge server 2B.

[0065] Through the process described above, the load balancing controller 1 can detect overload conditions in the multiple edge servers 2 included in the system and perform load balancing.

[0066] [flowchart] Next, we will explain the details of the processes performed by the load balancing controller 1. Figure 6(A) is a flowchart of the processes performed by the load balancing controller 1. The processes shown are executed periodically for each of the multiple edge servers while the load balancing controller 1 is monitoring the edge servers.

[0067] First, in step S11, the monitoring unit 111 determines that among the applications provided by the multiple edge servers 2 included in the system, there is an application whose performance is degraded below a predetermined value. In this step, the load balancing controller 1 identifies multiple applications to be evaluated using a list of edge servers 2 and applications recorded in the configuration database 12A. For each of the multiple applications to be evaluated, it obtains a value for evaluating performance (hereinafter referred to as the performance evaluation value) via the load notification unit 211 of the edge server 2. The performance evaluation value may be, for example, throughput. If any of these applications have a performance evaluation value below a predetermined performance requirement, it can be inferred that a problem has occurred (is in an overloaded state) in one of the microservices that constitute that application.

[0068] In step S11, if it is determined that there is an application whose performance is degraded, If the result is positive (Step S12-Yes), the process proceeds to Step S13. If it is determined in Step S11 that there are no applications with degraded performance (Step S12-No), the process terminates.

[0069] In step S13, the microservice causing the performance degradation of the application (i.e., the bottleneck) is identified. In this step, for example, as explained with reference to Figure 5, the monitoring unit 111 obtains measured response times for each microservice via the load notification unit 211 of the edge server 2, and uses this, along with the response time under normal conditions, to identify the microservice that is causing the bottleneck. In the example in Figure 5, d_slat represents the processing time for each microservice. For example, the difference between d_slat under normal conditions and the current d_slat can be calculated for each microservice, and any microservice whose difference exceeds a predetermined value can be considered a bottleneck.

[0070] Next, in step S14, the traffic control unit 112 performs processing to resolve the identified bottleneck. Figure 6(B) is a flowchart showing the processing in step S14 in detail. At the point where the illustrated flowchart begins, the target edge server 2 and the microservice experiencing overload have been identified. In the following explanation, the target edge server will also be referred to as the source edge server. The edge server to which the request is forwarded will also be referred to as the destination edge server.

[0071] First, in step S141, it is determined whether the target microservice is currently receiving requests forwarded from other edge servers. If the result in this step is positive, the process proceeds to step S142. If the result in this step is negative, the process proceeds to step S144.

[0072] In step S142, request forwarding from other edge servers is stopped. For example, the target microservice may be overloaded due to request forwarding from other edge servers, so stopping this forwarding attempts to alleviate the overload.

[0073] In step S143, it is determined whether the overload condition of the target microservice has been resolved because the other edge server has stopped forwarding requests. In this step, a measurement of the response time for the target microservice may be obtained and the determination of whether the overload condition has been resolved may be made based on the result of comparing this with the normal response time. If it is determined that the overload condition has been resolved, the process ends. If the overload condition is not resolved, the process proceeds to step S144.

[0074] Step S144 retrieves candidate destination edge servers to which requests will be forwarded. In this step, the delay time caused by forwarding requests between edge servers is calculated, and it is determined whether the performance requirements can still be met even after adding this delay time. Edge servers that are determined to be able to meet the performance requirements even after forwarding requests are added to the list as candidate destination edge servers. Edge servers whose corresponding microservices are already overloaded are excluded from this step.

[0075] The processes in steps S145 to S148 are repeatedly executed for each of the candidate destination edge servers generated in step S144. Step S145 determines whether the microservice running on the target destination edge server has sufficient surplus resources to accept the request. This step is affirmative if the microservice is capable of accepting all the requests necessary to resolve the overload condition of the microservice in question.

[0076] If the result in step S145 is positive, the process proceeds to step S146, where a forwarding command is generated to forward a number of requests sufficient to resolve the overload to the destination edge server, and this forwarding command is sent to the source edge server.

[0077] If the result in step S145 is negative, the process proceeds to step S147. A positive result in step S145 means that the destination edge server does not have the resources to accept the entire load. In this case, a forwarding command is generated to forward a number of requests that can partially alleviate the overload (i.e., an acceptable number) to the destination edge server, and this forwarding command is sent to the source edge server.

[0078] In step S148, it is determined whether the overload on the target microservice has been resolved. If the overload on the target microservice has been resolved, the process terminates. If the overload on the target microservice has not been resolved, the process returns to step S145 and repeats the same process for the next candidate destination edge server.

[0079] As mentioned above, the process in Figure 6 is executed periodically. That is, even after request forwarding has started, the predetermined percentage may be changed in response to changes in the load. Also, the destination microservice may be changed in response to changes in the load. For example, if the destination microservice becomes overloaded after request forwarding has started, request forwarding to that microservice may be stopped, or the destination microservice may be changed.

[0080] As explained above, in the edge computing system according to the first embodiment, a microservice running on each of the multiple edge servers is identified that is experiencing a load exceeding a predetermined amount. Furthermore, a predetermined percentage of the requests issued to that microservice are forwarded to microservices running on other edge servers. This makes it possible to detect overload conditions on a microservice-by-microservice basis and perform load balancing.

[0081] (modified version) The embodiments described above are merely examples, and this disclosure may be modified as appropriate without departing from its essence. For example, the processes and means described in this disclosure can be freely combined and implemented, as long as no technical inconsistencies arise.

[0082] Furthermore, a process described as being performed by a single device may be divided and executed by multiple devices. Conversely, a process described as being performed by different devices may be executed by a single device. In a computer system, the hardware configuration (server configuration) by which each function is implemented can be flexibly changed.

[0083] For example, in the description of the embodiment, the load balancing controller 1 detects that the performance of an application running on an edge server has deteriorated, but this process may also be triggered from the edge server 2 to the load balancing controller 1.

[0084] Furthermore, in the description of the embodiment, an example was given of measuring the processing time of each microservice as a method for identifying a microservice that is in an overloaded state, but other methods may be used to identify an overloaded microservice. You can also identify which microservices are in a state of being overloaded. For example, if you can obtain the number of requests each microservice is receiving per unit of time, you can use that information.

[0085] The present disclosure can also be realized by supplying a computer program implementing the functions described in the embodiments above to a computer, and having one or more processors in the computer read and execute the program. Such a computer program may be provided to the computer by a non-temporary computer-readable storage medium that can be connected to the computer's system bus, or it may be provided to the computer via a network. Non-temporary computer-readable storage mediums include, for example, any type of disk such as magnetic disks (floppy disks, hard disk drives (HDDs), etc.), optical disks (CD-ROMs, DVDs, Blu-ray discs, etc.), read-only memory (ROM), random access memory (RAM), EPROM, EEPROM, magnetic cards, flash memory, optical cards, and any type of medium suitable for storing electronic instructions. [Explanation of Symbols]

[0086] 1. Load balancing controller 2. Edge Server 11,21...Control Unit 12,22...Storage section 13,23... Communications Department

Claims

1. For each of the multiple edge servers in which multiple microservices work together to realize the operation of the first application, the load on each of the multiple microservices is obtained, The system decides to forward a predetermined percentage of requests from one or more requests issued to a first microservice running on a first edge server that is experiencing a load exceeding a predetermined amount, to a second microservice running on one or more second edge servers. It includes a control unit that performs the following: The control unit, when the performance value of the first application running on the first edge server deteriorates below a predetermined value, measures the processing time of each of the multiple microservices running on the first edge server and identifies the microservice whose processing time exceeds the predetermined value as the first microservice. Information processing device.

2. The control unit determines the predetermined ratio such that the load on the first microservice and the load on the second microservice are both below the predetermined amount. The information processing apparatus according to claim 1.

3. The control unit stops the transfer after it has started if the load on the second microservice exceeds a predetermined amount. The information processing apparatus according to claim 1.

4. For each of the multiple edge servers in which multiple microservices work together to realize the operation of the first application, the load on each of the multiple microservices is obtained, The system decides to forward a predetermined percentage of requests from one or more requests issued to a first microservice running on a first edge server that is experiencing a load exceeding a predetermined amount, to a second microservice running on one or more second edge servers. The performance value of the first application running on the first edge server is a predetermined value. If the situation worsens, the processing time of each of the multiple microservices running on the first edge server is measured, and the microservice whose processing time exceeds a predetermined value is identified as the first microservice. A program that causes a computer to execute something.

Images