Introduction: Dubo-Go is constantly new and evolving every year. Before introducing the work of Dubo-Go 3.0, let’s review its development over the past six years to clarify its future direction.

The author | | ali Li Zhixin source technology public number

About the author:

Github @Laurencelizhixin li, principal of Dubbo-Go 3.0, Apache Dubbo PMC, from Ali Cloud middleware team, is engaged in the development and open source work of go language middleware. Yu (Github @AlexStocks), Dubbo-Go community leader, Apache Dubbo PMC, Ant Group Trusted Native Department [TNT] Infrastructure and middleware R&D front-line programmer. 11 years work participation and improved in succession Redis/Pika Pika – Port/etcd/Muduo/Dubbo/Dubbo – go/Sentinel – golang/Seata – golang well-known projects, etc. Github @justxuewei (justxuewei), Apache Dubbo Committer, sophomore postgraduate of school of computer science, bupt, has a strong interest in middleware and cloud native field. Jianhui Dong (Github @Mulavar) is an Apache Dubbo Committer, currently focusing on Dubbo, Flink and Calcite.

Go language, as the most popular cloud native language, has gained high popularity in recent years and once attracted the attention of domestic open source ecology. According to the author, many enterprises have also transformed from their own traditional technology stack to Go language technology stack in recent years. Go is favored by developers because of its advantages of agile development, high ease of use and easy entry. As Go language ecology becomes increasingly vigorous, its ecological completeness still has a big Gap compared with the tested Java ecology. For small and medium-sized enterprises, Go framework similar to Spring is still needed to support daily business development, and they are eager to have the ease of use and stability of Dubbo ecology. In response, The Original Bridging The Gap Between Java And Go, The Dubo-Go service framework, was born in 2016 And has been in development ever since.

We are in the second half of this year’s cloud computing infrastructure conference awareness of “infrastructure ability sink” significance, from single architecture to cloud native architecture development step by step, is trying to have the business code and the middleware decoupling, as far as possible to provide a unified programming interface, through the thinking of AOP will service call abstraction, standardization of the interface, The realization of infrastructure submergence. On the premise of ensuring the high availability and stability of network communication, Dubo-Go integrates a number of common open source components and provides a consistent programming interface for expansion and invocation. On top of this, it is the consistent vision of our entire ecological project to align the control surface of Dubbo ecological mainstream, try to combine with cloud native, and develop towards Proxyless Service Mesh.

In The 3.0 era, our ambition does not stop at existing user usage scenarios And infrastructure capabilities. Instead, we choose to pursue The advantages of high availability, multilingualism And cross-ecology to build a new generation of microservices infrastructure, enabling Bridging The Gap Between X And Go. While expanding Go ecology, cloud biogenesis of various infrastructures is also realized.

A brief introduction the Dubbo – go

Dubo-go is new and evolving every year. Before introducing the work of Dubo-Go 3.0, let’s review its development over the past six years to clarify its future direction.

1 What is Dubo-go

github.com/apache/dubbo-go is a high-performance Go microservice RPC framework that plays an important role in Dubbo’s multilingual ecosystem and is one of the best choices for writing Go microservices.

Developers can use the Dubo-Go framework to efficiently write RPC services, and support cross-language communication with Dubbo and gRPC services. You can use Dubbo ecosystem’s powerful service governance and operation and maintenance capabilities, such as service registration discovery, load balancing, configuration center, visualization, etc. You can also use the Pixiu Gateway of dubbo-Go Ecology to expose services to external cluster access.

Dubo-go project was founded in 2016 due to rain, and started to build open source community in 2018. In 2019, the project officially entered the Apache Software Foundation and experienced more than three years of continuous iteration and optimization. At the end of 2021, the Dubbogo community will officially launch v3.0, which integrates the new communication protocol, new serialization protocol, new application registration model, new routing and new service governance capabilities. This version has attracted the attention and use of many production users in the early development stage.

Dubo-go is one of the most active open source communities in Ali’s open source project. Over the years, the community has accumulated many active contributors and Apache Committers /PMC members who love open source. Not only has it demonstrated how Dubbo and other Dubbo eco-projects have been helped to grow through the organization and operation of the community, but it has also helped to increase the activity of the entire Dubbo community:

• Dubbo Ecology, including Apache/Dubbo and Apache/ Dubo-Go, was rated as one of the 20 most active communities in China in 2021, ranking second among all alibaba open source projects (the first is AntD of Ant Group).
• Dubo-go has successfully applied for the “2021” Science and Technology China Open Source Innovation Ranking “sponsored by China Association for Science and Technology.
• Dubo-go Open Source community was awarded “OSCHINA Outstanding Open Source Technology Team of 2021” by OSCHINA

2 Function Description

Dubo-go has now fulfilled its initial mission of Bridging The Gap Between Java And Go, with strong connectivity capabilities, And is making significant progress towards cloud native.

• Connectivity capability

Dubo-go ecology covers multiple network protocols: Triple, Dubbo, JSONRPC, gRPC, HTTP, HTTP2, etc.

Triple protocol, which is promoted by Dubbo3 ecology, is an extended protocol based on gRPC. The underlying protocol is HTTP2, which can communicate with gRPC service. On the basis of gRPC’s reliable transmission, it adds Dubbo’s service governance capability.

Dubbo-go ecosystem has been interconnected with Dubbo, gRPC, Spring Cloud and other ecosystems to unify east-west and north-south data flows: Dubbo-go can be used for east-west service invocation, and Dubbo-Go-Pixiu can also be used for north-south traffic governance.

• The conversation ability

In terms of service registration discovery, it supports Nacos, Zookeeper, ETCD, Consul, Polaris-Mesh (Tencent open source) and other service registration middleware, and has extensible capabilities. We will also extend the implementation of user needs based on user usage.

On the configuration center side, developers can publish and pull framework/user configurations using Nacos, Apollo (Ctrip open source), and Zookeeper.

In terms of flow control, we have built-in implementation of fixed window, sliding window and other well-known flow limiting algorithms, and also support integration with third-party mature flow limiting fuse frameworks such as Hystrix and Sentinel-Golang to provide governance functions.

In terms of distributed transactions, we support Seata-Golang and implement the invocation of TCC mode distributed transactions.

In terms of link tracing, we support link tracing capabilities based on Jaeger and ZipKin.

In terms of metrics visualization, we support the use of Prometheus to collect framework metrics and user metrics.

3 Target Users

Dubo-go has been built and developed from the very beginning for production environments based on the actual needs of its users, who are as follows.

• Go language micro-service developers

If you are a Go microservices developer looking to quickly develop your own services based on a lightweight microservices framework, dubbo-Go 3.0 is a good choice for you.

• Dubbo ecology multilingual speakers

If you are a Dubbo eco-user or have compatibility issues when switching languages, Dubbo- Go will help you in multi-protocol cross-language communication scenarios.

• GRPC users

If you want to add service governance capabilities to the gRPC ecosystem, Dubbo-Go helps you easily access the Dubbo ecosystem from gRPC, providing support for service governance capabilities without changing business code.

• Cloud native architect

If you are looking for a cloud-native solution for your company, Dubbogo 3.0’s ProxyLess Service Mesh is also a good choice to help you access the ISTIO control surface from your microservices at the lowest cost. Of course, the control surface capability of Dubbogo needs to be further enhanced. In the future 3.1 version, two sets of Service Mesh solutions, ProxyLess and Proxy, will be provided.

What’s different about dubo-Go 3.0

Dubbo 3.0 has been an open source project of the Apache Software Foundation for ten years. As the third milestone and a new version of the cloud native era, Dubbo 3.0 can be traced back to 2018 as an important part of Dubbo’s multilingual ecosystem. The Dubo-Go community will also launch version 3.0 by the end of 2020.

On the basis of the official new feature support (Triple protocol, application-level service discovery, routing rules, flexible service, etc.), dubbo-Go community has been optimized for user friendliness, multi-language and multi-ecological compatibility, user programming and usage habits, etc. 3.0 for the Go community is not so much a version-aligned iteration as a vibrant new beginning.

1 New configuration scheme

• configuration

In 3.0, we have more clearly defined the concepts of application-level configuration and interface-level configuration. Compared with previous versions, the configuration structure has been restructured and streamlined. For example, in the microservices scenario, developers will pay attention to the registry address, protocol, interface name and other information. Just specify it in the configuration file:

Dubbo: registries: ZKRegistry: protocol: zookeeper: address: 127.0.0.1:2181: protocols: Provider: services: GreeterProvider: # service provider class name interface: Com. Dubbogo. Sample. DemoServiceName ID # interfaceCopy the code

