WO2022016848A1

WO2022016848A1 - Method and apparatus for performing application deployment according to service role

Info

Publication number: WO2022016848A1
Application number: PCT/CN2021/074033
Authority: WO
Inventors: 张志江; 莫展鹏; 季统凯; 贺忠堂; 姚文俊
Original assignee: 国云科技股份有限公司
Priority date: 2020-07-20
Filing date: 2021-01-28
Publication date: 2022-01-27
Also published as: CN111897539A; CN111897539B

Abstract

A method and apparatus for performing application deployment according to a service role. The method comprises: encapsulating an application program into a corresponding functional module, and defining a role by means of a role management module, so as to configure a dependency relationship for the corresponding functional module and the corresponding role. Therefore, all the modules are in the same application service, and, during starting, a module that needs to be started is directly selected according to a starting parameter, and no recompilation is needed. In the method, an application program can be used in a distributed micro-service architecture and a small program single-service architecture and can be flexibly switched between the two modes, no matter how a deployment environment and a deployment scenario change, a code does not need to be re-adjusted, and re-delivery is not needed.

Description

A method and device for application deployment according to service roles

technical field

The embodiments of the present application relate to the technical field of application deployment, and in particular, to a method and apparatus for application deployment according to service roles.

Background technique

At present, software applications are mainly divided into micro-service architecture and single-service applications. The microservice architecture is suitable for large-scale applications. Each module in the application is a single service, which can provide powerful processing capabilities. Single-service applications are suitable for applications with low traffic volume and limited physical machine resources. All modules in the application are in the same service instance.

If it is an application of a microservice architecture, if the entire service needs to be deployed on one server due to limited resources, it will lead to high resource usage and lose the meaning of microservices. Single-service applications cannot handle large distributed scenarios. Neither of them can be flexibly configured and adapted to various scenarios. If you want to switch between the two deployment modes, you need to recompile and package the program, which is very inflexible. Therefore, designing a way to rapidly deploy applications according to the number of servers has become a technical problem to be solved urgently by those skilled in the art.

SUMMARY OF THE INVENTION

The embodiments of the present application provide a method and device for deploying applications according to service roles. For an application, after only one compilation and delivery of the application, it can be adapted to all deployment environments and scenarios. No matter how the deployment environments and deployment scenarios change, No need to tweak the code again, it needs to be re-delivered.

In a first aspect, an embodiment of the present application provides a method for application deployment according to service roles, including:

Encapsulate program components into corresponding functional modules;

Define roles through the role management module and configure dependencies corresponding to the function modules and the roles;

Receive the application service requirement selected by the user and match the corresponding target role according to the application service requirement;

According to the target role and the dependency relationship, the corresponding function module is called and loaded to perform service deployment by running the corresponding program code.

Further, the receiving the application service requirement selected by the user and matching the corresponding target role according to the application service requirement, further includes:

Set corresponding target roles and role distributions according to the application service requirements.

Further, the application service requirements include one or more of business requirements, number of servers, cluster fault tolerance requirements and environmental concurrency.

Further, after encapsulating the program components into corresponding functional modules, it also includes:

A developer-editable configuration file is provided, wherein the configuration file provides for each functional module an option to enable the functional module so that the functional module can be selectively enabled according to the needs of the software project instance.

Further, the roles include a computing controller, a storage controller, a network controller, a computing node, a storage node, and a network node.

Further, encapsulating the program components into corresponding functional modules includes:

The corresponding example codes for the program components are packaged into corresponding functional modules.

Further, the application service requirements include the number of servers, and the receiving application service requirements selected by the user and matching corresponding target roles according to the application service requirements, including:

When the number of servers selected by the user is 1, match all target roles required by the application service on the corresponding server; or,

When the number of servers selected by the user is multiple, the target roles required by the application service are distributed and set at corresponding servers according to the number of servers.

In a second aspect, an embodiment of the present application provides an apparatus for deploying applications according to service roles, including:

Encapsulation module: used to encapsulate program components into corresponding functional modules;

Dependency configuration module: used to define roles through the role management module and configure dependencies corresponding to the function modules and the roles;

