Network-assisted application-layer request flow management in service meshes

Abstract

Techniques for service level performance updates based on network level factors are described. by establishing a co-operative model between a network fabric and service proxies to enhance the service mesh failure management primitives as well as bring in network level intelligence in service (service instance) placement decisions in the fabric. A virtual network edge (VNE) instance interacts with the network fabric including the next level switches (such as a top of rack switch) and a network controller in order to determine a network level health-score and a modulated health-score for a service instance executing on the node. The modulated health score causes actions such as an influence on load balancing, request routing, rolling upgrades, canary deployments, change in the utilization of network resources, a downgrade of service, etc., based on the network level health-score.

Description

TECHNICAL FIELD

Embodiments presented in this disclosure generally relate deployment and management of network fabrics and service meshes within the network fabrics. More specifically, embodiments disclosed herein include using network level performance insights to modulate health scores for service level applications, services, and/or micro-services.

BACKGROUND

In current network fabric designs and implementations, there is an increasing focus on using service meshes to provide Layer 7 (L7) services for applications on the network. A sidecar proxy is a proxy instance that is dedicated to a specific application instance (e.g., per application container pod) and communicates with other sidecar proxies executing on different nodes for information regarding the application.

Sidecar proxies are often used due to their utility and reliability in providing required services. For instance, middle proxies are not close enough to the workload to obtain information about the application instances without sending a query to each of the nodes. Additionally, middle proxies can be a single point of failure for a plurality of nodes. Sidecar proxies solve these issues by executing in tandem with the application instances and providing a distributed information source such that the failure of one does not condemn the whole system. However, sidecar proxies are inefficient in obtaining information regarding application/service instances executing on other nodes and the network wide service level performance of the application/service and updating a performance of the service instance based on the network wide service level performance.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above-recited features of the present disclosure can be understood in detail, a more particular description of the disclosure, briefly summarized above, may be had by reference to embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate typical embodiments and are therefore not to be considered limiting; other equally effective embodiments are contemplated.

FIG. 1 illustrates a network, according to one embodiment.

FIG. 2A depicts a system flow diagram for service level performance updates based on network level factors, according to one embodiment.

FIG. 2B depicts a method for service level performance updates based on network level factors.

FIG. 3 depicts a method for determining a network level health score, according to one embodiment.

FIG. 4 depicts a method for determining a modulated health-score, according to one embodiment.

FIG. 5 illustrates a block diagram of a virtual network edge instance, according to one embodiment.

To facilitate understanding, identical reference numerals have been used, where possible, to designate identical elements that are common to the figures. It is contemplated that elements disclosed in one embodiment may be beneficially used in other embodiments without specific recitation.

DESCRIPTION OF EXAMPLE EMBODIMENTS

Overview

A system of one or more computers can be configured to perform particular operations or actions by virtue of having software, firmware, hardware, or a combination of them installed on the system that in operation causes or cause the system to perform the actions. One or more computer programs can be configured to perform particular operations or actions by virtue of including instructions that, when executed by data processing apparatus, cause the apparatus to perform the actions. One general aspect includes a method for service level performance updates based on network level factors including: receiving at a virtual network edge (VNE) instance on a node, one or more network health indicators, determining from the one or more network health indicators, a network level health-score, determining from the network level health-score a modulated health-score for a service instance executing on the node, and updating a health-score of the service instance at the service proxy. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods.

One example embodiment includes a system for service level performance updates based on network level factors, including: a processor; and a memory including instructions which, when executed on the processor, performs an operation. The operation includes: receiving at a virtual network edge (VNE) instance on a node, one or more network health indicators, determining from the one or more network health indicators, a network level health-score, determining from the network level health-score a modulated health-score for a service instance executing on the node, and updating a health-score of the service instance at the service proxy.