• Configuration center

In Dubo-Go 3.0, you can place the above framework configuration or user configuration in a configuration center for easy management. You only need to place the configuration center information in the container to start the framework based on that configuration.

Dubbo: config-center: # Config center information protocol: nacos address: 127.0.0.1:8848 data-id: dubbo-go-samples-configcenter-nacos-serverCopy the code

• The configuration API

Developers can generate configuration instance structures in code through the configuration API, and the configuration generated in code is equivalent to the configuration read from a file. The design reference to Java Builder comes from the community and represents the developers’ desire for ease of use of the interface.

/ / 1. Through the center of the Builder pattern to create the configuration configuration configCenterConfig: = config. NewConfigCenterConfigBuilder (). Nacos SetProtocol (" "). SetAddress (127.0.0.1: "8848"). SetDataID (" dubbo - go - samples - configcenter nacos - server "). SetGroup("dubbogo"). Build() // 2. Through the Builder pattern to create the root configuration rootConfig: = config. NewRootConfigBuilder () SetConfigCenter (configCenterConfig). The Build () / / 3. Load the configuration and start the framework rootconfig.load ()Copy the code

2 Triple + PB protocol

Dubo-go already supports Triple protocol in version 3.0.0-rC1, which was first released in the first half of the year. During this period, many optimization suggestions for response delay and stability were put forward by the relevant students of the department. Up to now, a lot of optimization work has been done in performance, user experience, generalized call, exception callback, PB reflection and so on.

• Performance optimization

The old version of net/ HTTP2 based implementation is switched to GRPC based http2 layer implementation scheme. Enhance the stability and performance of the underlying transmission. After pressure testing, the 4C8G stand-alone Provider can handle simple requests of 70,000 TPS.

We used 3 machines of the same specification, one as a Server(running a triple-Server) and one as a Client (running a triple-server and triple Client), One presses the Client for the entire link and records the RT, real TPS, and CPU usage of the Client and server.

It can be seen from the pressure test results that we can guarantee millisecond request delay and maintain reasonable CPU resource utilization under the experimental environment of multi-hop link and single-machine TPS with tens of thousands of levels.

• Reflection support

Proto reflection is enabled on Triple by default. Users can use GRpc_CLI to display and debug pb serialization services exposed by Triple protocol.

On the premise that Proto reflection is supported, Dubbo-GO-Pixiu provides the support of gateway layer protocol transformation to invoke Triple service.

$ grpc_cli ls localhost:20000
org.apache.dubbogo.samples.api.Greeter
grpc.reflection.v1alpha.ServerReflection
Copy the code

• User programming

New PB-compiled plug-in, new version dubbo-Go recommends that go users define interfaces using proto files, similar to grPC-Go.

$go install github.com/dubbogo/tools/cmd/[email protected] $protoc -- go_out =. - go - triple_out =. ./helloworld.protoCopy the code

Triple protocol was first proposed by ali Cloud middleware team when the concept of Dubbo3 was formed. Compared with the previous generation of Dubbo protocol, it solves the problem that Dubbo ecology is not interoperable with other cloud native architecture ecology, and it is difficult for users to understand the previous generation of binary protocol located in the transport layer. GRPC extension protocol based on HTTP2 is a good solution to this problem. Second, it is not friendly to gateway components such as Mesh. In the 3.0 era, we can directly obtain necessary metadata by parsing the protocol header, and naturally adapt to the forwarding implementation of HTTP protocol by gateway.

Considering the Go language developers connected with our community, PB serialization is more suitable for their development habits, which is convenient to migrate business code from the existing gRPC service, and also solves the compatibility problem of cross-protocol communication in the upgrade process. After using Triple protocol, the advantage of cross-language communication will be further reflected. From “interworking” to “stable interworking” based on mature serialization scheme, it is convenient for users to expand their business more widely. To put it simply, in the Dubbo era, users need to rely on the Dubbo protocol of multi-language ecology to achieve cross-language interworking, but in the 3.0 era, You can use gRPC implementations in any language to communicate directly with Dubbo services and share a range of components of the gRPC ecosystem, such as link tracing, visualization, CLI tools, and so on.

Therefore, we believe that the significance of Triple is not a simple extension protocol, but a cross-language and cross-ecological concept realization, which is also the core Feature of Dubbo3.

3 Flexible Service

