Service self-evolution method, device, equipment and medium

Abstract

The invention provides a service self-evolution method and device, equipment and a medium, and relates to the technical field of communication. The method comprises the following steps: a first network element sends a micro-service request to a second network element; the first network element receives a micro-service response sent by the second network element, wherein the micro-service response comprises a micro-service; and the first network element generates a target network structure and a target communication flow of the edge core network according to the micro service. According to the scheme of the invention, the generation and flexible expansion of the network are realized.

Description

Technical Field

[0001] The present invention relates to the field of communication technology, and in particular to a service self-evolution method, device, equipment and medium. Background Art

[0002] From the Serving GPRS Support Node (SGSN) and Gateway GPRS Support Node (GGSN) in the 3G era, to the LTE (Long Term Evolution) architecture in the 4G era, to the core network in the 5G era with access and mobility management function (AMF), session management function (SMF), user plane function (UPF) and other network elements as the main components, the evolution of network architecture has always been the unchanging theme of the mobile core network.

[0003] With the development of artificial intelligence, some technologies have been developed that can automatically design the form of certain objects, such as reinforcement learning and evolutionary algorithms. In the 6G era, artificial intelligence will be deeply integrated with the communication network, and it has become possible to achieve the self-evolution of the network's form with the help of related artificial intelligence technologies. Therefore, in the face of the increasing complexity of 6G network service requirements and application scenarios, the solution space for network form has expanded dramatically. How to achieve the self-evolution of the network's form has become an urgent problem to be solved. Summary of the invention

[0004] The purpose of the present invention is to provide a service self-evolution method, device, equipment and medium to achieve flexible deployment of services.

[0005] To achieve the above object, an embodiment of the present invention provides a service self-evolution method, comprising:

[0006] The first network element sends a microservice request to the second network element;

[0007] The first network element receives a microservice response sent by the second network element, where the microservice response includes a microservice;

[0008] The first network element generates a target network structure and a target communication process of the edge core network according to the microservice.

[0009] Optionally, the first network element generates a network service structure and a communication process of the edge core network according to the microservice, including:

[0010] The first network element obtains a target service according to the microservice, where the target service includes one or more microservice combinations;

[0011] The first network element determines target placement information of the target service on a network node, and generates the target network structure according to the target placement information;

[0012] The first network element generates the target communication process according to the target service and the target placement information.

[0013] Optionally, the first network element obtains a target service according to the microservice, including:

[0014] The first network element determines a candidate service according to the microservice;

[0015] The first network element obtains the target service output by the first network by inputting the candidate service into the first network;

[0016] The input of the first network also includes a first stage identifier.

[0017] Optionally, the first network element determines target placement information of the target service on a network node, including:

[0018] The first network element obtains the target placement information output by the second network by inputting the target service into the second network;

[0019] The input of the second network also includes currently determined placement information and a second stage identifier.

[0020] Optionally, the first network element generates the target communication process according to the target service and the target placement information, including:

[0021] The first network element obtains the target communication process output by the third network by inputting the target service and the target placement information into a third network;

[0022] The input of the third network also includes the currently determined network state and the third stage identifier.

[0023] Optionally, the method further comprises:

[0024] The first network element trains the first network, the second network and the third network according to the microservice until the quality of service (Qos) and the communication target corresponding to the training communication process output by the third network meet preset requirements.

[0025] To achieve the above object, an embodiment of the present invention provides a service self-evolution method, comprising:

[0026] The second network element receives the microservice request sent by the first network element;

[0027] The second network element sends a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0028] Optionally, the method further comprises:

[0029] After the second network element receives the microservice request, the first component sends an entity and relationship extraction request to the second component;

[0030] After receiving the entities and relationships of the second component, the first component sends a graph creation request to a third component, wherein the graph creation request includes the entities and relationships;

[0031] After receiving the undirected weighted graph created by the third component, the first component sends a microservice extraction request to the fourth component, where the microservice extraction request includes the undirected weighted graph.

[0032] Optionally, the entity and relationship extraction request includes an identifier and network characteristics of the second network;

[0033] The method further comprises:

[0034] After receiving the entity and relationship extraction request, the second component sends a design document request to a fifth component, wherein the design document request includes an identifier of the second network;

[0035] The fifth component queries the core network code and protocol corresponding to the second network according to the identifier of the second network, and sends a design document response to the second component, where the design document response includes the core network code and protocol;

[0036] After receiving the design document response, the second component determines the entities and relationships according to the core network code and protocol, and sends an entity and relationship extraction response to the second network element, wherein the entity and relationship extraction response includes the entities and relationships.

[0037] Optionally, the entities and relationships include: one or more entities, and relationships between different entities;

[0038] The type of the one or more entities includes at least one of the following:

[0039] module entity;

[0040] Functional entity;

[0041] Data entity;

[0042] Step entity.

[0043] Optionally, the method further comprises:

[0044] After receiving the graph creation request, the third component creates the undirected weighted graph according to the entities and relationships, and sends a graph creation response to the second network element, where the graph creation response includes the undirected weighted graph;

[0045] The nodes of the undirected weighted graph are the entities in the entities and relationships, and the edges of the undirected weighted graph are the relationships between two connected entities.

[0046] Optionally, the undirected weighted graph further includes a weight of each edge, and the weight is related to the types of two connected entities.

[0047] Optionally, if the first edge connects the first module entity and the first functional entity, the weight of the first edge is determined by whether the first module entity includes the first functional entity;

[0048] If the second edge connects the second functional entity and the first data entity, the weight of the second edge is determined by the number of times the second functional entity writes and reads the first data entity;

[0049] If a third edge connects a second data entity and a third data entity, the weight of the third edge is determined by a mapping method between the second data entity and the third data entity;

[0050] If the fourth edge connects the third functional entity and the first step entity, the weight of the fourth edge is determined by the number of levels of the first step entity calling the third functional entity.

[0051] Optionally, the method further comprises:

[0052] After receiving the extraction request of the microservice, the fourth component determines the microservice according to the undirected weighted graph, and sends an extraction response of the microservice to the second network element, where the extraction response of the microservice includes the microservice.

[0053] To achieve the above object, an embodiment of the present invention provides a service self-evolution device, wherein the service self-evolution device is a first network element, including:

[0054] A first sending module, used to send a microservice request to a second network element;

[0055] A first receiving module is used to receive a microservice response sent by the second network element, where the microservice response includes a microservice;

[0056] The first processing module is used to generate a target network structure and a target communication process of the edge core network according to the microservice.

[0057] To achieve the above object, an embodiment of the present invention provides a network device, including a transceiver and a processor.

[0058] The transceiver is used to: send a microservice request to the second network element;

[0059] The transceiver is further used to: receive a microservice response sent by the second network element, wherein the microservice response includes a microservice;

[0060] The processor is used to generate a target network structure and a target communication process of an edge core network according to the microservice.

[0061] To achieve the above object, an embodiment of the present invention provides a service self-evolution device, wherein the service self-evolution device is a second network element, including:

[0062] A second receiving module, used to receive a microservice request sent by the first network element;

[0063] The second sending module is used to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0064] To achieve the above object, an embodiment of the present invention provides a network device, including a transceiver, wherein the transceiver is used to receive a microservice request sent by a first network element;

[0065] The transceiver is further configured to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0066] To achieve the above-mentioned purpose, an embodiment of the present invention provides a communication terminal, including a transceiver, a processor, a memory, and a program or instruction stored in the memory and executable on the processor; when the processor executes the program or instruction, the service self-evolution method as described above is implemented.

[0067] To achieve the above objective, an embodiment of the present invention provides a readable storage medium having a program or instruction stored thereon, and the program or instruction, when executed by a processor, implements the steps in the service self-evolution method as described above.

[0068] The beneficial effects of the above technical solution of the present invention are as follows:

[0069] According to the method of the embodiment of the present invention, the first network element can send a microservice request to the second network element, requesting the second network element to extract the microservice. After that, the first network element receives the microservice extracted by the second network element, and generates a target network structure and a target communication process of the edge core network, thereby realizing the generation and flexible expansion of the network. BRIEF DESCRIPTION OF THE DRAWINGS

[0070] Figure 1 This is one of the flow charts of the service self-evolution method according to an embodiment of the present invention;

[0071] Figure 2 is a schematic diagram of a first network element;

[0072] Figure 3 is a schematic diagram of the network generator;

[0073] Figure 4 This is the second flowchart of the service self-evolution method according to an embodiment of the present invention;

[0074] Figure 5 is a schematic diagram of interaction between a first network element and a second network element in an embodiment of the present invention;

[0075] Figure 6 is a schematic diagram of a second network element;

[0076] Figure 7 It is a schematic diagram of the calling series;

[0077] Figure 8 This is a schematic diagram of an application of the second network element side method according to an embodiment of the present invention;

[0078] Fig. 9 for Figure 1 The corresponding schematic diagram of the device structure;

[0079] Fig.10 for Figure 4 The corresponding schematic diagram of the device structure;

[0080] Fig.11 is a structural diagram of a network device according to an embodiment of the present invention;

[0081] Fig.12 This is a structural diagram of a network device according to another embodiment of the present invention. DETAILED DESCRIPTION

[0082] In order to make the technical problems, technical solutions and advantages to be solved by the present invention more clear, a detailed description will be given below with reference to the accompanying drawings and specific embodiments.

[0083] It should be understood that the references to "one embodiment" or "an embodiment" throughout the specification mean that the specific features, structures, or characteristics associated with the embodiment are included in at least one embodiment of the present invention. Therefore, the references to "in one embodiment" or "in an embodiment" appearing throughout the specification do not necessarily refer to the same embodiment. In addition, these specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0084] In various embodiments of the present invention, it should be understood that the size of the serial numbers of the following processes does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0085] Additionally, the terms "system" and "network" are often used interchangeably herein.

[0086] In the embodiments provided in the present application, it should be understood that "B corresponding to A" means that B is associated with A, and B can be determined according to A. However, it should also be understood that determining B according to A does not mean determining B only according to A, and B can also be determined according to A and / or other information.

[0087] For ease of understanding, some contents involved in the embodiments of the present invention are described below:

[0088] 1. In 5G, services exist in network elements and network slices, which are difficult to flexibly schedule and deploy. Therefore, network elements or network slices will not be used as the smallest unit when the 6G edge core network service form evolves. Considering that network elements or network slices are composed of services, and services are composed of microservices, the smallest evolution unit in the self-evolution of the 6G edge core network architecture form is microservices. The granularity of microservices can be regarded as the boundary of a microservice and its life cycle. A good microservice division can maintain the maintainability, scalability, automated deployment and flexibility of technology selection of the system. And relevant research has shown that the granularity of microservices will affect the quality of service (QoS).

[0089] 2. New value-added services can be produced through service combination, so that the system functions can be flexibly expanded. The combined service is called a composite service, and the services that make up the composite service are member services. The call of the composite service to the member service operation is a manifestation of service reuse, that is, a service is called multiple times. The loss of resources can be reduced to improve QoS by service reuse. In this embodiment, the combination of the core network services is regarded as a form of core network services, so this step and the service placement step will be modeled together as a Markov decision process.

[0090] 3. Deployment in the edge core network needs to rely on the hardware resources in the environment where the edge core network is located, such as CPU, memory size, hard disk size, etc. Reasonable allocation of resources is achieved through service placement. After the service placement is completed, the physical or virtual container and the services contained in the container will form a network element instance. The advantage of modeling service composition and service placement together as a Markov decision process is that the quality of the strategies in service composition and service placement can be evaluated from a global perspective. If the service composition and service placement are separated, it may lead to local optimal situations. For example, in distributed execution, when the service composition is completed, an optimal combination solution will be obtained, but because the service has been combined, it may not be possible to achieve the optimal solution when the service is placed.

[0091] like Figure 1 As shown, a service self-evolution method according to an embodiment of the present invention includes:

[0092] Step 101: The first network element sends a microservice request to the second network element;

[0093] Step 102: The first network element receives a microservice response sent by the second network element, where the microservice response includes a microservice;

[0094] Step 103: The first network element generates a target network structure and a target communication process of the edge core network according to the microservice.

[0095] Here, the first network element is an evolved network element in the edge core network, called Evolution Network Function (Edge Core Network); the second network element is an evolved network element in the cloud core network, called Evolution Network Function (Cloud Core Network). When the edge core network finds that the network needs to evolve, the first network element can send a microservice request to the second network element, requesting the second network element to extract microservices. The second network element responds to the microservice request, extracts microservices, and feeds back the extracted microservices to the first network element through a microservice response, so that after the first network element receives the extracted microservices, it generates the target network structure and target communication process of the edge core network, realizing the generation and flexible expansion of the network.

[0096] As an optional implementation, the first network element sends Nenf_UpdateMicroService_Request (i.e., microservice request) to request the second network element to extract microservices. After extracting microservices, the second network element sends the result to the first network element through Nenf_UpdateMicroService_Response (i.e., microservice response).

[0097] As an optional implementation, the microservices included in the microservice response are represented as a set of microservices Ms: {Ms1, Ms2, ..., Ms n}.

[0098] Optionally, the structure of the first network element is as follows: Figure 2 As shown, it includes a MicroService Set and a Network Generator. MicroService Set is responsible for storing microservices, and Network Generator is responsible for generating networks.

[0099] As an optional implementation manner, after receiving Nenf_UpdateMicroService_Response, the first network element stores the microservice in Microservice Set.

[0100] In this embodiment, a microservice is defined using the input (Ms.I,), output (Ms.O) of the microservice, and the resources consumed by the microservice (Ms.R), namely, the microservice Ms: (Ms.R, Ms.I, Ms.O).

[0101] Optionally, the first network element generates a network service structure and a communication process of the edge core network according to the microservice, including:

[0102] The first network element obtains a target service according to the microservice, where the target service includes one or more microservice combinations;

[0103] The first network element determines target placement information of the target service on a network node, and generates the target network structure according to the target placement information;

[0104] The first network element generates the target communication process according to the target service and the target placement information.

[0105] That is, the first network element will take the acquired microservice set as the starting point, generate a new service network element through service combination and placement, and realize network self-evolution.

[0106] like Figure 3As shown, the network generated by Network Generator is mainly divided into the first network, the second network and the third network, which can be understood as three stages. Among them, the first network (such as Service Composition Neural Networks) corresponds to the first stage, that is, the service composition stage; the second network (such as Service Placement Neural Networks) corresponds to the second stage, that is, the service placement stage; the third network (such as Procedure Generation Neural Networks) is the process generation stage, that is, the process generation stage. Training Network Generator is also divided into the same three stages.

[0107] In this embodiment, the current stage can be controlled by setting a flag (such as an identifier) ​​Φ, such as: The identifier Φ of the first network is also called the first-stage identifier, the identifier Φ of the second network is also called the second-stage identifier, and the identifier Φ of the third network is also called the third-stage identifier.

[0108] like Figure 3 As shown, Network Generator also includes a memory pool and a training module (Train). The memory pool is used to record the data generated during training and application, and the train is used to sample data from the memory pool for training and update the parameters in the service composition neural networks, service placement neural networks, and procedure generation neural networks, such as the PPO algorithm.

[0109] Optionally, in this embodiment, the method further includes:

[0110] The first network element trains the first network, the second network and the third network according to the microservice until the quality of service (Qos) and the communication target corresponding to the training communication process output by the third network meet preset requirements.

[0111] That is, the first network element will be based on the set of microservices Ms: {M1, Ms2, ..., Ms n}, train the Network Generator.

[0112] Specifically, change the Ms in Microservice Set: {Ms1,Ms2,……,Ms n} Input into NetworkGenerator.

[0113] Assume Ms. i ∈Ms, an ordered tuple can be used to represent the service Service generated by the microservice combination = (Ms n ,Ms m ,……,Ms k ). Therefore, based on each microservice, the candidate service G can be determined t =(Service1,Service2,…,Service i ), Service i ∈Service. In the process of training the first network, the input of the first network is defined as (G t ,Φ t ), the output is action represents the action of the agent combination service, so the first network output After that, it can be known that the agent selects one or several microservices from the microservice set Ms to form a service, and the output of the first network can also be regarded as obtaining one or more services. During the training process, the time t is counted from t = 0 to t = x. At each time t, let Φ t =0 and (G t ,Φ t ) is input into Service Composition Neural Networks and output Acting on a collection of microservices results in G t Change to G t+1 . G t+1 will be used as the input for the next moment. Let reward r = 0, and the reward generated at each time t Recorded in the Memory Pool.

[0114] In this embodiment, Indicates the placement information (placement status) of the service, Composition. Among them, V t To represent a physical container or a virtual container for storing services, the container can be regarded as a node; E t The connection status between nodes, that is, the physical connection status between two physical containers or virtual containers. If there is a link, it is 1, and if there is no connection, it is 0; It is a node attribute, which can be the resources of the physical container or virtual container and the services included after the service is placed (0 before the service is placed), etc. Indicates the edge attribute, which can be the communication delay between two physical containers or virtual containers. In the process of training the second network, the input of the second network is defined as (G t ,D t ,Φ t ), the output is action represents the action of the agent placing the service. Therefore, the second network outputs After that, it can be known that the agent selects one or more services to be placed in an unplaced physical or virtual container, and the output of the second network can also be regarded as obtaining the placement information of one or more services. During the training process, the time t is counted from t = x to t = x + y. At each time t, let Φ t =1 and (G t ,D t ,Φ t ) is input into the second network and output G t This is the combination of microservices at time t=x in the first network training. Acting on G t Lead to D t Change to D t+1 . D t+1 will be used as the input for the next moment. Let reward r = 0, and the reward generated at each time t Recorded in the Memory Pool.

[0115] In this embodiment, the communication process is related to the service and the placement information of the service, and different communication processes may cause changes in the network state, such as the overall network delay. Therefore, the state of the process generation stage is S t =(s t ,D t ,G t ). Where s t is the network status, such as the overall network delay, the CPU and memory used by each network element instance, etc. In the process of training the third network, the input of the third network is defined as (s t ,G t ,D t ,Φ t ), the output is action represents the action generated by the agent process. Therefore, the third network outputs After that, it can be known that the intelligent agent selects the next network element instance for the user equipment that has completed a certain network element instance, then the output of the third network can also be regarded as obtaining the communication process. In this way, whether the training is completed is determined by whether the Qos and communication target g corresponding to the current communication process meet the preset requirements. That is, the reward of the third network consists of two parts, reward r = W1×QoS+W2×g, where W1 and W2 are weights. QoS can be indicators such as the delay of the user equipment's communication this time. Qos meets the preset requirements, that is, Qos reaches the corresponding threshold. Whether the communication target g meets the preset requirements, that is, whether the communication target of the current communication process is a specific communication target, such as user equipment switching cells, session establishment, etc. The Recorded in the Memory Pool.

[0116] After training is completed, the Network Generator can be used to generate the target network results and target communication process.

[0117] Optionally, in this embodiment, the first network element obtains a target service according to the microservice, including:

[0118] The first network element determines a candidate service according to the microservice;

[0119] The first network element obtains the target service output by the first network by inputting the candidate service into the first network;

[0120] The input of the first network also includes a first stage identifier.

[0121] That is to say, for the set of microservices Ms fed back by the second network element: {Ms1, Ms2, ..., Ms n}, based on each microservice, we can determine the candidate service G t =(Service1,Service2,…,Service i ), Service i Then, the first network element inputs the candidate service into the first network, and obtains the target service output by the first network by combining the first stage identifier.

[0122] Optionally, in this embodiment, the first network element determines the target placement information of the target service on the network node, including:

[0123] The first network element obtains the target placement information output by the second network by inputting the target service into the second network;

[0124] The input of the second network also includes currently determined placement information and a second stage identifier.

[0125] That is, the target service output by the first network is input into the second network, combined with the currently determined placement information and the second-stage identifier, to obtain the target placement information of the target service, so that it is known in which unplaced physical or virtual container the target service is placed, thereby determining the target network structure.

[0126] Optionally, in this embodiment, the first network element generates the target communication process according to the target service and the target placement information, including:

[0127] The first network element obtains the target communication process output by the third network by inputting the target service and the target placement information into a third network;

[0128] The input of the third network also includes the currently determined network state and the third stage identifier.

[0129] That is, the target service placement output by the second network is input into the third network, combined with the currently determined network state and the third stage identifier, to obtain the target communication process.

[0130] Of course, in this embodiment, the second network element can send the generated target network structure to the edge core network, such as sending it through Nenf_EventExposure_Evolute, to achieve network deployment.