One example embodiment includes a computer program product for service level performance updates based on network level factors, the computer program product including a non-transitory computer-readable medium program having program instructions embodied therewith, the program instructions executable by a processor to perform an operation. The operation includes: receiving at a virtual network edge (VNE) instance on a node, one or more network health indicators, determining from the one or more network health indicators, a network level health-score, determining from the network level health-score a modulated health-score for a service instance executing on the node, and updating a health-score of the service instance at the service proxy.

Example Embodiments

Service mesh data plane implementations in networks include proxies such as sidecar proxies. While these sidecar proxies delegate certain functions to other network components, these proxies do not have detailed insight into network fabric-level events such as congestion or service-level agreement (SLA) violations at network edges. This lack of insight into network fabric-level events may have adverse effects on services that make application traffic flow decisions based only on layer 7 (L7) parameters (ex: application load balancers, etc.). For example, an application load balancer may continue routing traffic via network elements that are congested and/or have failed for a period of time before the load balancer can detect the issue.

In some examples, a service mesh manages service-level (i.e., L7) communication. The service meshes provide powerful primitives that can be used for at least three failure management strategies. For example, service meshes implement: dynamic routing, which can be used for different release and testing strategies such as canary routing, traffic shadowing, or blue/green deployments; resilience, which mitigates the impact of failures through strategies such as circuit breaking and rate limiting; and observability, which helps improve response time of application behavior by collecting metrics and adding context (e.g., tracing data) to service-to-service communication.

As discussed above, a service mesh is usually implemented as a collection of inter-connected sidecar proxies where sidecar proxies are typically deployed per container pod on nodes. Sidecar proxies often delegate responsibilities including service discovery and service health to external providers (such as a datacenter fabric) in order to conserve bandwidth at the container and node. As described herein, the sidecar proxies may delegate service discovery and service health to a virtual network edge (VNE) instance on the node.

The systems and methods described herein provide for service level performance updates based on network level factors by establishing a co-operative model between a network fabric and service proxies to enhance the service mesh failure management primitives as well as bring in network level intelligence in service (service instance) placement decisions in the fabric. The VNE instance, with delegated responsibilities, interacts with the network fabric including the next level switches (such as a top of rack switch) and a network controller in order to determine a network level health-score and a modulated health-score for a service instance executing on the node. The modulated health score causes actions such as an influence on load balancing, request routing, rolling upgrades, canary deployments, change in the utilization of network resources, a downgrade of service, etc., based on the network level health-score.

FIG. 1 illustrates a network, according to one embodiment. The various elements of FIG. 1 communicate over a network using network switches such as through a leaf spine architecture, e.g., a CLOS network topology, although embodiments are not limited to this example and are applicable to any datacenter fabric or other network fabric monitored by a network controller.

The compute nodes, nodes 102a-102d, may be any computer systems configured to communicate with a network, such as computer systems in a datacenter. In some examples, the nodes 102a-d may host one or more container environments, such as Docker or Kubernetes containers which may be hosted on server computers. Each container environment includes a stand-alone executable software package which provides particular services and includes every element needed to run the software package, including code, runtime, system libraries, settings, etc. The container environments may implement a Container Network Interface (CNI) networking model or a Container Network Model (CNM) to perform local programming.

The nodes 102a-d also execute one or more service instances 103a-103d. In some examples, the one or more service instances 103a-103d comprise an application instance for an application, where the application instance is executed in a container environment. The varying nodes may execute application instances of various services. In some examples, the service instances 103a-103d executing on the various nodes may differ in configuration and/or application type. The application instances may be executed as part of a service mesh. The service mesh comprises a configurable infrastructure layer for one or more applications.

In some examples, the nodes 102a-d each comprise a VNE instance (e.g., the VNEs 105a-105d) executing on the node. The VNEs 105a-d comprises executable software which identifies and authenticates end points and registers end-point identification information in a fabric host-tracking database. The VNEs may also contain a port in each container pod namespace and act as a bridge between the nodes 102 and the top of rack (ToR) switches (e.g., switches 110a-110b).

