Static compilation and optimization of Java applications before running based on GraalVM can significantly solve the long-criticized problems of long-term cold start and large memory usage of Java applications, and achieve cost reduction and efficiency increase! This article will introduce how to use Spring Cloud Alibaba 2022.0.0.0-RC1 version, and how to use GraalVM to statically compile and optimize Spring Cloud Alibaba applications.

new version preview

The Spring Cloud Alibaba 2022.0.0.0-RC1 version released this time is the first Release Candidate (RC) version based on the 2022.x trunk branch of the community. Considering that this version upgrade is a major version change, it will be released in the form of RC version for the time being. You can try it out first, and the community will release the official version as soon as possible when the time is ripe. The preview content of the new version is as follows:

2022.0.0.0-RC1 version

Based on Spring Cloud 2022.0.0 and Spring Boot 3.0, it adapts many original components in the ecology including registration configuration center, distributed message, etc., which belongs to a version with major changes. The Spring Cloud Alibaba 2022.0.0.0-RC1 version released this time has adapted the following component versions:

• Seata: The client adaptation version is version 1.6.1[1]. Compared with the previous version 1.5.x, this version already supports MySQL updatejoin, PostgreSQL & Oracle multi-primary key support, InsertOnDuplicateUpdate has made a lot of optimizations, supports multiple registries, etc., and a lot of core functions have been optimized. This version of the client has completed the support of JDK 17 .
• RocketMQ: The client adaptation version is version 4.9.4[2], which provides many features such as lightweight message queue and asynchronous sending function for delayed messages.
• Sentinel: The client adaptation version is version 1.8.6[3]. This version adjusts the attributes in the Sentinel rule class and replaces the relevant basic classes under the javax. package with those under the jakarta. package path to be compatible with JDK 17.
• Nacos: The adapted version of the client is 2.2.1-RC. This version is the latest version of the client launched by the Nacos community based on the latest version 2.2.0 to adapt to the latest GraalVM and build a native image. This version can be used directly with the Nacos 2.x series Nacos Server. Not only can you experience the latest plug-in capabilities such as data sources and connection current limiting brought by 2.2.0, but you can also directly build a GraalVM native image. The startup speed and runtime memory are greatly reduced .

In addition to component upgrades, some problems in previous versions have also been fixed, further improving the stability and robustness of Spring Cloud Alibaba. For more information, please refer to the release announcement [4] related to this version.

version interpretation

Why JDK 17?

Many people will be very surprised to hear that the minimum version of JDK required by Spring Boot 3.0 is 17 by default! Spring's official choice must be unwise for many JDK 8 users. is it really like this? For this problem, we think it is mainly based on two reasons: Oracle's official support policy for JDK and its advanced nature. Oracle currently divides all released JDK versions into Long-Term-Support (LTS) releases and relative non-TLS releases. The TLS version of JDK is officially supported by Oracle for a long time. It will continue to maintain and update this version for a long time in the future. The non-TLS version of JDK is only a transitional version. As long as the next LTS version appears, the official will not maintain it, so it is not suitable for long-term production and use by external users. Therefore, when Spring Boot 3.0 was released in the first Milestone version at the beginning of this year, the optional JDK versions were only JDK 7, 8, 11 and 17 from the above figure. Why 17 and not its predecessors? This should be understood in conjunction with Oracle's official JDK support policy. Oracle officially divides the released JDK follow-up support strategies into the following three types:

• Premier Support: It can be understood as the standard support type provided by Oracle. The support period under its latest policy is 5 years. Within 5 years, Oracle will officially provide continuous free update and upgrade services for this version of JDK.
• Extended Support: As an extended support type after standard support, the support time period under its latest policy is 3 years. Within 3 years, Oracle users can purchase the update support service provided by Oracle for this version of JDK by paying a certain support service fee.
• Sustaining Support: It is an official support service provided by Oracle after continuing the support type. Of course, it is also charged, and there is no clear deadline for it yet.