[0131] It should be noted that the first network and the second network parts are modeled together as a Markov decision process, and on this basis, the self-evolution of the edge core network is completed.

[0132] like Figure 4 As shown, a service self-evolution method according to an embodiment of the present invention includes:

[0133] Step 401: The second network element receives a microservice request sent by the first network element;

[0134] Step 402: The second network element sends a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0135] According to step 401 and step 402, upon receiving the microservice request from the first network element, the second network element extracts the microservice and informs the first network element of the extracted microservice through the microservice response, so that the first network element can complete the self-evolution of the edge core network and realize the generation and flexible expansion of the network.

[0136] For example, Figure 5As shown, when the edge core network finds that the network needs to evolve, the first network element (EvolutionNetwork Function (Edge Core Network)) sends a microservice request (such as Nenf_UpdateMicroService_Request) to the second network element (Evolution Network Function (Cloud Core Network)) to request the Evolution Network Function (Cloud Core Network) to extract microservices. After the EvolutionNetwork Function (Cloud Core Network) extracts the microservices, it informs the Evolution Network Function (EdgeCore Network) of the acquired microservices through a microservice response (such as Nenf_UpdateMicroService_Response). After receiving the extracted microservices, the Evolution Network Function (Edge Core Network) will train the Network Generator. After the training is completed, the extracted microservices are input into the Network Generator to generate the target network structure, and Nenf_EventExposure_Evolute sends it to other network elements in the edge core network.

[0137] Optionally, the structure of the second network element, namely, Evolution Network Function (Cloud Core Network) is as follows: Figure 6 As shown, it includes a first component (such as an Evolution Network Function Controller (ENFC) component), a second component (such as an Entity and Relationships extraction component), a third component (such as a Graph Structure creation component), a fourth component (such as a Microservice extraction component) and a fifth component (such as a Design Document Set component).

[0138] Optionally, the method further comprises:

[0139] After the second network element receives the microservice request, the first component sends an entity and relationship extraction request to the second component;

[0140] After receiving the entities and relationships of the second component, the first component sends a graph creation request to a third component, wherein the graph creation request includes the entities and relationships;

[0141] After receiving the undirected weighted graph created by the third component, the first component sends a microservice extraction request to the fourth component, where the microservice extraction request includes the undirected weighted graph.

[0142] That is, after the second network element receives the microservice request from the first network element, the first component of the second network element will process the request and send an entity and relationship extraction request to the second component to request the extraction of entities and relationships. Furthermore, after receiving the entities and relationships fed back by the second component based on the entity and relationship extraction request, the first component can send a graph creation request to the third component, and after receiving the undirected weighted graph fed back by the third component based on the graph creation request, send a microservice extraction request to the fourth network element, so as to obtain the microservice and provide feedback to the first network element.

[0143] Among them, the entity and relationship extraction request sent by the first component to the second component can be Nenf_ExtractEntitiesAndRelationships_Request; the entities and relationships fed back by the second component based on the entity and relationship extraction request can be implemented through corresponding responses such as Nenf_ExtractEntitiesAndRelationships_Response. The graph creation request sent by the first component to the third component can be Nenf_CreateGraph_Request; the undirected weighted graph fed back by the third component based on the graph creation request can be implemented through corresponding responses such as Nenf_CreateGraph_Response. The microservice extraction request sent by the first component to the fourth network element can be Nenf_ExtractMicroservice_Request; the microservice fed back by the fourth component based on the microservice extraction request can be implemented through corresponding responses such as Nenf_ExtractMicroservice_Response.

[0144] The microservice request sent by the first network element includes the identifier (ID) of the edge core network and the characteristics of the edge core network (also called network characteristics), so that the second network element can feedback the adaptive microservice for the edge core network. The characteristics of the edge core network include but are not limited to the communication protocol required by the lock, the signaling distribution structure, the quality of service QoS called by the user, etc. The entity and relationship extraction request sent by the first component may also include the ID of the edge core network and the characteristics of the edge core network.

[0145] Optionally, the entity and relationship extraction request includes an identifier and network characteristics of the second network;

[0146] The method further comprises:

[0147] After receiving the entity and relationship extraction request, the second component sends a design document request to a fifth component, wherein the design document request includes an identifier of the second network;

[0148] The fifth component queries the core network code and protocol corresponding to the second network according to the identifier of the second network, and sends a design document response to the second component, where the design document response includes the core network code and protocol;

[0149] After receiving the design document response, the second component determines the entities and relationships according to the core network code and protocol, and sends an entity and relationship extraction response to the second network element, wherein the entity and relationship extraction response includes the entities and relationships.

[0150] That is, after the second component receives the extraction request for the entity and relationship, it obtains the core network code and protocol by sending a document request to the fifth component, so that the second component determines the entity and relationship based on the core network code and protocol, and feeds back to the first component.

[0151] Among them, the design document request sent by the second component to the fifth component can be Nenf_DesignDocument_Request; the core network code and protocol queried and fed back by the fifth component based on the design document request can be carried out through a corresponding response such as Nenf_DesignDocument_Response.

[0152] Optionally, in this embodiment, the entities and relationships include: one or more entities, and relationships between different entities;

[0153] The type of the one or more entities includes at least one of the following:

[0154] module entity;

[0155] Functional entity;

[0156] Data entity;

[0157] Step entity.

[0158] Here, module entity is an entity that contains multiple functions or subsystems. Function entity is an entity that contains a single system function. Data entity is an entity of service operation and stored data in 5G network. Step entity is an entity that constitutes the communication protocol process. The relationships between different entities are module-function relationship, function-data relationship, data-data relationship, and function-step relationship.

[0159] Specifically, the module entity and the function entity have a module-function relationship, which indicates the subordinate and inclusive relationship between the module and the function, for example, module A includes function B. The function entity and the data entity have a function-data relationship, which indicates the operational relationship between the function and the data, for example, function A stores data B and function A reads data C. The data entity and the data entity have a data-data relationship, which indicates the association relationship between the data, for example, a one-to-one relationship or a one-to-many relationship. The function entity and the step entity have a function-step relationship, which indicates the implementation relationship between the function and the step, for example, function A implements part of step B.

[0160] After receiving Nenf_DesignDocument_Response, the second component will extract entities and relationships based on the characteristics of the edge core network, the core network code and the protocol.

[0161] For module entities, classes or packages in design documents and code documents can be extracted as module entities.

[0162] For the functional entity, the function part in the code document can be regarded as the functional entity.

[0163] For data entities, a table in a database or a data structure defined in an external interface (openAPI) in a code can be extracted as a data entity.

[0164] For the step entity, the step in the 3GPP protocol process can be extracted as the step entity.

[0165] When extracting entities, the relationships between entities can also be extracted.

[0166] Taking the code in free5gc (a simulation software for 5G core network written in Go language) as an example, Go-callvis can be used to extract entities from free5gc and get the relationship between entities. Go-callvis is a Go program structure visualization tool based on Graphviz, which can display the call relationship between packages and functions, and between functions in the form of directed graphs.