As described herein, each local VNE instance acts as the proxy for any delegated L7 service. A delegated L7 service is one in which the network fabric provides policy or statistics for enforcement to the service proxies. In some examples, the actual enforcement of any application behavior can still be done by the service proxy 104 (e.g., a sidecar proxy).

In some examples, service proxies 104a-d execute in the container environment on the respective nodes. The service proxies 103a-d may be configured to implement enforcement of policies relating to the respective service instances. For example, the service proxy 103a may function as an Envoy sidecar proxy to enforce policies for an Envoy service mesh. The service proxy 103a may be further configured to communicate with the VNE 105a to obtain information regarding the service/application. For example, the network fabric may be integrated with the service mesh by allowing the VNE 105a to provide key services to either the service instance 103a or the service proxy 104a.

In some examples, the service proxies 104a-d query the VNE instances for performing specific checks such as determining health of a service, endpoint discovery, rate limiting, etc. In response, the VNE instance delegates to the next-hop switch, e.g., the switches 110a-110b. The fabric controller, e.g., the controller 120, downloads the requested information into the switches 110a-110b and the response from switch is then cached at the VNE instance level. Thus allowing the node-level proxy to provide delegated service health statistics to the mesh proxies in a hub-and-spoke model.

In some examples, the VNE routes network traffic through the switches 110a-110b. The switches 110a-110b comprise network switches which interconnect nodes in a network (such as nodes in a datacenter). In some examples the switches 110a-110b may be connected to one or more spines based on a leaf/spine datacenter fabric, such as the CLOS network topology.

The network controller 120 is a central entity that manages operation of a network fabric, such as by providing overlay reachability information and end points-to-routing location mapping. An example of a fabric controller is the Cisco Application Policy Infrastructure Controller (APIC) which is a unifying point of automation and management for the Cisco Application Centric Infrastructure (ACI) fabric. The network controller 120 may be implemented on a computing system that is communicatively coupled to the nodes through the network fabric architecture.

In some examples, the network controller 120 also functions as a container orchestrator which acts as a resource manager for container environments operating on nodes. The container orchestrator may allocate and provide resources to container environments, provide instructions to systems instructions executing container environments, obtain and distribute attribute data regarding container environments, and otherwise manage deployment and implementation of container environments.

FIG. 2 depicts a system flow diagram for service level performance updates based on network level factors, according to one embodiment. The examples discussed herein refer to VNE 105a, but may also apply to any VNE instance in the network 100. In some examples, VNE instances route and monitor application data relating to service instance. For example, as shown in steps 202 and 204, the VNE 105a routes and monitors outgoing and incoming application data traffic for the service instance 103a. In some examples, the VNE 105a further routes the application data to a destination via the network switch 110a.

In some examples, the VNE 105a is also delegated service health monitoring functions. For example, at step 206, the service proxy 104a associated with the service instance 102a sends a service health request to the VNE 105a. When the VNE 105a receives the service health request from the service proxy 104a, the VNE 105a queries a next-level network element for the one or more network health indicators at step 208. For example, the VNE 105a will query and/or delegate the request for service health request to the switch 110a.

At step 210, the switch 110a queries the controller 120 for the network level network health indicators. At step 212, the fabric controller, controller 120, downloads the requested information into the switch 110a and at step 214 the response (which includes the network health indicators from the switch 110a) is cached at the VNE level in the VNE 105a from the switch 110a. For example, as also shown in block 252 of method 200 in FIG. 2b, the VNE 105a receives the one or more network health indicators.

At step 216 in FIG. 2A and at block 254 in FIG. 2B, the VNE 105a determines from the network health indicators, a network level health-score and at step 218 in FIG. 2A and at block 256 in FIG. 2B, the VNE 105a determines a modulated health-score for the for the service instance 103a executing on the node 102a.