According to the official support service provided by Oracle for the current JDK and the advanced nature of the JDK version itself, the Premier Support support service for JDK 7 and 8 has ended, and the Premier Support related to 11 is about to expire. As the latest LTS version, JDK 17 has been optimized in terms of syntax and performance compared to the previous version, and it has a relatively large advantage. Therefore, it is logical to choose JDK 17 as the default JDK version of the latest Spring Boot 3.0!

What does Spring Cloud 2022.0.0 bring?

Spring Cloud ushered in the first official version 2022.0.0 of the 2022.x series in the last month of 2022. At this time, some users may have a feeling that the end is almost over and the beginning is just beginning! In fact, Spring launched 2022.0.0-M1 in the first month of 2022 as the first Milestone version. In the next year, it released 5 Milestone and 3 Release Candicate (RC) versions one after another before officially launching the official General Available (GA) version. It can be seen that Spring's official work is still very reliable and patient, which is worthy of respect! As the most widely used microservice framework in the industry, Spring Cloud defines a relatively complete set of microservice solution standards including: distributed registration configuration center, distributed message, current limiting and degradation, remote procedure call, load balancing, etc. In 2022.0.0, the following adjustments are mainly made:

• In the Spring Cloud Common module, since AsyncRestTemplate has been deleted in Spring Framework 6, the corresponding LoadBalancer automatic configuration has been deleted. Users who have related content in the old code and are considering upgrading should pay attention.

• The ResponseData of LoadBalancer in the Spring Cloud Common module has now been adjusted to use org.springframework.http.HttpStatusCode in Spring, which is consistent with other Spring modules.

• In the Spring Cloud Common module, the @SpringCloudApplication annotation was officially removed from the source code for the first time, and the @EnableDiscoveryClient and @EnableCircuitBreaker annotations no longer need to add content by default.

• The Spring Cloud Stream module officially removed support for @StreamListener

• Adjust the JDK baseline to version 17, compatible with JDK19;

• Migrate Java EE dependencies to Jakarta EE;

• Support applications to use GraalVM technology to generate native images, replacing the previous experimental Spring Native project, allowing Spring Boot applications to directly move towards GraalVM;

• Improved application observability with Micrometer and Micrometer Tracing.

Among them, the first 2 points are also explained in the previous article, so I won’t repeat them here. Next, we will introduce GraalVM and observable aspects.

Towards GraalVM

The biggest change brought by Spring Boot 3.0 this time is the support of GraalVM's native image, which is also the part that they spend a lot of time and energy emphasized in the official document. As an alternative to JRE, GraalVM technology pre-compiles Java applications through technologies such as Ahead Of Time (AOT), allowing Spring to learn more about the application when it runs the application, making the entire application start faster. In addition, the final application can be smaller and occupy less memory by eliminating some unnecessary content during the compilation process through the compilation tool. It is very friendly to some scenarios that require very high startup speed, such as Serverless and FaaS scenarios! When it comes to GraalVM technology, it first came from the Spring Native project initiated by the Spring team in 2019. As an experimental project, it has been integrated with projects before Spring Boot 3.0 and Spring Framework 6.0 in the past few years. According to Josh Long in a recent related interview, the experimental project has verified Spring Boot 2.x and Spring Framework 5.x. function. This time, Spring Boot 3.0 directly migrated it from Spring Native to Spring Boot, which also indicates that the technology has gradually matured, and the Spring ecosystem has entered the GraalVM stage! Compared with the JVM compilation and deployment method, GraalVM has the following characteristics:

• Static analysis of the application starts from the main entry point during the application construction phase.
• When creating a native image, through code analysis, the inaccessible code will be deleted and will not become part of the executable file, so that the package size can be compressed to a certain extent.
• GraalVM cannot directly perceive the dynamic elements of the code. Therefore, for applications with reflection, serialization, and dynamic proxy, relevant hint configuration files need to be provided in advance to help parse the application. For related operations, please refer to official documents.
• The application classpath is fixed at build time and cannot be changed.
• No lazy class loading, everything in the executable will be loaded into memory at startup.
• The supported Java applications have some limitations in some aspects, so there is currently no guarantee that all previous Java applications can be directly built using GraalVM technology, and there may be incompatibility exceptions with a certain probability.