Matching module: used to receive the application service requirement selected by the user and match the corresponding target role according to the application service requirement;

Loading module: used to call and load a corresponding function module according to the target role and the dependency relationship to perform service deployment by running the corresponding program code.

In a third aspect, an embodiment of the present application provides an electronic device, including:

memory and one or more processors;

the memory for storing one or more programs;

When the one or more programs are executed by the one or more processors, the one or more processors implement the method for application deployment according to service roles as described in the first aspect.

In a fourth aspect, an embodiment of the present application provides a storage medium containing computer-executable instructions, when executed by a computer processor, the computer-executable instructions are used to perform the performance according to the service role as described in the first aspect App deployment method.

In the embodiment of the present application, the application program is encapsulated into corresponding functional modules, and the role is defined through the role management module to configure dependencies for the corresponding functional modules and the corresponding roles; so that all modules are in the same application service, and the direct The modules to be started are selected according to the startup parameters without recompiling. The solutions of the embodiments of the present application can be used in a distributed micro-service architecture and a small-program single-service architecture with one application. And it can be flexibly switched between the two modes, no matter how the deployment environment and deployment scenarios change, there is no need to adjust the code or redelivery.

Description of drawings

FIG. 1 is a flowchart of a method for application deployment according to a service role provided by an embodiment of the present application;

2 is a schematic flowchart of service requirements and role matching provided by an embodiment of the present application;

3 is a schematic diagram of a deployment structure of a single server and a single service provided by an embodiment of the present application;

4 is a schematic diagram of a multi-server distributed deployment structure provided by an embodiment of the present application;

5 is a schematic structural diagram of an apparatus for deploying applications according to service roles provided by an embodiment of the present application;

FIG. 6 is a schematic structural diagram of an electronic device provided by an embodiment of the present application.

detailed description

In order to make the objectives, technical solutions and advantages of the present application clearer, the specific embodiments of the present application will be further described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are only used to explain the present application, but not to limit the present application. In addition, it should be noted that, for the convenience of description, the drawings only show some but not all of the contents related to the present application. Before discussing the exemplary embodiments in greater detail, it should be mentioned that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although a flowchart depicts various operations (or steps) as a sequential process, many of the operations may be performed in parallel, concurrently, or concurrently. Additionally, the order of operations can be rearranged. The process may be terminated when its operation is complete, but may also have additional steps not included in the figures. The processes may correspond to methods, functions, procedures, subroutines, subroutines, and the like.

In the existing situation, if the entire service needs to be deployed on one server due to limited resources, it will lead to high resource usage and lose the meaning of microservices. Single-service applications cannot handle large distributed scenarios. Neither of them can be flexibly configured and adapted to various scenarios. If you want to switch between the two deployment modes, you need to recompile and package the program, which is very inflexible. Based on this, the embodiment of the present application encapsulates the application into corresponding functional modules, and defines roles through the role management module, and then configures dependencies for the corresponding functional modules and the corresponding roles; so that all modules are in the same application service, When starting, the modules to be started are directly selected according to the startup parameters without recompiling. The solutions of the embodiments of the present application can be used in a distributed micro-service architecture and a small-program single-service architecture with one application. And it can be flexibly switched between the two modes, no matter how the deployment environment and deployment scenarios change, there is no need to adjust the code or redelivery.

FIG. 1 shows a flowchart of a method for deploying applications based on service roles provided by an embodiment of the present application. The method for deploying applications based on service roles provided in this embodiment may be implemented by deploying applications based on service roles. The device that performs application deployment according to the service role can be implemented by software and/or hardware. The device that performs application deployment according to the service role can be composed of two or more physical entities, or one Physical entity composition. Generally speaking, the device that deploys the application according to the service role may be a computer, a mobile phone, a tablet, or a server.

The following description takes the server as an example of a device that executes the method for application deployment according to the service role. Referring to FIG. 1 , the method for deploying an application according to a service role specifically includes:

S101: Encapsulate the program components into corresponding functional modules.