[0167] When extracting module entities, function entities, and data entities in free5gc, first ignore the standard library in GO, as well as functions related to logging and error handling. The extracted functions are identified by "package name / function name". In this way, the module entity and function entity, as well as the module-function relationship, can be obtained. After obtaining the function entity, the data in the function can be extracted through regular expressions (keyword matching), the data entity can be obtained, and the data-data relationship and function-data relationship can be obtained.

[0168] Take the PDUestablish protocol in 3GPP as an example to extract the step entity. Use to and send in the protocol to locate the corresponding message and network node, and convert the unstructured data in the 3GPP protocol into structured data to extract the step entity. Use regular expressions (keyword matching) to find the functional entity related to the step in free5gc and get the function-step relationship.

[0169] Of course, the implementation methods for determining entities and relationships are not limited to the above contents and will not be listed one by one here.

[0170] Optionally, the method further comprises:

[0171] After receiving the graph creation request, the third component creates the undirected weighted graph according to the entities and relationships, and sends a graph creation response to the second network element, where the graph creation response includes the undirected weighted graph;

[0172] The nodes of the undirected weighted graph are the entities in the entities and relationships, and the edges of the undirected weighted graph are the relationships between two connected entities.

[0173] That is, the third component receives a graph creation request sent by the first component, the graph creation request carries the ID of the edge core network and the extracted entities and relationships, and can create an undirected weighted graph based on the extracted entities and relationships.

[0174] Optionally, the undirected weighted graph further includes a weight of each edge, and the weight is related to the types of two connected entities.

[0175] That is, in the process of creating an undirected weighted graph, a weight is calculated for each edge.

[0176] Optionally, if the first edge connects the first module entity and the first functional entity, the weight of the first edge is determined by whether the first module entity includes the first functional entity;

[0177] If the second edge connects the second functional entity and the first data entity, the weight of the second edge is determined by the number of times the second functional entity writes and reads the first data entity;

[0178] If a third edge connects a second data entity and a third data entity, the weight of the third edge is determined by a mapping method between the second data entity and the third data entity;

[0179] If the fourth edge connects the third functional entity and the first step entity, the weight of the fourth edge is determined by the number of levels of the first step entity calling the third functional entity.

[0180] That is, the weight of the module-function relationship depends on whether the module entity contains the connected function entity. For example, the weight w1 of the module-function relationship is:

[0181] The weight of the function-data relationship depends on the number of times the function entity writes and reads the connected data entity. For example, the weight w2 of the function-data relationship is: Among them, T(f j ,d k ) is the number of times the function node (i.e., the second function entity) writes and reads the data node (i.e., the first data entity), max(T(f j ,d k )) is the maximum number of write and read times for the data node.

[0182] The weight of the data-data relationship depends on the mapping method between the data entity and the connected data entity, so that different data nodes can be distinguished. For example, the weight w3 of the data-data relationship is: Among them, θ1, θ2, θ3 are pre-set, satisfying 0<θ3≤θ2≤θ1<1, such as

[0183] The weight of the function-step relationship depends on the level of the function entity called by the step entity. For example, the weight w4 of the function-step relationship is w4=θ n-1 . Where θ is preset, 0<θ<1. Where n is the number of levels called, such as Figure 7 As shown, for step 1, it can be determined from the calling relationship between step 1 and each function that the calling level n=1 between step 1 and function 1, function 5, function 7, the calling level n=2 between step 1 and function 2, function 6, the calling level n=3 between step 1 and function 3, and the calling level n=4 between step 1 and function 4.

[0184] Optionally, the method further comprises:

[0185] After receiving the extraction request of the microservice, the fourth component determines the microservice according to the undirected weighted graph, and sends an extraction response of the microservice to the second network element, where the extraction response of the microservice includes the microservice.

[0186] Here, the microservice extraction request sent by the first component to the fourth component includes the ID of the edge core network and the created undirected weighted graph. In this way, the fourth component will obtain the microservice based on the undirected weighted graph and feedback to the first component.

[0187] Among them, the way to determine microservices based on undirected weighted graphs can be achieved through graph clustering. Among them, graph clustering can use the Louvain algorithm, which is a community discovery algorithm based on modularity. Its basic idea is that nodes in the network try to traverse the community labels of all neighbors and select the community label that maximizes the modularity increment. After maximizing the modularity, each community is regarded as a new node, and the process is repeated until the modularity no longer increases. Modularity can be expressed as: in, A i,j represents the weight of the edge connecting nodes i and j, k i represents the sum of the weights of all edges connected to node i, m represents the sum of the weights of all edges in the graph, and c i Indicates the community to which node i currently belongs. In this embodiment, the community can be regarded as a microservice.

[0188] The module gain during the iteration process can be calculated using the following formula:

[0189]

[0190] Among them, Σ in represents the sum of link weights, Σ tot represents the sum of the associated link weights of the nodes in community C, k i represents the sum of the weights of all edges connected to node i, k i,in is the sum of the link weights from node i to the nodes in community C.

[0191] In this way, after the fourth component obtains the microservice through graph clustering, it will inform the first component of the microservice through the extraction response of the microservice, and then the first component will feed back to the first network element.

[0192] For example, Figure 8 As shown, the process of the second network element extracting microservices is as follows:

[0193] Step 801, the first network element sends a Nenf_UpdateMicroService_Request message to the Evolution Network Function (Cloud Core Network). The message includes the ID of the edge core network and the characteristics of the edge core network (such as the required communication protocol). The ENFC in the Evolution Network Function (Cloud Core Network) will process the message.

[0194] Step 802: ENFC sends a Nenf_ExtractEntitiesAndRelationships_Request message to Extract Entities and Relationships to request the extraction of entities and relationships. This message includes the edge core network ID and the characteristics of the edge core network (such as the required communication protocol).

[0195] Step 803, Extract Entities and Relationships sends a Nenf_DesignDocument_Request message to the Design Document Set. The message contains the ID of the edge core network. The message will request the Design Document Set to send the core network code and protocol.

[0196] Step 804: Design Document Set sends a Nenf_DesignDocument_Response message to Extract Entities and Relationships, which contains the edge core network ID, core network code and protocol.

[0197] Step 805, Extract Entities and Relationships extracts entities and relationships based on the characteristics of the edge core network (such as the required communication protocol), the core network code and the protocol after receiving the Nenf_DesignDocument_Response message.

[0198] Step 806: Extract Entities and Relationships sends a Nenf_ExtractEntitiesAndRelationships_Response message to ENFC, which includes the ID of the edge core network and the extracted entities and relationships.

[0199] Step 807: ENFC sends a Nenf_CreateGraph_Request message to Create Graph Structure, which includes the ID of the edge core network and the extracted entities and relationships.

[0200] Step 808, Create Graph Structure receives the Nenf_CreateGraph_Request message and constructs an undirected weighted graph based on entities and relationships.