In some examples, the VNE 105a uses the upstream/external/global signals received in the network health indicators 212 to determine the network level health-score and in turn, the VNE 105a modulates/generates/changes the health-score of a particular app/service, e.g., the service instance 103a that is located behind an affected leaf/spine. In some examples, the modulated health-score influences an upstream L7-based service (such as a load-balancer) to degrade the availability of a specific service instance and lower its priority to serve traffic. This results in a reduced level of service/application requests being routed to the degraded instance, (e.g., 103a) which can be temporarily degraded and/or migrated from the node 102a. For example, as described in relation to method 400 of FIG. 4, the VNE 105a determines, based on the network level health-score, to lower a priority of the service instance at the node at block 402; and at block 404, determines the modulated health-score based on the lower priority determination, wherein the modulated health-score comprises a health-score for the service instance which lowers the priority of the service instance.

In some examples, the network health indicators include one or more congestion indicators, one or more node level indicators, and one or more network wide service level factors. For example, the congestion indicators may include indications of resource exhaustion or over-utilization at the leaf switch layer. These indicators may include signals related congestion-related resources such as buffer space, TCAM table space for ACLs, L2/L3 tables at a leaf that are needed to provide services to the service instance, etc. In some examples, the VNE 105a queries an upstream leaf for resource utilization metrics and determines the service utilization load on the leaf. For example, at block 302 of method 300 in FIG. 3, the VNE 105a determines a utilization of network resources for the service instance based on at least the one or more congestion indicators. In some examples, when the service and/or the service instance is consuming a disproportionate amount of resources at the leaf, then the health-score is modulated/degraded in order to reapportion the resource consumption. In such cases, the health-score values may be changed using a strategy such as Additive Increase Multiplicative Decrease feedback control algorithm (among others) to reduce the service resource utilization.

In some examples, the determination of the a network level health-score and the related modulation of the service instance health score is due to real or impending resource exhaustion or congestion being experienced by the upstream network as demonstrated by a queue buildup, such as in an L2/L3 table buildup etc. This congestion may be proactively triaged by the VNE instances by modulating/degrading health-scores to specific services instances hosted on the nodes in order to temporarily divert traffic.

In some examples, the determination of the a network level health-score and the related modulation of the service instance health score is related to a measure of the ratio of resource utilization of an service instance in the upstream switch, e.g., the switch 110a, to that service instance's usefulness to the service overall. For example, when the ratio is computed to be higher than a pre-defined threshold, then the VNE 105a modulates/degrades the service instance health score with an intent to evict the service instance 103a from the node 102a.

For example, the network fabric may track the percentage of resources consumed by a specific service/application instance as well as the percentage of overall traffic at the switch 110a consumed by the service instance 103a. In an example, where the percentage of resources used by the service instance is not proportional with the percentage of overall traffic for that service instance, then the affects the service instance are determined to be negatively affecting the switch and thus the associated VNE signals a an eviction in the modulated health-score, where the service instance is evicted/removed/transitioned from the node 102a.

In some examples, the one or more node level indicators include Node-level maintenance and/or high availability (HA) events. For example these indicators may include proactive notifications for nodes undergoing planned updates/maintenance. Returning to FIG. 3, at block 304, the VNE 105a determines a status for one or more network elements based on at least the one or more node level indicators. In this example, the controller 120 interacts with the container orchestrator and is notified of any upcoming maintenance events and informs the VNE 105a via the network health indicators as discussed in relation to steps 212 to 214 in FIG. 2A. In response, the VNEs 105a-d begin proactively modulating/degrading the health-score of the service instances located on the to-be affected hosts. For example, the health-score values change similar to a step-function at initiation and termination of the maintenance window thus preventing service instance traffic interruption.

In some examples, the one or more network wide service level factors include service-level insights from sensors in the network. This category of indicators relate to telemetry and other data gathered from various service/application level sensors which may include SLA violations and/or metrics that are customized for the specific service/application. At block 306 of FIG. 3, the VNE 105a determines a network wide service health based on at least the one or more network wide service level factors.