When encapsulating, a single program component can be encapsulated into a corresponding functional module, or multiple program components can be encapsulated into a corresponding functional module, so that each functional module includes a corresponding program component and a development configuration for the program component. . The specific developer can set it according to the actual situation.

Exemplarily, the encapsulation of the program components into corresponding functional modules includes:

The corresponding example codes for the program components are packaged into corresponding functional modules. By encapsulating the corresponding exemplary codes into corresponding functional modules for reference by developers.

More preferably, after encapsulating the program components into corresponding functional modules, it also includes:

A developer-editable configuration file is provided, wherein the configuration file provides for each functional module an option to enable the functional module, so that the functional module can be selectively enabled according to the needs of the software project instance.

The configuration file mentioned in this embodiment is the configuration content that can package and bundle multiple functional modules. For example, the authentication module and the database module can be configured together, or the data analysis module and the database module can be configured together to realize further modules. configuration.

S102: Define roles through a role management module and configure dependencies corresponding to the function modules and the roles.

In general applications, modules are configured mainly through Maven, Gradle and other tools. However, the dependencies have been prepared when compiling, and it is impossible to dynamically switch the selection during operation. In the first step of the present invention, it is necessary to develop a module managed by a role module through a program. In this module, redefine the dependencies of roles, function modules, and role configuration modules. By redefining roles, it is convenient to correspond to function modules.

In the solutions of the embodiments of the present application, the application refers to the entire application program. A service is an instance of an application. A role is a collection of modules in an application that together provide the capabilities of that role. A service can be configured with multiple roles. Therefore, in the specific design, roles can be named not only through the control side, such as computing nodes, storage nodes, network nodes, etc., but also through the business side, such as management roles, service roles, logistics roles, Show characters and more. In specific situations, developers can adjust the settings according to different service requirements.

Exemplarily, for example, for a cloud platform system, the entire cloud platform system is an application; the roles include a computing controller, a storage controller, a network controller, a computing node, a storage node, and a network node. The dependencies corresponding to the function modules and the role configuration, including:

Corresponding dependencies are configured for the functional modules and the computing controller, the storage controller, the network controller, the computing node, the storage node and the network node.

Since the cloud platform system mainly provides computing and storage services, when defining roles, it is mainly abstracted into roles such as computing nodes and storage nodes. In the above example, the roles are defined as: the computing controller is responsible for virtual machine-related functional modules, the storage controller is responsible for storage block device-related functional modules, the network controller is responsible for network device-related functional modules, computing nodes store virtual machines, and storage nodes are responsible for Storage block devices are stored, and network nodes store network devices. By defining the above-mentioned roles, it is convenient to distinguish the corresponding functional modules. However, in actual implementation, there are not only the above-mentioned types of roles, but also other roles, such as shopping websites, or a variety of different roles, such as user management roles, data storage roles, logistics management roles, etc. Wait. The specific role definition needs to be set according to the actual situation.

The entire cloud platform system provided by the embodiments of the present application is an application, and the program package of the application is cloud.jar. Then running a cloud.jar is a service. The roles defined are computing controllers, storage controllers, network controllers, computing nodes, storage nodes, network nodes, and so on. The module refers to the database module, authentication module, etc. used in the computing controller. After defining the role, you can complete the dependency configuration of the corresponding function module and the corresponding role. A service cloud.jar process mentioned in this embodiment, this service can be configured with one or more roles. The entire cloud platform and one or more services constitute the provisioning capability.

The dependency mentioned in this embodiment refers to: in a project including multiple modules or components, there may be a large number of dependencies between the modules or components, that is, the execution of one module or component requires another one or more modules or Component support, the dependencies that a module or component includes may include, for example, the identification of the module or component on which its execution depends. Maven is mainly used for dependency management. Maven can avoid the need to search for all required libraries. Maven finds out the dependencies between their projects by reading the project file (pom.xml). All we need to do is define the direct dependencies in each project's pom.