Some of the middleware clients included in the Spring Cloud Alibaba 2022.0.0.0-RC1 version released this time have completed the adaptation to build GraalVM native applications. The following is the community’s currently supported service registration and discovery, and distributed transaction module related sample applications. After upgrading to Spring Boot 3.0, use GraalVM to build native application images to do tests related to startup speed and runtime content (Sentinel and RocketMQ are still being adapted, the following test process is in MacOS 11.4, 2.6 GHz 6-Core Intel Core i7 processor, 16G memory environment, simulated 5 times and take the average value):  From the above comparison, it can be found that the latest GraalVM-based Spring Cloud Alibaba application that supports Spring Boot 3.0 will be greatly reduced in terms of startup speed, runtime memory usage, and application package size. This brings significant advantages to applications hosted on the cloud in the cloud-native era, allowing them to perform elastic expansion and contraction faster and reduce the overall cost of using the cloud for enterprises!

Observability

Microservice applications bring about the decoupling of the system, splitting an application into several modules for deployment, so that while improving the scalability of the system, the processing of a request may go through multiple separately deployed modules, thus significantly improving troubleshooting. Observable technology defines the collection and processing of data in three dimensions: logging, metrics, and traces, so that system operation and maintenance personnel can easily grasp the operating status of the system and troubleshoot and solve problems in a timely manner. Another major feature in Spring Boot 3.0 is its enhancement in the observable field. In Spring Boot 3.0, the new API introduced in Observable Facts Standard Micrometer 1.10 is supported. For example, Spring Boot 3.0 can automatically assemble an ObservationRegistry instance object to provide users with an API interface suitable for both metrics and traces. In addition, 3.0 also provides users with automatic configuration Micrometer Tracing Features, including support for relevant third-party observability tools such as: Brave, OpenTelemetry, Zipkin, and Wavefront. It makes it very convenient for Spring Boot applications to integrate various mainstream observable tools. For more information about observability, please refer to the relevant Document Description. In addition to the main features introduced above, Spring Boot 3.0 also solves many bugs that existed before. For more details, please refer to Spring Boot 3.0 Release Notes.

Upgrade steps

Upgrade operation

If you need to use Spring Cloud Alibaba 2022.0.0.0-RC1 version for a Spring Boot 3.0 project, please add the following Management dependencies to the project:

<dependencyManagement>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>2022.0.0</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2022.0.0.0-RC1</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
</dependencyManagement>

Note that in addition to adjusting the above JDK version, you also need to upgrade the JDK version to 17.

Compatible with Spring Boot 3.0 & Spring Cloud 2022.0.0

The Spring Cloud Alibaba project is a one-stop solution in the field of middleware and microservices in Alibaba. During the adaptation process of the 2022.0.0.0-RC1 version released this time, due to the major changes in Spring Boot & JDK, a large number of other compatibility tasks other than function upgrades have been caused to the project adaptation. If you are directly building a new project, you can refer to the latest Spring Boot 3.0 project construction process to operate. The following steps can be omitted. If you want to upgrade to JDK17 & Spring Boot 3.0 for old applications, you may need to do the following compatibility processing: Java EE dependency migration to Jakarta EE Due to the dispute between Oracle and the Eclipse Foundation on the Java EE trademark, starting from Jakarta EE 9, the basic classes under the javax. package have been migrated to jakarta.. Therefore, for this upgrade, if the import package starting with javax.* is used in the program, it needs to be modified. Here is a list of tools that can help you with this part of the migration:

• OpenRewrite recipes.
• The Spring Boot Migrator project.
• Migration support in IntelliJ IDEA.