In some examples, AppD and/or other monitoring solutions are integrated with the controller 120 to provide visibility into issues/problems with services instances such as policy violations, anomalous network activity, maintenance (e.g., application needs to be updated), vulnerability alerts with application versions, etc. In general, these indicators relate to service health as measured by an external entity (e.g., the controller 120) which is integrated with the network fabric and not just service level health as computed by a service load balancer, etc.

In this example, the VNE instances 105a-d modulate/adjust the health-score in a spectrum based on the severity of the issue and the urgency to address it. For example, the health score for the service-instance may be downgraded severely for a critical issue and/or may also be downgraded to a lower degree for less critical issues in order for the service mesh to gradually adjust.

At step 220 in FIG. 2A and at block 258 in FIG. 2B, the VNE 105a provides the modulated health score to the service proxy 104a which in turn updates the modulated health score for the service 103a. In some examples, the service proxy 104a reports the modulated health-score to one or more of a network traffic controller or network traffic metrics collector on behalf of the service instance, to enhance the service mesh failure management primitives with the information derived from the network level factors.

FIG. 5 illustrates a block diagram of a node, according to one embodiment. The arrangement 500 may include a computer embodied as a node and configured to perform the methods described herein. The node 102 is shown in the form of a general-purpose computing device. The components of node 102 may include, but are not limited to processing units or processors 505, a system memory, memory 510, a storage system, storage 520, network interface 530, and a bus 550 that couples various system components including the system memory, memory 510 and storage system, storage 520, to processors 505 along with the network interface 530 and various input/output components and the network 100. In other embodiments, arrangement 500 is distributed and includes a plurality of discrete computing devices that are connected through wired or wireless networking.

Bus 550 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnects (PCI) bus.

Node 102 typically includes a variety of computer system readable media. Such media may be any available media that is accessible by Node 102, and it includes both volatile and non-volatile media, removable and non-removable media.

Memory 510 can include computer system readable media in the form of volatile memory, such as random access memory (RAM) and/or cache memory. Node 102 may further include other removable/non-removable, volatile/non-volatile computer system storage media. In some examples, 520 may be included as part of memory 510 and may typically provide a non-volatile memory for the networked computing devices, and may include one or more different storage elements such as Flash memory, a hard disk drive, a solid state drive, an optical storage device, and/or a magnetic storage device. For example, storage system, storage 520, can be provided for reading from and writing to a non-removable, non-volatile magnetic media (not shown and typically called a “hard drive”). Although not shown, a magnetic disk drive for reading from and writing to a removable, non-volatile magnetic disk (e.g., a “floppy disk”), and an optical disk drive for reading from or writing to a removable, non-volatile optical disk such as a CD-ROM, DVD-ROM or other optical media can be provided. In such instances, each can be connected to bus 550 by one or more data media interfaces. Storage 520 may include media for storing network health indicators 521, modulated health-scores 522 and other data described herein.

Memory 510 may include a plurality of program modules 515 for performing various functions related to the node described herein. The program modules 515 generally include program code that is executable by one or more of the processors 505. As shown, program modules 515 include the VNE module 511 and service modules 512 to perform the functions related to the VNE and service instances on a node. The program modules 515 may also interact with each other and storage system, storage 520, to perform certain functions as described herein.

In the current disclosure, reference is made to various embodiments. However, the scope of the present disclosure is not limited to specific described embodiments. Instead, any combination of the described features and elements, whether related to different embodiments or not, is contemplated to implement and practice contemplated embodiments. Additionally, when elements of the embodiments are described in the form of “at least one of A and B,” it will be understood that embodiments including element A exclusively, including element B exclusively, and including element A and B are each contemplated. Furthermore, although some embodiments disclosed herein may achieve advantages over other possible solutions or over the prior art, whether or not a particular advantage is achieved by a given embodiment is not limiting of the scope of the present disclosure. Thus, the aspects, features, embodiments and advantages disclosed herein are merely illustrative and are not considered elements or limitations of the appended claims except where explicitly recited in a claim(s). Likewise, reference to “the invention” shall not be construed as a generalization of any inventive subject matter disclosed herein and shall not be considered to be an element or limitation of the appended claims except where explicitly recited in a claim(s).