There are mainly the following ways to use Maven for dependency management: 1. Dependency adjustment, which determines which dependency version will be used when multiple manually created versions appear at the same time. If two dependency versions are at the same depth in the dependency tree, the first declared dependency will be used. 2. Dependency management, which directly specifies that a manually created version is used. For example, when a module C includes module B in its own dependency management module, that is, B depends on A, then A can specify the version used when B is referenced. 3. Dependency scope, including dependencies in each stage of the build process. Dependency scope can include compilation phase. Provisioning Phase, Run Phase, Test Phase, System Phase and Import Phase. 4. Dependency Exclusion, any transitive dependencies can be excluded via the "exclusion" element. For example, A depends on B, and B depends on C, so A can mark C as "excluded". 5. Dependencies are optional. Any transitive dependency can be marked as optional by using the "optional" element. For example: A depends on B, B depends on C. So B can mark C as optional so that A can no longer use C.

S103: Receive an application service requirement selected by a user and match a corresponding target role according to the application service requirement.

That is, the user selects the target role that needs to be started when starting the application service program. More preferably, FIG. 2 is a schematic flowchart of the matching of service requirements and roles provided by the embodiment of the present application. As shown in FIG. 2 , the application service requirements selected by the user are received and the corresponding target roles are matched according to the application service requirements. ,Also includes:

S1031: Receive the application service requirement selected by the user;

S1032 sets corresponding target roles and role distribution according to the application service requirements.

At startup, select different numbers of services and different roles according to the actual environment of the physical machine and the specific needs of the business. Different users have different needs, and the corresponding roles and role distribution can be set through application service requirements; for example, when a user uses multiple servers and needs to perform distributed processing on each module; then set the roles corresponding to different modules The roles are distributed at different servers, and the same control role can also be set at two different servers to improve the fault tolerance of the scheme.

Exemplarily, the application service requirements include one or more of business requirements, number of servers, cluster fault tolerance requirements, and environment concurrency.

Which roles will be configured by the application in step S102 can be selected, and when starting the application service program, it can be selected according to the actual scenario, such as the number of servers, cluster fault tolerance requirements, concurrency of the environment, etc. which servers to start and how many services to start. , which roles are enabled for each service.

For example, when enabling a cloud platform, you can choose to start a server on server 1, and the roles are computing controller, storage controller, and network controller. Start a service on server 2 and the role is the compute node. It is also possible to start only one service including all roles on the same server. This only needs to modify the startup parameters, no need to modify the code, no need to recompile. The startup parameters also refer to service requirements, number of servers, cluster fault tolerance requirements, and environmental concurrency.

Exemplarily, the application service requirement includes the number of servers, and the receiving the application service requirement selected by the user and matching the corresponding target role according to the application service requirement includes:

When the number of servers selected by the user is 1, match all target roles required by the corresponding application service on the corresponding server; or,

The above is a schematic structural diagram of specific application service deployment when the number of servers is different. FIG. 3 is a schematic diagram of a deployment structure of a single server and a single service provided by an embodiment of the present application. As shown in FIG. 3 , it is a schematic diagram of a deployment structure of a single server and a single service, wherein s1, s2 and s3 represent functional modules, and three functional modules Configured together to form a corresponding role, and provide corresponding services through this role. Since a single server is used, all function modules are loaded to the corresponding server through roles.

FIG. 4 is a schematic diagram of a multi-server distributed deployment structure provided by an embodiment of the present application. As shown in FIG. 4 , it is a schematic diagram of a multi-server distributed deployment structure. Among them, s1 represents a role, s2 represents a role, s3 represents a role, and s1, s2 and s3 are configured as a role; since multiple servers are used, each role can be set in a distributed manner, and through different modules Offer different services. As can be seen from the above, according to different situations, the difference in the final deployment structure is also obvious.

S104: Call and load a corresponding function module according to the target role and the dependency relationship to perform service deployment by running corresponding program code.