spring.factories file no longer supports auto-configuration for Auto-configuration Starting with Spring Boot 3.0, the META-INF/spring.factories file no longer supports autowiring for Auto-configuration. Users can use the AutoConfiguration.imports file instead of the META-INF/spring.factories file to migrate the autowiring classes originally written in it. If you do not make corresponding modifications and upgrade directly, you will find that the objects that were automatically injected during the previous program running phase will not exist and cause errors when running. This is also the method used by Spring Cloud Alibaba this time. For example, during the upgrade process of Spring Cloud Alibaba this time, the service registration and discovery module is automatically assembled by creating the following META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports:

com.alibaba.cloud.nacos.discovery.NacosDiscoveryAutoConfiguration
com.alibaba.cloud.nacos.endpoint.NacosDiscoveryEndpointAutoConfiguration
com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration
com.alibaba.cloud.nacos.discovery.NacosDiscoveryClientConfiguration
com.alibaba.cloud.nacos.discovery.reactive.NacosReactiveDiscoveryClientConfiguration
com.alibaba.cloud.nacos.discovery.configclient.NacosConfigServerAutoConfiguration
com.alibaba.cloud.nacos.loadbalancer.LoadBalancerNacosAutoConfiguration
com.alibaba.cloud.nacos.NacosServiceAutoConfiguration
com.alibaba.cloud.nacos.utils.UtilIPv6AutoConfiguration

Do not allow URI trailing slash matching Before Spring 6, the request path using "/hello" and "/hello/" can enter the hello() method as follows, but after the upgrade, it should be noted that only the former request can be normally assigned to the method, and the latter will throw a 404 no matching path exception.

@GetMapping("/hello")
String hello() {
    return "Hello World";
}

The usage of Spring Cloud Stream annotations has been removed Spring Cloud Stream is a highly scalable distributed message solution standard implemented within the Spring Cloud system. Based on Spring Cloud Alibaba, RocketMQ has been integrated into the Spring Cloud ecosystem, allowing users to migrate message middleware from RabbitMQ, Kafka, etc. to RocketMQ without modifying a line of business code and only adjusting dependencies and configurations. In Spring Cloud Stream 4.0 corresponding to the latest version of Spring Cloud 2022.0.0, the ability to process messages on the client side in the previous annotation method is removed, and currently only supports functional methods. Therefore, like the previous @StreamListener and @Input Notes can no longer be used directly after the upgrade. At present, the sample code of RocketMQ related modules in Spring Cloud Alibaba has been adjusted to the functional method. The functional method makes the code writing process more concise. The following is the consumption code of the broadcast message using the functional method. For more examples, please refer to the relevant Example Module：

@SpringBootApplication
public class RocketMQBroadcastConsumer2Application {
    private static final Logger log = LoggerFactory
            .getLogger(RocketMQBroadcastConsumer2Application.class);

    public static void main(String[] args) {
        SpringApplication.run(RocketMQBroadcastConsumer2Application.class, args);
    }

    @Bean
    public Consumer<Message<SimpleMsg>> consumer() {
        return msg -> {
            log.info(Thread.currentThread().getName() + " Consumer2 Receive New Messages: " + msg.getPayload().getMsg());
        };
    }
}

Spring Cloud Common module officially removes @SpringCloudApplication annotation The @SpringCloudApplication annotation was officially removed in Spring Cloud Common 4.0.0 corresponding to Spring Cloud 2022.0.0. The introduction of this annotation is to include @SpringBootApplication, @EnableDiscoveryClient, @EnableCircuitBreaker, which are necessary annotations for the three Spring Cloud applications to provide application dependency management, service registration and circuit breaker inclusion respectively. Later, service registration and circuit breaker capabilities can be provided by default by introducing related dependencies, so these two annotations are no longer necessary. By configuring spring.cloud.discovery.enabled=false, the default registration behavior can be directly turned off. The related registration method is more flexible. This time @SpringCloudApplication is officially removed in the new version, and the old version needs to be adjusted accordingly during the upgrade process.