The user traffic of a large-scale distributed system increases exponentially. Therefore, load balancing algorithms are required to evenly distribute the traffic to each machine to improve the throughput and resource utilization of the cluster.

Traditional load balancing algorithms, such as RR and HASH algorithms, are based on the perspective of consumers, but their common limitation is that they cannot dynamically adjust traffic balancing policies based on the current status of service providers. These algorithms always distribute traffic with as fair a probability as possible, but in practice fairness does not equal load balancing.

The expected balanced triage strategy is:

• Dynamic performance evaluation: the user does not need to set the weight of the machine in advance, the framework automatically evaluates the system performance during operation, the machine with good performance bears more traffic, the machine with poor performance bears less traffic;
• Self-healing capability: The load balancing algorithm can automatically remove the faulty nodes and has self-healing capability.
• Proper traffic limiting policies: Avoid service avalanche.

As a new generation load balancing strategy, flexible service is introduced in Dubbo-Go 3.0. Its core capabilities include capacity assessment and intelligent streaming.

Capacity estimation evaluates the current state of the service provider to maintain the optimal request queue length. The two core metrics that capacity estimates focus on are TPS, which measures how fast a system processes things per second, and latency, which reflects how long users wait. When evaluating server capacity, the relationship between system throughput and user wait time should be balanced. Ideally, the system throughput should be as high as possible and user latency should be as low as possible.

The real capacity is limited by hardware and downstream dependencies, so it is difficult to predict the real capacity at one time. As shown in the figure above, TPS increases monotonically with the number of requests until it reaches the optimal value. In version 3.0.0 of Dubo-Go, we introduced HillClimbing algorithm to approach the optimal carrying capacity of the system gradually during the call.

HillClimbing algorithm works on service providers to periodically determine whether the current state is optimal and dynamically update system capacity.

The detection interval lengthens gradually with time until it tends to be stable. When the system starts up, no historical data is available. In this case, capacity evaluation values need to be updated frequently to ensure that the system detects the optimal capacity as soon as possible. We assume that the optimal capacity will not fluctuate strongly in a short time, and capacity evaluation will consume additional resources, so the algorithm will gradually extend the detection cycle when it tends to be stable.

The capacity update policy is similar to TCP congestion control. Two types of increment preset by HillClimbing algorithm are shown below:

Where, lim represents the current capacity and ITV represents the current detection interval.

In the initial stage, a slow start strategy is adopted, where a low level value is taken as the initial capacity value, but a high increment (alpha) is used to approach the optimal capacity. If the current capacity has grown to the point where TPS is reduced, lower increments (beta) are used to move toward the optimal capacity in a more precise manner.

At the end of each invocation, the service provider returns the latest estimated capacity to the service consumer through dubbo-Go’s Attachment feature, and the consumer caches the information locally and implements intelligent streaming using THE P2C algorithm.

P2C (Pick Two Random Choices) algorithm acts on service consumers. It has a more scientific load balancing strategy and is widely used in many well-known open source projects, such as Linkerd and Rsocket. The algorithm firstly randomly selects two nodes, then compares the remaining capacity of nodes, and selects one node with more remaining capacity as the service provider of this call.

Flexible services will continue to be refined in future releases, working with the Dubbo community to explore a set of flexible services best practices for microservices scenarios.

4 Pixiu gateway

Dubbo-go-pixiu gateway supports the call to go /Java Dubbo cluster. In the scenario of Dubbo-Go 3.0, we can request Pixiu Gateway with HTTP protocol outside the cluster through Pixiu Gateway, perform protocol conversion at the gateway layer, and further call dubbo-Go service within the cluster.

The path for invoking the Dubo-Go service is http:// (app_name)/(app\_name)/(app_name)/(service_name)/$(method).

For example, a proto file has the following definition:

package org.apache.dubbo.quickstart.samples;

service UserProvider {
  rpc SayHello (HelloRequest) returns (User) {}
}

message HelloRequest {
  string name = 1;
}
Copy the code

And configure the application named my-Dubbogo-app in dubbogo.yml when the Dubbogo service starts:

dubbo:
  application:
    name: my-dubbogo-app
Copy the code

Pixiu gateway can parse path for my – dubbogo – app/org. Apache. Dubbo. Quickstart. Samples. UserProvider/SayHello routing, and forwarded to the corresponding service. The body from the external HTTP request is a JSON serialized request parameter, such as {“name”:”test”}.