As will be appreciated by one skilled in the art, the embodiments disclosed herein may be embodied as a system, method or computer program product. Accordingly, embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, embodiments may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for embodiments of the present disclosure may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).

Aspects of the present disclosure are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatuses (systems), and computer program products according to embodiments presented in this disclosure. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the block(s) of the flowchart illustrations and/or block diagrams.

These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other device to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the block(s) of the flowchart illustrations and/or block diagrams.

The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process such that the instructions which execute on the computer, other programmable data processing apparatus, or other device provide processes for implementing the functions/acts specified in the block(s) of the flowchart illustrations and/or block diagrams.

The flowchart illustrations and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments. In this regard, each block in the flowchart illustrations or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the Figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

In view of the foregoing, the scope of the present disclosure is determined by the claims that follow.

Claims

1. A method for service level performance updates based on network level factors, the method comprising: receiving, at a virtual network edge (VNE) instance on a node, a service health request from a service proxy on the node, wherein the service health request indicates a delegation of application layer service health monitoring from the service proxy to the VNE instance, wherein the VNE instance performs the delegated application layer service health monitoring for the service proxy, wherein the VNE instance is collocated on the node with a service instance executing on the node and the service proxy executing on the node, wherein the service proxy controls application behaviors for the service instance based on an application layer health-score of the service instance;receiving, at the VNE instance, one or more network health indicators comprising network level indicators generated at a network controller for a network fabric and received from a delegated service health request network switch located between the node and the network controller in the network fabric;determining, at the VNE instance and from the one or more network health indicators, a network level health-score for the network fabric;determining, at the VNE instance and from the network level health-score, a modulated health-score for the service instance; andupdating the application layer health-score of the service instance at the service proxy to cause the service instance to alter its application behaviors within the service mesh based on the modulated health-score.

2. The method of claim 1, further comprising: in response to receiving the health service request, querying a next-level network element for the one or more network health indicators; andwherein the one or more network health indicators are received from the next-level network element in response to the query.

3. The method of claim 2, wherein updating the health-score of the service instance comprises: providing the modulated health-score to the service proxy, wherein the service proxy reports the modulated health-score to at least one of a network traffic controller and network traffic metrics collector on behalf of the service instance.

4. The method of claim 1, wherein the VNE instance serves as a proxy for one or more delegated services at the node.

5. The method of claim 1, wherein the one or more network health indicators comprise at least one of: a congestion indicator;a node level indicator; anda network wide service level factor.

6. The method of claim 5, wherein determining the network level health-score comprises at least one of: determining a utilization of network resources for the service instance based on at least the congestion indicator;determining a status for one or more network elements one based on at least the node level indicator; anddetermining a network wide service health based on at least the network wide service level factor.

7. The method of claim 1, wherein determining the modulated health-score for the service instance comprises: determining, based on the network level health-score, to lower a priority of the service instance at the node; anddetermining the modulated health-score based on the lower priority determination, wherein the modulated health-score comprises a health-score for the service instance which lowers the priority of the service instance such that a level of service to the service instance is lowered.

8. A system for service level performance updates based on network level factors, comprising: a processor; anda memory comprising instructions which, when executed on the processor, performs an operation, the operation comprising: receiving, at a virtual network edge (VNE) instance on a node, a service health request from a service proxy on the node, wherein the service health request indicates a delegation of application layer service health monitoring from the service proxy to the VNE instance, wherein the VNE instance performs the delegated application layer service health monitoring for the service proxy, wherein the VNE instance is collocated on the node with a service instance executing on the node and the service proxy executing on the node, wherein the service proxy controls application behaviors for the service instance based on an application layer health-score of the service instance;receiving, at the VNE instance, one or more network health indicators comprising network level indicators generated at a network controller for a network fabric and received from a delegated service health request network switch located between the node and the network controller in the network fabric;determining, at the VNE instance and from the one or more network health indicators, a network level health-score for the network fabric;determining, at the VNE instance and from the network level health-score, a modulated health-score for the service instance; andupdating the application layer health-score of the service instance at the service proxy to cause the service instance to alter its application behaviors within the service mesh based on the modulated health-score.