The above content is some relatively direct changes at the framework level in the process of Spring Cloud Alibaba adapting to JDK 17 & Spring 6 & Spring Boot 3.0 & Spring Cloud 2022.0.0. For more features and changes brought about by other related new versions, please refer to related documents Spring 6, [Spring Boot 3.0](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-3. 0-Release-Notes), Spring Cloud 2022.0.0. In addition, in adapting to support GraalVM technology to build the native mirroring method of Spring Cloud Alibaba applications, the community has also cooperated with Nacos, Sentinel, Seata and other communities to make some transformations and compatibility. The details will be mentioned in the introduction of new features.

New features and how to use them

Building applications using GraalVM technology

Among all the components supported by Spring Cloud Alibaba adapted to Spring Boot 3.0 this time, Nacos 2.2.1-RC already supports GraalVM technology to build applications. Next, we will introduce related components that use GraalVM technology to compile and run applications:

Project build

Just follow the general Spring Cloud Alibaba application construction method to build the project. The following are the dependencies that must be added:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.0</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-commons</artifactId>
</dependency>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2022.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2022.0.0.0-RC1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

The above are the necessary dependencies for service registration using Nacos through Spring Cloud Alibaba this time. Please adjust other dependencies according to your own needs. Please note that it is very important to use the GraalVM spring-boot-starter-parent parent module. It declares a native profile, which contains the necessary information to create and run the GraalVM native image. There are two main ways to build Spring Boot native image applications:

1. Use Spring Boot's support for Cloud Native Buildpacks to generate lightweight containers containing native executables.
2. Generate a native executable using GraalVM Native Build Tools.

Since the first method has certain requirements for the local environment, if you need to use it, please refer to Spring Boot 3.0 Related User Documentation. Next, this article demonstrates the use of the second method for GraalVM application construction.

Environment preparation

To build a native image using Native Build Tools, the GraalVM distribution needs to be installed on the machine first. You can download it manually on the Liberica Native Image Kit page, or use a download manager like SDKMAN! The demonstration environment in this article is MacOS. If it is Windows, you can refer to corresponding documents to operate. Execute the following command to install the GraalVM environment:

sdk install java 22.3.r17-nik
sdk use java 22.3.r17-nik

Verify that the correct version is configured by checking the output of java -version:

$ java -version
openjdk version "17.0.5" 2022-10-18 LTS
OpenJDK Runtime Environment GraalVM 22.3.0 (build 17.0.5+8-LTS)
OpenJDK 64-Bit Server VM GraalVM 22.3.0 (build 17.0.5+8-LTS, mixed mode)

Resource file preparation

Before building the application, you need to add the following relevant build tool plugins to the application pom.xml file.

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <jvmArguments>
                        -agentlib:native-image-agent=config-merge-dir=src/main/resources/META-INF/native-image/
                    </jvmArguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.graalvm.buildtools</groupId>
                <artifactId>native-maven-plugin</artifactId>
            </plugin>
        </plugins>
</build>

After adding the above plug-ins, use the following commands to generate hint configuration files required for reflection, serialization, and dynamic proxy in the application.

mvn -Pnative spring-boot:run

After running successfully and stopping the application, the following hint files will be generated in the resource/META-INF/native-image directory of the project:

• resource-config.json: resource hint file in the application
• reflect-config.json: reflection definition hint file in the application
• serialization-config.json: the serialization content hint file in the application
• proxy-config.json: a hint file for Java proxy related content in the application
• jni-config.json: Java Native Interface (JNI) content hint file in the application

Since GraalVM cannot directly perceive the dynamic elements of the code, it needs the native application images generated by these hints to run. Note: The process of executing the above command to start the application to analyze the application attributes is dynamic. At this stage, it is necessary to fully test all the functions of the application to ensure that all necessary dynamic attributes during the application running process are completely generated. Otherwise, the content of the generated configuration file will be incomplete and an error will be reported during the operation phase. In the process of adapting Nacos service registration and consumption testing, the community has caused similar errors due to insufficient testing.