[0201] Step 809: Create Graph Structure sends a Nenf_CreateGraph_Response message to ENFC, which includes the ID of the edge core network and the undirected weighted graph constructed in step 808.

[0202] Step 810: ENFC sends a Nenf_ExtractMicroservice_Request message to Extract Microservice, which includes the ID of the edge core network and the undirected weighted graph constructed in step 809.

[0203] Step 811, Extract Microservice receives the Nenf_ExtractMicroservice_Request message, and obtains the microservice through graph clustering based on the undirected weighted graph.

[0204] Step 812: Extract Microservice sends a Nenf_ExtractMicroservice_Response message to ENFC, which includes the ID of the edge core network and the microservice extracted in step 811.

[0205] In step 813, ENFC sends a Nenf_UpdateMicroService_Response message to the Edge Core Network, which includes the ID of the edge core network and the microservice extracted in step 811.

[0206] In summary, the method of the embodiment of the present invention defines corresponding entities and relationships, and uses the core network design document to extract entities and relationships, obtains an undirected weighted graph, and obtains microservices through a clustering algorithm. Then, based on the extracted microservices, the combination and placement of services are completed. The combination and placement of services will be modeled together as a Markov decision and solved using reinforcement learning, and the target network structure will be generated by self-evolution.

[0207] Among them, the automatic design of the edge core network service form is realized through the method of microservice extraction-service composition-service placement; the service composition part and the service placement part of the core network are modeled together as a Markov decision process, and on this basis, the automatic design of the edge core network is completed; the microservice division and extraction of the core network are completed by constructing a knowledge graph.

[0208] It should be noted that the method of the embodiment of the present invention is implemented in conjunction with the above-mentioned service self-evolution method executed by the first network element. The implementation method of the above-mentioned method embodiment is applicable to this method and can achieve the same technical effect.

[0209] like Fig. 9 As shown, a service self-evolution device according to an embodiment of the present invention, the service self-evolution device is a first network element, including:

[0210] A first sending module 910, configured to send a microservice request to a second network element;

[0211] A first receiving module 920 is configured to receive a microservice response sent by the second network element, where the microservice response includes a microservice;

[0212] The first processing module 930 is used to generate a target network structure and a target communication process of the edge core network according to the microservice.

[0213] Optionally, the first processing module is further used for:

[0214] Obtain a target service according to the microservice, wherein the target service includes one or more microservice combinations;

[0215] Determining target placement information of the target service on a network node, and generating the target network structure according to the target placement information;

[0216] The target communication process is generated according to the target service and the target placement information.

[0217] Optionally, the first processing module is further used for:

[0218] Determine candidate services based on the microservices;

[0219] By inputting the candidate service into the first network, the target service output by the first network is obtained;

[0220] The input of the first network also includes a first stage identifier.

[0221] Optionally, the first processing module is further used for:

[0222] By inputting the target service into a second network, obtaining the target placement information output by the second network;

[0223] The input of the second network also includes currently determined placement information and a second stage identifier.

[0224] Optionally, the first processing module is further used for:

[0225] By inputting the target service and the target placement information into a third network, the target communication process output by the third network is obtained;

[0226] The input of the third network also includes the currently determined network state and the third stage identifier.

[0227] Optionally, the device further comprises:

[0228] The second processing module is used to train the first network, the second network and the third network according to the microservice until the service quality Qos and the communication target corresponding to the training communication process output by the third network meet the preset requirements.

[0229] It should be noted that the device is a device that applies the above-mentioned service self-evolution method executed by the first network element. The implementation method of the above-mentioned method embodiment is applicable to the device and can also achieve the same technical effect.

[0230] like Fig.10 As shown, a service self-evolution device in an embodiment of the present invention, wherein the service self-evolution device is a second network element, includes:

[0231] The second receiving module 1010 is used to receive a microservice request sent by the first network element;

[0232] The second sending module 1020 is used to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0233] Optionally, the device further comprises:

[0234] A first component, a second component, a third component, a fourth component and a fifth component.

[0235] Optionally, after receiving the microservice request, the first component sends an entity and relationship extraction request to the second component;

[0236] After receiving the entities and relationships of the second component, the first component sends a graph creation request to a third component, wherein the graph creation request includes the entities and relationships;

[0237] After receiving the undirected weighted graph created by the third component, the first component sends a microservice extraction request to the fourth component, where the microservice extraction request includes the undirected weighted graph.

[0238] Optionally, the entity and relationship extraction request includes an identifier and network characteristics of the second network;

[0239] After receiving the entity and relationship extraction request, the second component sends a design document request to a fifth component, wherein the design document request includes an identifier of the second network;

[0240] The fifth component queries the core network code and protocol corresponding to the second network according to the identifier of the second network, and sends a design document response to the second component, where the design document response includes the core network code and protocol;

[0241] After receiving the design document response, the second component determines the entities and relationships according to the core network code and protocol, and sends an entity and relationship extraction response to the second network element, wherein the entity and relationship extraction response includes the entities and relationships.

[0242] Optionally, the entities and relationships include: one or more entities, and relationships between different entities;

[0243] The type of the one or more entities includes at least one of the following:

[0244] module entity;

[0245] Functional entity;

[0246] Data entity;

[0247] Step entity.

[0248] Optionally, after receiving the graph creation request, the third component creates the undirected weighted graph according to the entities and relationships, and sends a graph creation response to the second network element, wherein the graph creation response includes the undirected weighted graph;

[0249] The nodes of the undirected weighted graph are the entities in the entities and relationships, and the edges of the undirected weighted graph are the relationships between two connected entities.

[0250] Optionally, the undirected weighted graph further includes a weight of each edge, and the weight is related to the types of two connected entities.

[0251] Optionally, if the first edge connects the first module entity and the first functional entity, the weight of the first edge is determined by whether the first module entity includes the first functional entity;

[0252] If the second edge connects the second functional entity and the first data entity, the weight of the second edge is determined by the number of times the second functional entity writes and reads the first data entity;

[0253] If a third edge connects a second data entity and a third data entity, the weight of the third edge is determined by a mapping method between the second data entity and the third data entity;

[0254] If the fourth edge connects the third functional entity and the first step entity, the weight of the fourth edge is determined by the number of levels of the first step entity calling the third functional entity.

[0255] Optionally, after receiving the extraction request of the microservice, the fourth component determines the microservice according to the undirected weighted graph, and sends an extraction response of the microservice to the second network element, where the extraction response of the microservice includes the microservice.

[0256] It should be noted that the device is a device that applies the above-mentioned service self-evolution method executed by the second network element. The implementation method of the above-mentioned method embodiment is applicable to the device and can also achieve the same technical effect.

[0257] like Fig.11 As shown, a network device 1100 according to an embodiment of the present invention includes a processor 1110 and a transceiver 1120, wherein:

[0258] The transceiver is used to: send a microservice request to the second network element;