In order to implement the solutions of the embodiments of the present application, the codes of all modules are in the same application. Therefore, when starting, according to the configuration in step S102, the role module management module of the application determines which modules, codes and related configurations to load. In addition to the above-mentioned method of assigning roles, operations can also be performed according to the method of application packaging for each functional module. However, the above operations need to be compiled multiple times into different application packages according to different scenarios. For example, in Figure 4, four configurations of s1, s2, s3, and s1+s2+s3 need to be compiled to output four applications. However, the above solution has a drawback, that is, the more modules there are, the more complicated the combination may be, and once packaged, it cannot be changed. It is not the same as the method of role-dependent limitation adopted in the embodiment of the present application. Using the role-dependent method, all modules can be in the same application, and the module to be started can be selected directly according to the startup parameters when starting. without recompiling. A single application can be used for distributed microservice architecture and small program single service architecture. And it can be flexibly switched between the two modes.

The embodiment of the present application encapsulates the application program into corresponding functional modules, and defines roles through the role management module to configure dependencies for the corresponding functional modules and the corresponding roles; so that all modules are in the same application service, and directly when starting The modules to be started are selected according to the startup parameters without recompiling. The solutions of the embodiments of the present application can be used in a distributed micro-service architecture and a small-program single-service architecture with one application. And it can be flexibly switched between the two modes, no matter how the deployment environment and deployment scenarios change, there is no need to adjust the code or redelivery.

On the basis of the foregoing embodiments, FIG. 5 is a schematic structural diagram of an apparatus for deploying applications according to service roles according to an embodiment of the present application. Referring to FIG. 5 , the apparatus for deploying applications according to service roles provided in this embodiment specifically includes:

Encapsulation module 21: used to encapsulate program components into corresponding functional modules;

Dependency configuration module 22: used to define roles through the role management module and configure dependencies corresponding to the function modules and the roles;

Matching module 23: for receiving the application service requirement selected by the user and matching the corresponding target role according to the application service requirement;

Loading module 24: used to call and load the corresponding function module according to the target role and the dependency relationship to perform service deployment by running the corresponding program code.

The apparatus for deploying applications based on service roles provided by the embodiments of the present application can be used to execute the methods for deploying applications based on service roles provided by the above embodiments, and has corresponding functions and beneficial effects.

6 is a schematic structural diagram of an electronic device provided by an embodiment of the present application. Referring to FIG. 6 , the electronic device includes: a processor 31 , a memory 32 , a communication module 33 , an input device 34 and an output device 35 . The number of processors 31 in the electronic device may be one or more, and the number of memories 32 in the electronic device may be one or more. The processor 31 , the memory 32 , the communication module 33 , the input device 34 and the output device 35 of the electronic device may be connected by a bus or in other ways.

As a computer-readable storage medium, the memory 32 can be used to store software programs, computer-executable programs, and modules, such as program instructions/modules corresponding to the method for deploying applications according to service roles described in any embodiment of the present application (for example, , the encapsulation module 21, the dependency configuration module 22, the matching module 23 and the loading module 24) in the apparatus for application deployment according to the service role. The memory 32 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function; the storage data area may store data created according to the use of the device, and the like. Additionally, memory 32 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some examples, the memory may further include memory located remotely from the processor, the remote memory being connectable to the device through a network. Examples of such networks include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

The communication module 33 is used for data transmission.

The processor 31 executes various functional applications and data processing of the device by running the software programs, instructions and modules stored in the memory 32 , that is, to implement the above-mentioned method of application deployment according to service roles.

The input device 34 may be used to receive input numerical or character information and to generate key signal input related to user settings and functional control of the device. The output device 35 may include a display device such as a display screen.

The electronic device provided above can be used to execute the method for application deployment according to the service role provided by the above embodiment, and has corresponding functions and beneficial effects.

Embodiments of the present application further provide a storage medium containing computer-executable instructions, when the computer-executable instructions are executed by the computer processor 31 for executing a method for deploying an application according to a service role, the The methods of application deployment include:

Encapsulate program components into corresponding functional modules;