We currently recommend using Nacos as the registry.

You can deploy Demo in your own cluster. The cluster should be able to expose LB type service, so that you can access services in the cluster on the public network. You can also directly request services in the cluster.

For your cluster, perform:

$ kubectl apply -f https://raw.githubusercontent.com/dubbogo/triple-pixiu-demo/master/deploy/pixiu-triple-demo.yml
Copy the code

The following resources will be created in the dubbogo-triple-nacos namespace, including three triple-Servers, one Pixiu gateway and one Nacos Server. The service is exposed to the public network through Servcie.

namespace/dubbogo-triple-nacos created
service/dubbo-go-nacos created
deployment.apps/dubbogo-nacos-deployment created
deployment.apps/pixiu created
deployment.apps/server created
service/pixiu created
Copy the code

Obtain pixiu public IP address and invoke it

$ kubectl get svc -n dubbogo-triple-nacos NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dubbo-go-nacos ClusterIP 192.168.123.204 < None > 8848/TCP 32s Pixiu LoadBalancer 192.168.156.175 30.xxx.xxx. XX 8881:30173/TCP 32sCopy the code

Use curl to invoke the Demo service and obtain the response result.

$ curl -X POST -d '{"name":"laurence"}' http://30.XXX.XXX.XX:8881/dubbogoDemoServer/org.apache.dubbo.laurence.samples.UserProvider/SayHello
{"name":"Hello laurence","id":"12345","age":21}
Copy the code

5 O&M Capabilities and Tools

• observability

Compared with the previous version of Dubbo- Go, this release provides support based on Triple protocol observability on the basis of the original Dubbo protocol observability, suitable for Jaeger link tracing display. For data reporting, we provide an interface in the framework to facilitate users to report business buried data in real time, and enable the support of promehteus pull mode data collection by default.

The framework also provides a default metrics field for RPC call information, such as request RT, interface name, method name, etc., for user collection and statistics.

• The log

In this release, the log module is greatly changed and updated. Users can configure the log printing level, fragment, file output, and retention time as required. Users can also customize log components.

• Cli tool

Dubbo-go 3.0 will focus on command-line tools. Dubbo-go-cli is available for making Dubbo RPC calls. Protoc-gen-go-triple plugin for compiling PB files; In the future, we will further enhance the capability of command line tools in health check, service information acquisition, RPC call debugging, framework code initialization and interface compilation, service deployment and other aspects, so as to provide a more complete service governance and operation and maintenance ecosystem.

Dubo-go from three user perspectives

As a framework designed from the perspective of users, we hope to provide users with a more concise, intuitive and “convention over configuration” experience. Therefore, in the research and development stage, we focused on several rounds of configuration iterations and the construction and maintenance of samples warehouse. Users are provided with a more streamlined concept and focused samples.

Interface and configuration oriented development

Dubbo-go 3.0 shields developers from the underlying implementation details and allows them to use the framework for development by focusing on a few key points. Take Triple Services as an example.

• Framework configuration file: dubbogo.yaml

Configuration items on which the framework starts.

• The interface definition

Write proto file and compile using the supplied protoc-gen-go-Triple plug-in and the official protoc-gen-go plug-in.

• Interface code implementation

Write the service implementation and start it using the framework.

Interface, implementation, configuration. Are the basic dependencies of common Go microservices. Dubo-go provides a complete set of microservices solutions, and provides rich service governance capabilities and scalability capabilities, so that users can easily access and use.

2 Code sample repository dubo-go-samples

We maintained a rich dubo-Go 3.0 code sample in the Master branch of the Apache/Dubo-Go-Samples repository. Including RPC call of multiple protocols, support of multiple registries, use of multiple configuration centers, and display of operation and maintenance capabilities such as generalized call, configuration API, log, data reporting, link tracking, almost all capabilities possessed by the framework can be found in the samples warehouse corresponding common use cases. Users can also find examples of dubo-Go 1.5.x in the 1.5 branch.

Through configuration reconstruction and significant user friendly optimization in the early stage of 3.0, the code and configuration in the samples warehouse have been highly streamlined to highlight the capabilities of a single module. Developers can download the repository and play with the services of a sample module directly in server to client order to experience the capabilities provided by the framework.

The samples warehouse was endowed with more functions in the iteration process, which will be familiar to all students of community development. We combined the framework warehouse and samples warehouse through CI integration tests to ensure that the code submitted by the framework developers could pass the E2E tests of all use cases, so as to guarantee the development quality. Improve iteration efficiency.

