Communication system and method for accessing and deploying temporary microservices on a heterogeneous platform

1. A communication system comprising one or several execution node(s) able to execute one or several microservice(s), a computer device, called a host server, including several routers constituting an intermediate communication interface between each execution node and the outside of the communication system, a heterogeneous computing platform, consisting of comprising a set of hardware and software or executable code for the access to and deployment of microservices on the system, each node stores execution files of the microservice(s) including the access to the system by at least one of two entry points either at the host server or at the execution node and the communication system being characterized in that wherein the set of hardware and software or executable code for the access to and deployment of the microservices is in a Java runtime environment (J) on the host server and the execution nodes allowing the execution of the computer programs based on the Java language and in that it allows the creation of ephemeral microservices by the use of a key/value system stored in a distributed memory cache at each creation by referencing each microservice by filenames deposited in the system by a developer and using an asynchronous TCP exchange protocol (T) exchanging notifications containing metadata (M) between the host server and each execution node; and in that at least one classloader in the Java environment ensures the deployment of the services associated with the microservices that are integrated into the execution node.

2. The system according to claim 1 , wherein the host server and the execution nodes of the system exchange metadata (M) type data comprising one or several of the following elements: an alias of the microservice (called key), a location path of a particular method in the microservice, an action associated with the location path, a microservice execution return code and a microservice execution content type.

3. The system according to claim 1 , wherein a microservice development tool constitutes a developer interface and a sending tool in the protocol used between the microservice and the host server.

4. The system according to claim 1 , wherein each execution node further comprises computer means for managing the microservices, computer means for reading and writing the execution files disposed in a distributed storage unit of the system, and a system for publishing and subscribing a message when a microservice is deposited or an alias is modified by the developer on the system.

5. The system according to claim 1 , wherein each execution node is able to execute a predetermined algorithm dedicated to the selection of one or several execution node(s) of the microservice by determining a score (value) and then storing the address or alias of the microservice and this score (key/value system) in the distributed memory cache if the score is more relevant than the previous one.

6. The system according to claim 5 , wherein the predetermined algorithm executed by the execution node launches an inactivity timeout at each score determination so that the host server reuses the same execution node as long as the microservice is unused or an inactivity timeout is lifted.

7. The system according to claim 1 , wherein the execution node chosen by the host server called by the system, loads the microservice in a new classloader referenced within the system, in a HashMap of the distributed memory cache according to the alias used in the standardized exchange message.

8. The system according to claim 5 , wherein each selected execution node is able to report data in the form of a score and address allocation in the distributed memory cache of the communication system allocated to each microservice so that the host server can read and use these data.

9. The system according to claim 1 , wherein the routers of the host server integrate Java and Netty-based applications to ensure multiprotocol communications to the outside of the system and asynchronous TCP protocol exchanges (T) towards the execution nodes of the system.

10. The system according to claim 1 , wherein the microservices are stored in Jar or Javascript format by the system in the distributed memory cache, while the Jar format files are dearchived into use or execution classes by the system to make them accessible to the classloader of the Java runtime environment (J) of the execution node; so that these microservices are loaded from the distributed storage unit according to the request of the host server (defined by the service alias that allows identifying the microservice to be loaded) and the path of the incoming request allowing to identify the method (java or javascript) to call in the loaded microservice); and the other file formats are stored unitarily on the key/value system so that the Java runtime environment (J) can read or use the data as needed.

11. The system according to claim 4 , wherein the system is able to select an execution node so that it loads a microservice in a classloader which is referenced in the distributed storage unit according to the alias used in the exchange metadata (M).

12. The system according to claim 1 , wherein the system includes at least one access code for a call activation of a microservice for its deployment on the platform, said access code is disposed either at the level of the service allowing the access to all the resources of the service, or at the level of a resource of the service allowing the access to this single resource, or by at least one access method predefined by a security manager of the communication system.

13. The system according to claim 5 , wherein the host server ( 3 ) is configured to use and reuse the same execution node ( 2 ), by means of the specific algorithm of the node ( 2 ), as long as the microservice ( 5 ) is unused or a load inactivity timeout of the microservice ( 5 ) is lifted.

14. The system according to claim 1 , wherein the key/value system and the notification system are systems external to the communication system which are integrated into an executable code of the communication system, or injected at runtime of the system.

15. A method for accessing and deploying ephemeral microservices on a heterogeneous computing platform, by a communication system according to claim 1 , wherein the method comprises the following steps: depositing one or several microservice(s) by the developer on one or several execution node(s); referencing microservices by the filename deposited without its extension in the key/value system; storing microservices ( 5 ), in the form of a Jar or Javascript-type execution file, by the key/value system in the distributed storage unit; dearchiving, into use or execution classes, Jar format execution files by the key/value system to make them accessible to the classloader of the Java runtime environment (J) of the execution node, and the JavaScript formats of the execution files are stored unitarily on the key/value system so that the Java runtime environment (J) can read or use the data as needed; loading the classes associated with the microservices by the classloaders of the execution nodes to be loaded; unloading the microservices by the execution nodes when the microservices are unused or when the load inactivity timeout of the microservices is lifted.

16. The method according to claim 15 , wherein the step of unloading the microservices comprises a selection by the host server of the execution nodes of the microservice to be loaded and each execution node reports data in the form of a score and allocation address of the microservice in the distributed memory cache of the communication system so that the host server can read and use these data.

17. The method according to claim 15 , wherein the method further comprises a step of creating the aliases to the microservices by the developer so that the system can locate the microservice(s) (or 5 ) to be deployed.

18. The method according to claim 15 , wherein when the microservice is not loaded, the communication system chooses the execution node that loads the microservice in a new classloader and references it in the distributed storage unit of the system.

19. The method according to claim 17 , wherein the reloading of microservice is done either by depositing a new microservice with the same execution filename, or by changing the alias.

20. The method according to claim 15 , wherein the reloading of a microservice results in a message sent by the publication and subscription system to update all the actions of the execution nodes of the communication system.