Compile native applications

After the above steps are all in place, use the following command to build the native application:

mvn -Pnative native:compile 

The native application construction phase will be time-consuming. Depending on the local environment resources, it will take a few minutes. After the above process is successfully executed, the following results will indicate that the construction is successful:

Finished generating 'nacos-discovery-provider-example' in 2m 36s.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  02:51 min
[INFO] Finished at: 2022-12-21T13:43:22+08:00
[INFO] ------------------------------------------------------------------------

Next, we start the application through target/nacos-discovery-provider-example, as shown in the following figure, the startup speed is very fast, and the application startup and service registration are completed in just over 0.3s:

...... : [REGISTER-SERVICE] public registering service DEFAULT_GROUP@@service-provider with instance: Instance{instanceId='null', ip='30.221.144.116', port=18082, weight=1.0, healthy=true, enabled=true, ephemeral=true, clusterName='DEFAULT', serviceName='null', metadata={preserved.register.source=SPRING_CLOUD}}
...... : null No credential found
...... : nacos registry, DEFAULT_GROUP service-provider 30.221.144.116:18082 register finished
...... : Started ProviderApplication in 0.328 seconds (process running for 0.339)

In addition, we can use the vmmap pid | grep Physical command to view the memory usage during operation: The above process is a Spring Cloud Alibaba application using GraalVM technology to build the application and complete the whole process of registering with Nacos. For relevant sample codes, please refer toSCA Nacos Example。Special attention should be paid to the fact that OpenFeign needs to make some adjustments in the process of using GraalVM, such as adding spring.cloud.refresh.enabled=false configuration. For the specific setting process, please refer to the relevant OpenFeign documentation。

Upgrade suggestions and precautions

1. The changes related to the Spring Cloud Alibaba version that supports Spring Boot 3.0 are relatively large overall. There are certain compatibility risks for old projects, especially the direct migration of Spring Boot 2.4 and below. It is recommended that relevant migration operations be fully verified and tested before proceeding.
2. The GraalVM technology introduced in Spring Boot 3.0 has significant advantages over the traditional JVM virtual machine model in terms of application startup speed, runtime memory usage, and package size. To a certain extent, it solves the problems that the Java language has been criticized, such as slow startup speed and excessively large build packages. However, related technologies are still under development, and there are still certain problems that need to be resolved within a period of time. For example, in the Spring Cloud Alibaba version released this time, in addition to the service registration and discovery and distributed transaction modules, the initial GraalVM support has been implemented. Other modules have more or less problems and cannot directly use GraalVM. This community is also continuing to work hard.

Community Future Planning

At present, the Spring Cloud Alibaba version released this time initially supports GraalVM, Sentinel/Seata/RocketMQ and other modules are also being actively supported, and the community will release it after compatibility and adaptation are completed. This is also the focus of short-term work for the future 2022.x branch! At present, you can use the community Examples module to complete the functional experience of the new version. Cloud native application scaffolding will support Spring Cloud Alibaba’s 2022.0.0.0-RC1 version in the near future. At that time, you can build new applications more conveniently through start.aliyun.com. Cloud native application scaffolding is a scaffold based on the Spring Initializr project that supports multiple engineering architectures, provides code sample fragments, richer components, and a more open ecosystem. frame. It is committed to providing developers with a simpler and more efficient project construction experience in the current cloud-native era. Currently the project is open source, and the Github address is https://github.com/alibaba/cloud-native-app-initializer. In addition, in the future, the work of the Spring Cloud Alibaba community will focus on building the microservice governance capabilities of the Spring Cloud ecosystem. Currently, the community has implemented label routing and service authentication capabilities based on Istio VirtualService and DestinationRule traffic and security specifications. In the future, users only need to write CRD rules to parse and deliver to the Spring Cloud Alibaba application in the system through the Istio control plane. You can easily have native microservice governance capabilities. Interested students are welcome to scan the DingTalk QR code below to join the community exchange group and participate in the future construction of the community together!