storage medium - any of various types of memory devices or storage devices. The term "storage medium" is intended to include: installation media, such as CD-ROMs, floppy disks, or tape devices; computer system memory or random access memory, such as DRAM, DDR RAM, SRAM, EDO RAM, Rambus RAM, etc. ; non-volatile memory, such as flash memory, magnetic media (eg hard disk or optical storage); registers or other similar types of memory elements, etc. The storage medium may also include other types of memory or combinations thereof. In addition, the storage medium may be located in the first computer system in which the program is executed, or may be located in a second, different computer system connected to the first computer system through a network such as the Internet. The second computer system may provide program instructions to the first computer for execution. The term "storage medium" may include two or more storage media residing in different locations (eg, in different computer systems connected by a network). The storage medium may store program instructions (eg, embodied as a computer program) executable by one or more processors 31 .

Of course, a storage medium containing computer-executable instructions provided by the embodiments of the present application, the computer-executable instructions of which are not limited to the above-mentioned method for application deployment according to service roles, and can also execute any of the embodiments of the present application. Related operations in the provided method for application deployment based on service roles.

The apparatus, storage medium, and electronic device for deploying applications based on service roles provided in the foregoing embodiments can execute the methods for deploying applications based on service roles provided in any of the embodiments of the present application, which are not described in detail in the foregoing embodiments. For technical details, refer to the method for application deployment according to service roles provided by any embodiment of this application.

The above are only the preferred embodiments of the present application and the applied technical principles. The present application is not limited to the specific embodiments described herein, and various obvious changes, readjustments and substitutions that can be made by those skilled in the art will not depart from the protection scope of the present application. Therefore, although the present application has been described in detail through the above embodiments, the present application is not limited to the above embodiments, and can also include more other equivalent embodiments without departing from the concept of the present application. The scope is determined by the scope of the claims.

Claims

A method for application deployment according to service roles, comprising:

Encapsulate program components into corresponding functional modules;

Define roles through the role management module and configure dependencies corresponding to the function modules and the roles;

Receive the application service requirement selected by the user and match the corresponding target role according to the application service requirement;

According to the target role and the dependency relationship, the corresponding function module is called and loaded to perform service deployment by running the corresponding program code.
The method for application deployment based on service roles according to claim 1, wherein the receiving the application service requirements selected by the user and matching the corresponding target roles according to the application service requirements, further comprising:

Set corresponding target roles and role distributions according to the application service requirements.
The method for deploying applications according to service roles according to claim 2, wherein the application service requirements include one or more of business requirements, number of servers, cluster fault tolerance requirements, and environment concurrency.
The method for application deployment according to the service role according to claim 1, characterized in that, after the encapsulation of the program components into corresponding functional modules, the method further comprises:

A developer-editable configuration file is provided, wherein the configuration file provides for each functional module an option to enable the functional module so that the functional module can be selectively enabled according to the needs of the software project instance.
The method for deploying applications according to service roles according to claim 1, wherein the roles include a computing controller, a storage controller, a network controller, a computing node, a storage node, and a network node.
The method for application deployment according to any one of claims 1-5, wherein the encapsulating the program components into corresponding functional modules includes:

The corresponding example codes for the program components are packaged into corresponding functional modules.
The method for deploying applications according to service roles according to any one of claims 1 to 5, wherein the application service requirements include the number of servers, and the application service requirements selected by the user are received according to the application service requirements. Service requirements are matched to corresponding target roles, including:

When the number of servers selected by the user is 1, match all target roles required by the application service on the corresponding server; or,

When the number of servers selected by the user is multiple, the target roles required by the application service are distributed and set at corresponding servers according to the number of servers.
A device for deploying applications according to service roles, comprising:

Encapsulation module: used to encapsulate program components into corresponding functional modules;

Dependency configuration module: used to define roles through the role management module and configure dependencies corresponding to the function modules and the roles;

Matching module: used to receive the application service requirement selected by the user and match the corresponding target role according to the application service requirement;

Loading module: used to call and load a corresponding function module according to the target role and the dependency relationship to perform service deployment by running the corresponding program code.
An electronic device, comprising:

memory and one or more processors;

the memory for storing an or

multiple programs;

When the one or more programs are executed by the one or more processors, the one or more processors implement the method for deploying an application according to a service role according to any one of claims 1-7.
A storage medium containing computer-executable instructions, wherein the computer-executable instructions, when executed by a computer processor, are used to execute the application deployment process according to any one of claims 1-7 according to service roles. method.