[0259] The transceiver is further used to: receive a microservice response sent by the second network element, wherein the microservice response includes a microservice;

[0260] The processor is used to generate a target network structure and a target communication process of an edge core network according to the microservice.

[0261] Optionally, the processor is further configured to:

[0262] Obtain a target service according to the microservice, wherein the target service includes one or more microservice combinations;

[0263] Determining target placement information of the target service on a network node, and generating the target network structure according to the target placement information;

[0264] The target communication process is generated according to the target service and the target placement information.

[0265] Optionally, the processor is further configured to:

[0266] Determine candidate services based on the microservices;

[0267] By inputting the candidate service into the first network, the target service output by the first network is obtained;

[0268] The input of the first network also includes a first stage identifier.

[0269] Optionally, the processor is further configured to:

[0270] By inputting the target service into a second network, obtaining the target placement information output by the second network;

[0271] The input of the second network also includes currently determined placement information and a second stage identifier.

[0272] Optionally, the processor is further configured to:

[0273] By inputting the target service and the target placement information into a third network, the target communication process output by the third network is obtained;

[0274] The input of the third network also includes the currently determined network state and the third stage identifier.

[0275] Optionally, the processor is further used to: train the first network, the second network and the third network according to the microservice until the quality of service (Qos) and the communication target corresponding to the training communication process output by the third network meet preset requirements.

[0276] The network device applies the service self-evolution method executed by the first network element as described above. The implementation of the above method embodiment is applicable to the network device and will not be described in detail here.

[0277] The embodiment of the present invention further provides a network device, including a transceiver,

[0278] The transceiver is used to receive a microservice request sent by the first network element;

[0279] The transceiver is further configured to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

[0280] Optionally, the transceiver is further used for:

[0281] After receiving the microservice request, the first component sends an entity and relationship extraction request to the second component;

[0282] After receiving the entities and relationships of the second component, the first component sends a graph creation request to a third component, wherein the graph creation request includes the entities and relationships;

[0283] After receiving the undirected weighted graph created by the third component, the first component sends a microservice extraction request to the fourth component, where the microservice extraction request includes the undirected weighted graph.

[0284] Optionally, the entity and relationship extraction request includes an identifier and network characteristics of the second network;

[0285] The transceiver is further configured to: after the second component receives the entity and relationship extraction request, send a design document request to the fifth component, wherein the design document request includes an identifier of the second network;

[0286] The network device also includes a processor,

[0287] The processor is used for the fifth component to query the core network code and protocol corresponding to the second network according to the identifier of the second network, and send a design document response to the second component, where the design document response includes the core network code and protocol;

[0288] The processor is also used to determine the entities and relationships according to the core network code and protocol after the second component receives the design document response, and send an entity and relationship extraction response to the second network element, and the entity and relationship extraction response includes the entity and relationship.

[0289] Optionally, the entities and relationships include: one or more entities, and relationships between different entities;

[0290] The type of the one or more entities includes at least one of the following:

[0291] module entity;

[0292] Functional entity;

[0293] Data entity;

[0294] Step entity.

[0295] Optionally, the processor is further configured to:

[0296] After receiving the graph creation request, the third component creates the undirected weighted graph according to the entities and relationships, and sends a graph creation response to the second network element, where the graph creation response includes the undirected weighted graph;

[0297] The nodes of the undirected weighted graph are the entities in the entities and relationships, and the edges of the undirected weighted graph are the relationships between two connected entities.

[0298] Optionally, the undirected weighted graph further includes a weight of each edge, and the weight is related to the types of two connected entities.

[0299] Optionally, if the first edge connects the first module entity and the first functional entity, the weight of the first edge is determined by whether the first module entity includes the first functional entity;

[0300] If the second edge connects the second functional entity and the first data entity, the weight of the second edge is determined by the number of times the second functional entity writes and reads the first data entity;

[0301] If a third edge connects a second data entity and a third data entity, the weight of the third edge is determined by a mapping method between the second data entity and the third data entity;

[0302] If the fourth edge connects the third functional entity and the first step entity, the weight of the fourth edge is determined by the number of levels of the first step entity calling the third functional entity.

[0303] Optionally, the processor is further configured to:

[0304] After receiving the extraction request of the microservice, the fourth component determines the microservice according to the undirected weighted graph, and sends an extraction response of the microservice to the second network element, where the extraction response of the microservice includes the microservice.

[0305] The network device applies the service self-evolution method executed by the second network element as described above. The implementation of the above method embodiment is applicable to the network device and will not be described in detail here.

[0306] A network device according to another embodiment of the present invention, such as Fig.12 As shown, it includes a transceiver 1210, a processor 1200, a memory 1220, and a program or instruction stored on the memory 1220 and executable on the processor 1200; when the processor 1200 executes the program or instruction, it implements the above-mentioned service self-evolution method applied to the first network element, or the above-mentioned service self-evolution method applied to the second network element.

[0307] The transceiver 1210 is used to receive and send data under the control of the processor 1200 .

[0308] Among them, Fig.12 In the embodiment, the bus architecture may include any number of interconnected buses and bridges, specifically one or more processors represented by processor 1200 and various circuits of memory represented by memory 1220 are linked together. The bus architecture may also link together various other circuits such as peripherals, voltage regulators, and power management circuits, which are well known in the art and are therefore not further described herein. The bus interface provides an interface. The transceiver 1210 may be a plurality of components, namely, a transmitter and a receiver, providing a unit for communicating with various other devices on a transmission medium. The processor 1200 is responsible for managing the bus architecture and general processing, and the memory 1220 may store data used by the processor 1200 when performing operations.

[0309] A readable storage medium of an embodiment of the present invention stores a program or instruction thereon. When the program or instruction is executed by a processor, the program or instruction implements the service self-evolution method applied to the first network element as described above, or the steps in the service self-evolution method applied to the second network element as described above, and can achieve the same technical effect. To avoid repetition, it will not be repeated here.

[0310] The processor is the processor in the above-mentioned embodiment. The readable storage medium includes a computer-readable storage medium, such as a computer read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0311] It should be further explained that many functional components described in this specification are referred to as modules in order to more particularly emphasize the independence of their implementation methods.

[0312] In the embodiment of the present invention, module can be implemented with software so that it can be executed by various types of processors. For example, an executable code module of an identification can include one or more physical or logical blocks of computer instructions, for example, it can be constructed as an object, process or function. Nevertheless, the executable code of the identified module does not need to be physically located together, but can include different instructions stored in different positions, and when these instructions are logically combined together, it constitutes a module and realizes the specified purpose of the module.

[0313] In fact, executable code module can be a single instruction or many instructions, and can even be distributed on a plurality of different code segments, distributed among different programs, and distributed across a plurality of memory devices. Similarly, operating data can be identified in the module, and can be implemented and organized in the data structure of any appropriate type according to any appropriate form. The operating data can be collected as a single data set, or can be distributed in different locations (including on different storage devices), and can only be present on a system or network as an electronic signal at least in part.