9. The system of claim 8, wherein the operation further comprises: in response to receiving the health service request, querying a next-level network element for the one or more network health indicators; andwherein the one or more network health indicators are received from the next-level network element in response to the query.

10. The system of claim 9, wherein updating the health-score of the service instance comprises: providing the modulated health-score to the service proxy, wherein the service proxy reports the modulated health-score to at least one of a network traffic controller and network traffic metrics collector on behalf of the service instance.

11. The system of claim 8, wherein the VNE instance serves as a proxy for one or more delegated services at the node.

12. The system of claim 8, wherein the one or more network health indicators comprise at least one of: a congestion indicator;a node level indicator; anda network wide service level factor.

13. The system of claim 12, wherein determining the network level health-score comprises at least one of: determining a utilization of network resources for the service instance based on at least the congestion indicator;determining a status for one or more network elements one based on at least the node level indicator; anddetermining a network wide service health based on at least the network wide service level factor.

14. The system of claim 8, wherein determining the modulated health-score for the service instance comprises: determining, based on the network level health-score, to lower a priority of the service instance at the node; anddetermining the modulated health-score based on the lower priority determination, wherein the modulated health-score comprises a health-score for the service instance which lowers the priority of the service instance such that a level of service to the service instance is lowered.

15. A non-transitory computer-readable medium, the non-transitory computer-readable medium having program instructions embodied therewith, the program instructions are executed by a processor to perform an operation comprising: receiving, at a virtual network edge (VNE) instance on a node, a service health request from a service proxy on the node, wherein the service health request indicates a delegation of application layer service health monitoring from the service proxy to the VNE instance, wherein the VNE instance performs the delegated application layer service health monitoring for the service proxy, wherein the VNE instance is collocated on the node with a service instance executing on the node and the service proxy executing on the node, wherein the service proxy controls application behaviors for the service instance based on an application layer health-score of the service instance;receiving, at the VNE instance, one or more network health indicators comprising network level indicators generated at a network controller for a network fabric and received from a delegated service health request network switch located between the node and the network controller in the network fabric;determining, at the VNE instance and from the one or more network health indicators, a network level health-score;determining, at the VNE and from the network level health-score a modulated health-score for a service instance; andupdating the application layer health-score of the service instance at a service proxy to cause the service instance to alter its application behaviors within the service mesh based on the modulated health-score.

16. The computer program product of claim 15, wherein the operation further comprises: in response to receiving the health service request, querying a next-level network element for the one or more network health indicators; andwherein the one or more network health indicators are received from the next-level network element in response to the query.

17. The computer program product of claim 16, wherein updating the health-score of the service instance comprises: providing the modulated health-score to the service proxy, wherein the service proxy reports the modulated health-score to at least one of a network traffic controller and network traffic metrics collector on behalf of the service instance.

18. The computer program product of claim 15, wherein the one or more network health indicators comprise at least one of: a congestion indicator;a node level indicator; anda network wide service level factor.

19. The computer program product of claim 18, wherein determining the network level health-score comprises at least one of: determining a utilization of network resources for the service instance based on at least the congestion indicator;determining a status for one or more network elements one based on at least the node level indicator; anddetermining a network wide service health based on at least the network wide service level factor.

20. The computer program product of claim 15, wherein determining the modulated health-score for the service instance comprises: determining, based on the network level health-score, to lower a priority of the service instance at the node; anddetermining the modulated health-score based on the lower priority determination, wherein the modulated health-score comprises a health-score for the service instance which lowers the priority of the service instance such that a level of service to the service instance is lowered.