Iv. Community Collaboration

As a service platform with rich capabilities and functions, Dubbogo community attaches great importance to the cooperation with various open source communities, especially ali open source product community and various companies.

• Nacos community

Early on, the Dubbo-Go community worked closely with the Nacos community, with several core contributors participating in the DUbbo-Go development support. In version 3.0.0, several Nacos community members were added and many constructive suggestions and contributions were made during the community iteration.

• Polaris community

Polaris is Tencent’s open source service discovery and governance center, dedicated to solving service visibility, fault tolerance, traffic control and security issues in distributed or microservice architectures. In the development of version 3.0.0, the Dubo-Go community worked with the Polaris community to implement Polaris as the dubo-Go registry.

• Sentinel – Golang community

Sentinel is a flow control component for distributed services architecture. The Dubbo-Go community has been working closely with the Sentinel-Golang community since the official release of the first Sentinel-Golang version 0.1.0. Sentinel-golang is functionally supported as flow control.

• Seata – golang community

Since Dubbogo V1.3, seata-Golang has been integrated to implement the invocation of TCC mode distributed transactions.

The two communities have cooperated to integrate TCC mode Seata-Golang into Dubbo-Go-Pixiu. Only simple configuration is required to integrate TCC mode to coordinate distributed transactions. The overall process principle is shown in the figure above. In order to further reduce the threshold for people to use distributed transactions, Seata-Golang community is also considering to implement AT mode into DB agent layer, and then it will be more convenient to use Seata-Golang in Dubbo-Go-Pixiu. Please look forward to it.

• Other companies

Dubbogo itself is a project with very high production environment requirements. During its development, it has cooperated with Many companies such as Ali. These cooperation benefits both parties, ensuring the quality of DuBbogo, expanding its functionality, and greatly improving the stability of the partner’s own platform.

Five outlook

As mentioned above, Dubbo-Go 3.0 is the starting point of a new era for us. In the future iterations, we will continue to maintain the above traffic scheduling and service governance capabilities, and focus on the following aspects.

1 Traffic routing rules

Dubbo-go 3.0 has the same routing rules design as Dubbo. It provides routing rules policies in mesh mode and connects to the Control panel dubbo-admin.

In terms of mesh routing, Dubbo-Go divides routing rules into VirtualService and DestinationRule. DestinationRule defines the rule of the destination address. A subset and host are associated with a cluster, and VirtualService defines specific route matching rules. When a client initiates a call, it routes to a specific subset through VirtualService, and then finds the specific cluster based on the labels information of the corresponding subset in the DestinationRule. This design decouples routing rules from destination addresses and supports multiple combinations of VirtualService and DestinationRule, enabling more flexible routing policies and easier implementation of A/B testing, canary publishing, blue-green publishing and other capabilities.

As for the work of connecting dubbo-admin, dubbo-Go has reconstructed the code logic of zooKeeper configuration center and realized the interworking with Dubbo-admin. That is, users can dynamically publish and update routes on Dubbo-admin to schedule traffic in the cluster (only ZooKeeper at present), and the application can sense the traffic immediately without restart. In the near future, we will continue to deepen the communication of this part, support the communication of nacOS and other common configuration centers and registries, and completely realize the separation of control panel and data panel.

2. Unified control surface and service architecture innovation

We will launch a unified control surface compatible with Dubbo-Admin, which can dynamically schedule the traffic in the cluster through routing configuration on the control surface, and implement the new routing rules into production scenarios in a more flexible and easy to use way. Operation and maintenance personnel can also know the real-time application situation of Dubbo-Go in the cluster at a sight on the control surface. Further speaking, the control surface will have a series of operation and maintenance capabilities such as service testing, gray publishing, monitoring, and flow scheduling.

On the basis of adapting to pixiu Gateway protocol transformation, we will further explore gateway capabilities and explore new microservice architecture in the direction of Proxyless Service-Mesh.

3 Further cloud biogenesis

We will further support cloud native capabilities based on the exploration of K8S in Dubo-Go version 1.5. We plan to include probe, configuration, resource monitoring and other aspects, so that the framework can provide better user experience and more diversified service governance capabilities under the cloud native architecture.

The original link

This article is the original content of Aliyun and shall not be reproduced without permission.