[0314] When a module can be implemented by software, considering the level of existing hardware technology, a person skilled in the art can build a corresponding hardware circuit to implement the corresponding function of the module that can be implemented by software without considering the cost. The hardware circuit includes a conventional very large scale integration (VLSI) circuit or gate array and existing semiconductors such as logic chips, transistors, or other discrete components. The module can also be implemented by a programmable hardware device, such as a field programmable gate array, a programmable array logic, a programmable logic device, etc.

[0315] The above exemplary embodiments are described with reference to the accompanying drawings, and many different forms and embodiments are feasible without departing from the spirit and teachings of the present invention. Therefore, the present invention should not be constructed as a limitation of the exemplary embodiments proposed herein. More specifically, these exemplary embodiments are provided so that the present invention will be perfect and complete, and the scope of the present invention will be conveyed to those who are familiar with the technology. In these figures, the component sizes and relative sizes may be exaggerated for clarity. The terms used here are only based on the purpose of describing specific exemplary embodiments and are not intended to be limiting. As used herein, unless the text clearly indicates otherwise, the singular forms "one", "an" and "the" are intended to include these multiple forms. It will be further understood that the terms "including" and / or "comprising" when used in this specification indicate the presence of the features, integers, steps, operations, components and / or components, but do not exclude the presence or increase of one or more other features, integers, steps, operations, components, components and / or their groups. Unless otherwise indicated, when stated, a range of values ​​includes the upper and lower limits of that range and any subranges therebetween.

[0316] The above is a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A service self-evolution method, characterized in that: include: The first network element sends a microservice request to the second network element; The first network element receives a microservice response sent by the second network element, where the microservice response includes a microservice; The first network element generates a target network structure and a target communication process of the edge core network according to the microservice.

2. The method according to claim 1, characterized in that The first network element generates a network service structure and a communication process of the edge core network according to the microservice, including: The first network element obtains a target service according to the microservice, where the target service includes one or more microservice combinations; The first network element determines target placement information of the target service on a network node, and generates the target network structure according to the target placement information; The first network element generates the target communication process according to the target service and the target placement information.

3. The method according to claim 2, characterized in that The first network element obtains a target service according to the microservice, including: The first network element determines a candidate service according to the microservice; The first network element obtains the target service output by the first network by inputting the candidate service into the first network; The input of the first network also includes a first stage identifier.

4. The method according to claim 2, characterized in that: The first network element determines target placement information of the target service on the network node, including: The first network element obtains the target placement information output by the second network by inputting the target service into the second network; The input of the second network also includes currently determined placement information and a second stage identifier.

5. The method according to claim 2, characterized in that: The first network element generates the target communication process according to the target service and the target placement information, including: The first network element obtains the target communication process output by the third network by inputting the target service and the target placement information into a third network; The input of the third network also includes the currently determined network state and the third stage identifier.

6. The method according to claim 1, characterized in that The method further comprises: The first network element trains the first network, the second network and the third network according to the microservice until the quality of service (Qos) and the communication target corresponding to the training communication process output by the third network meet preset requirements.

7. A service self-evolution method, characterized in that: include: The second network element receives the microservice request sent by the first network element; The second network element sends a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

8. The method according to claim 7, characterized in that The method further comprises: After the second network element receives the microservice request, the first component sends an entity and relationship extraction request to the second component; After receiving the entities and relationships of the second component, the first component sends a graph creation request to a third component, wherein the graph creation request includes the entities and relationships; After receiving the undirected weighted graph created by the third component, the first component sends a microservice extraction request to the fourth component, where the microservice extraction request includes the undirected weighted graph.

9. The method according to claim 8, characterized in that The entity and relationship extraction request includes an identifier and network characteristics of the second network; The method further comprises: After receiving the entity and relationship extraction request, the second component sends a design document request to a fifth component, wherein the design document request includes an identifier of the second network; The fifth component queries the core network code and protocol corresponding to the second network according to the identifier of the second network, and sends a design document response to the second component, where the design document response includes the core network code and protocol; After receiving the design document response, the second component determines the entities and relationships according to the core network code and protocol, and sends an entity and relationship extraction response to the second network element, wherein the entity and relationship extraction response includes the entities and relationships.

10. The method according to claim 9, characterized in that The entities and relationships include: one or more entities, and relationships between different entities; The type of the one or more entities includes at least one of the following: module entity; Functional entity; Data entity; Step entity.

11. The method according to claim 8, characterized in that The method further comprises: After receiving the graph creation request, the third component creates the undirected weighted graph according to the entities and relationships, and sends a graph creation response to the second network element, where the graph creation response includes the undirected weighted graph; The nodes of the undirected weighted graph are the entities in the entities and relationships, and the edges of the undirected weighted graph are the relationships between two connected entities.

12. The method according to claim 11, characterized in that The undirected weighted graph also includes a weight for each edge, where the weight is related to the types of two connected entities.

13. The method according to claim 12, characterized in that If a first edge connects a first module entity and a first functional entity, the weight of the first edge is determined by whether the first module entity includes the first functional entity; If the second edge connects the second functional entity and the first data entity, the weight of the second edge is determined by the number of times the second functional entity writes and reads the first data entity; If a third edge connects a second data entity and a third data entity, the weight of the third edge is determined by a mapping method between the second data entity and the third data entity; If the fourth edge connects the third functional entity and the first step entity, the weight of the fourth edge is determined by the number of levels of the first step entity calling the third functional entity.

14. The method according to claim 8, characterized in that The method further comprises: After receiving the extraction request of the microservice, the fourth component determines the microservice according to the undirected weighted graph, and sends an extraction response of the microservice to the second network element, where the extraction response of the microservice includes the microservice.

15. A service self-evolution device, characterized in that: The service self-evolution device is a first network element, including: A first sending module, used to send a microservice request to a second network element; A first receiving module is used to receive a microservice response sent by the second network element, where the microservice response includes a microservice; The first processing module is used to generate a target network structure and a target communication process of the edge core network according to the microservice.

16. A network device, characterized in that: Including transceivers and processors, The transceiver is used to: send a microservice request to the second network element; The transceiver is further used to: receive a microservice response sent by the second network element, wherein the microservice response includes a microservice; The processor is used to generate a target network structure and a target communication process of an edge core network according to the microservice.

17. A service self-evolution device, characterized in that: The service self-evolution device is a second network element, including: A second receiving module, used to receive a microservice request sent by the first network element; The second sending module is used to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

18. A network device, characterized in that: Including transceiver, The transceiver is used to receive a microservice request sent by the first network element; The transceiver is further configured to send a microservice response to the first network element according to the microservice request, where the microservice response includes the microservice acquired by the second network element.

19. A readable storage medium having a program or instruction stored thereon, characterized in that: When the program or instruction is executed by the processor, the steps in the service self-evolution method as described in any one of claims 1-6 are implemented, or the steps in the service self-evolution method as described in any one of claims 7-14 are implemented.

Images