Meshery is the open-source, multi-service mesh management plane that can provision ten different service meshes, onboard your applications, manage WebAssembly filters, apply service mesh patterns, validate against best practices, and benchmarks the performance of your service mesh deployments. Let’s learn how to manage service meshes with confidence with the multi-mesh manager, Meshery.
As we unfold what a management plane is, it would serve us well to talk about network planes in this regard. Architecturally, a service mesh consists of two planes. One of those is the data plane, while the other one is the control plane. A service mesh data plane is the collection of intelligent proxies that operate in unison under the coordination of the control plane. The control plane performs configuration management of these intelligent proxies.
A management plane can do many things. Essentially, a management plane helps you integrate service meshes into your backend systems. A robust management plane allows you to take full advantage of the power of the network while integrating your service delivery processes seamlessly. Your management plane might federate different types of service meshes, help you instigate chaos through controlled experiments, or offer automated traffic splitting in order to execute different styles of canarying of your applications. Your management plane might offer deep insights into the performance of your applications and to the performance of your infrastructure or might deliver a change in management framework.
Meshery manages the lifecycle of service meshes. Meshery does workload management, helps you onboard or offboard your applications onto the mesh. It also lets you do performance management. MeshSync, a custom controller within Meshery operator, performs discovery of existing service meshes and deep fingerprinting of the specific functions that version of your service mesh is capable of performing. Through MeshSync, Meshery supports brownfield deployments of your service meshes (Meshery discovers your existing service mesh deployment that is already running inside your cluster(s) whether those service meshes were deployed by Meshery or not)
In order to facilitate such a deep level of understanding of each type of service mesh, Meshery has adapters that are specific to each service mesh (given that each service mesh has its own set of features). Consequently, in order to leverage the maximum functionality of each service mesh, Meshery has separate, dedicated adapter for each of the supported service meshes:
Meshery also lets you integrate your Prometheus and Grafana add-ons so you can import your existing Grafana dashboards to Meshery. When you first start Meshery, we also have a configuration wizard, which basically walks you through the entire setup to get Meshery up and running. By the end of this, it will make sure that you have Meshery running on your cluster.
If you want a more finer configuration, you can configure your environment through settings and you can configure service meshes, and you can configure the metrics, you can define your performance tests to be reused.
For configuration management, Meshery will analyze your runtime environment for certain service meshes and tell you if you're doing things right or not. What you can do is you can upload your applications directly into Meshery, edit them in the Meshery UI itself and actually apply these applications or onboard these applications on your service mesh.
Meshery operator is a custom controller called MeshSync. MeshSync helps keep Meshery apprised of the various changes that are going on to the service meshes and various changes that are happening within Kubernetes itself. In this way Meshery supports not only greenfield deployments like deploying service meshes itself, it also supports connecting to existing service mesh deployments, that is, brownfield deployment. So it will discover your existing deployments as well.
There's an extensible concept in Meshery called a provider. Providers can typically offer a layer of persistence so to the extent that users are running performance tests intensely or to the extent that users want to have a particular type of directory integrated to bring their own identity to Meshery and have a multi-user experience. The other area of extensibility is the notion that Meshery has a couple of APIs both – rest API and graphql API. It comes with a command-line interface as well as a user interface.
Another capability of Meshery that is going to be released in the upcoming version is visually configuring your service mesh using MeshMap. You can add filters, applications as well as make other configurations visually here and you can export it as patterns to make it reusable quite easily. It automatically figures out the sample application we have deployed, then generates a visual representation. It provides users the ability to design service meshes, service mesh configuration, and the applications that run on it.
A pattern is capable of describing the deployment of any of the meshes that Meshery supports as well as the configuration of the mesh. It also notes ongoing behavior so if you wanted to run a canary you can describe that in a pattern. So, patterns are like a template, they're customizable and ingestible into Meshery itself.
Meshery will take action based on what you've described in the pattern, things like generating or running a performance test, generating load, and then doing statistical analysis on that set of results. In the future, if you want to deploy a web assembly filter, you can describe that in a pattern as well and have Meshery apply it. The patterns are service mesh agnostic, they're reusable and the initial set of them is being stored in a public-facing repository. There are almost 60 patterns that have been identified. Ultimately, it will allow you to ingest these and measure then orchestrate and apply them to your infrastructure. You can also use Meshery to visually represent them and to visually design.
There’s a project called Nighthawk that helps advance the existing integration of nighthawk and Meshery. Nighthawk is a load generator that is an envoy project. It's written in c plus plus and has a couple of intriguing capabilities that are the ongoing study within Nighthawk. There is an ongoing effort to take advantage of nighthawk’s adaptive load controllers, add a couple of those in and expose them through Meshery to let people recursively evaluate what is ultimately an optimal configuration in your environment and the service mesh.
If you consider that you've got a certain SLO or a certain minimum latency requirement that you need to stick to that but you also want to at the same time maximize resiliency characteristics of your deployment, that can be a difficult thing to figure out particularly if any of your infrastructure changes:
- if you add another node to your environment, your clusters,
- if you upgrade your service mesh,
- if you change the configuration of your service mesh,
- if you add another service to your set of workloads that you're running.
If these factors change, so does the ability to run optimization routines. To help you identify the optimal configuration of your mesh but in accordance with your own constraints is again the study of Nighthawk.