You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by wu...@apache.org on 2022/08/04 08:01:24 UTC
[shardingsphere] branch master updated: feat(blog): add new articles and images (#19798)
This is an automated email from the ASF dual-hosted git repository.
wuweijie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new bd6dd4cc473 feat(blog): add new articles and images (#19798)
bd6dd4cc473 is described below
commit bd6dd4cc47346775914e00eeac1cb130ae4d097a
Author: Yumeiya <10...@users.noreply.github.com>
AuthorDate: Thu Aug 4 16:01:16 2022 +0800
feat(blog): add new articles and images (#19798)
* add new blogs and images
* delete images
* Revert "delete images"
This reverts commit b685f405da2d32345c0fc19fbc5196ca94fd112d.
* Delete images
* Update 2022_06_08_How_does_Apache_ShardingSphere_standardize_and_format_code_We use_Spotless.en.md
* Update 2022_06_16_Understanding_Apache_ShardingSphere's_SPI_and_why_it’s_simpler_than_Dubbo’s.en.md
* Update 2022_06_28_Cloud_native_deployment_for_a_high-performance_data_gateway_new API driver_Apache_ShardingSphere_5.1.2_is_released.en.md
---
..._Governance_in_a_Cloud_Native_Environment.en.md | 137 +++++++
...andardize_and_format_code_We use_Spotless.en.md | 221 +++++++++++
...ngSphere_Enterprise_Applications_Bilibili.en.md | 93 +++++
...200\231s_simpler_than_Dubbo\342\200\231s.en.md" | 270 ++++++++++++++
...stem_RTO_60x_and_increasing_speed_by_20%.en.md" | 130 +++++++
...r_Apache_ShardingSphere_5.1.2_is_released.en.md | 407 +++++++++++++++++++++
...2022_06_30_ShardingSphere_&_Database_Mesh.en.md | 128 +++++++
7 files changed, 1386 insertions(+)
diff --git a/docs/blog/content/material/2022_06_02_Database_Mesh_2.0_Database_Governance_in_a_Cloud_Native_Environment.en.md b/docs/blog/content/material/2022_06_02_Database_Mesh_2.0_Database_Governance_in_a_Cloud_Native_Environment.en.md
new file mode 100644
index 00000000000..81e66666ea8
--- /dev/null
+++ b/docs/blog/content/material/2022_06_02_Database_Mesh_2.0_Database_Governance_in_a_Cloud_Native_Environment.en.md
@@ -0,0 +1,137 @@
++++
+title = "Database Mesh 2.0: Database Governance in a Cloud Native Environment"
+weight = 58
+chapter = true
++++
+
+In March 2018, an article titled [Service Mesh is the broad trend, what about Database Mesh?](https://www.infoq.cn/article/database-mesh-sharding-jdbc), was pubslished on [InfoQ China](https://www.infoq.com/) and went viral in the technical community.
+In this article, Zhang Liang, the founder of [Apache ShardingSphere](https://shardingsphere.apache.org/), described Database Mesh concept along with the idea of [Service Mesh](https://linkerd.io/what-is-a-service-mesh/). Four years later, the Database Mesh concept has been integrated by several companies together with their own tools and ecosystems. Today, in addition to Service Mesh, a variety of “X Mesh” concepts such as [ChaosMesh](https://chaos-mesh.org/), [EventMesh](https://eventme [...]
+
+This article reviews the background of Database Mesh, reexamines the value of Database Mesh 1.0, and introduces the new concepts, ideas, and features of Database Mesh 2.0. It also attempts to explore the future of Database Mesh.
+
+## 1. Reviewing Database Mesh 1.0
+In 2016, the first generation of Service Mesh was introduced to the public by [Linkerd](https://linkerd.io/). In 2017, the second generation of Service Mesh, was born thanks to [Istio](https://istio.io/). Its design separates the control plane from data plane, and key behavioral factors such as traffic governance, access control and observability in service governance are abstracted and standardized. Then the application container and governance container are decoupled by [Kubernetes](ht [...]
+
+
+
+Almost at the same time, [ShardingSphere](https://shardingsphere.apache.org/) led by Zhang Liang evolved from the original [ShardingSphere-JDBC](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-jdbc) into the [ShardingSphere-Proxy](https://shardingsphere.apache.org/document/current/en/quick-start/shardingsphere-proxy-quick-start/) we know today, that can be deployed independently. Both built in Java, respectively representing SDK mode and Proxy mode, providi [...]
+
+Both of them have their respecitve pros and cons. In 2018, the article, [Service Mesh is the broad trend, what about Database Mesh?](https://www.infoq.cn/article/database-mesh-sharding-jdbc) written by Zhang Liang (on InfoQ China) described Database Mesh as:
+
+”Database Mesh is a new term derived from Service Mesh. As its name suggests, Database Mesh uses a mesh layer to achieve unified management of databases scattered around the system. The network of interactions between applications and databases, held together by mesh layers, is as complex and ordered as a spider’s web.”
+
+According to this description, the concept of Database Mesh is similar to that of the Service Mesh. It is called Database Mesh, not Data Mesh, because its primary goal is not to engage data stored in the database, but to engage the interaction between applications and databases.
+
+Database Mesh focuses on how to organically connect distributed applications for data access with databases. It’s more focused on the interaction, and effectively clarifies the interaction between chaotic applications and databases.
+
+Database Mesh empowers applications that access databases, eventually forming a huge databases grid. Applications and databases can simply be matched in the grid and are governed by the mesh layer.
+
+This means that the implementation of Service Mesh in Kubernetes’ Sidecar model opens new possibilities: ShardingSphere-Sidecar mode can effectively combine the advantages and minimize the disadvantages of JDBC, Proxy and Proxy client, and achieve a real cloud infrastructure with “elastic scaling + zero intrusion + decentralization”.
+
+When a new technology concept is launched, it’ll be characterized hahahby different business scenarios and patterns, different architectural design, different infrastructure maturity, and even different engineering cultures. It is a belief that has been fully demonstrated in the implementation of Kubernetes, and has been reinforced by Service Mesh. What about Database Mesh?
+
+[ShardingSphere-Sidecar](https://shardingsphere.apache.org/document/current/en/user-manual/shardingsphere-sidecar/) incorporates ShardingSphere’s sharding capabilities, while some companies delivered their own interpretation based on Database Mesh.
+
+For example, analysis and support for SQL protocol are added in Service Mesh by means of secondary development to enhance the database traffic governance ability, which is compatible with the unified service governance configuration. The concept of Database Mesh is integrated into a complete set of middleware service frameworks, and a unified access mode is provided for business applications in the form of SDK or Sidecar to simplify the operation for developers.
+
+Another example is the project that integrates distributed transaction capabilities into the Database Mesh Sidecar, presenting business applications as cloud native distributed databases. Either way, you can see that the Database Mesh concept is taking gaining acceptance and growing into a thriving ecosystem.
+
+
+
+Note: There are three implementations of Database Mesh 1.0: ShardingSphere-Sidecar, Unified Mesh management, and distributed database from left to right respectively.
+
+**So that’s Database Mesh 1.0.**
+
+## 2. Introducing Database Mesh 2.0
+In computer science, operating systems and databases are arguably the two most important basic softwares. SQL, for example, has an impressive half-life period. SQL not only played an important role in the early DBMS systems, but recently has become a must-have skill in data science along with Python. The vitality of SQL can be said to be timeless, which explains the famous paper proclaiming “[One SQL to rule them all](https://arxiv.org/abs/1905.12133)”.
+
+If the database is perceived as a service node in the call-chain, then the framework of Service Mesh can also be used for governance. If a database is viewed as a stateful business application, its unique field gives rise to governance specificities. For example, database requests cannot be randomly routed to any peer nodes like services. More challenges are caused by the perception and understanding of database protocols, data sharding and routing, multiple replicas deployed by database [...]
+
+Moreover, when business applications are packaged and delivered in containers, and they are distributed to the Kubernetes infrastructure of each data center hundreds of thousands of times through [CI/CD pipelines](https://www.redhat.com/en/topics/devops/what-cicd-pipeline), people will undoubtedly think about how to achieve service governance in the upper layer of applications and database governance. Database Mesh is an answer to this question.
+
+Without Database Mesh, SDK and Proxy can also support the access and governance to databases. Sidecar itself is not the core of Database Mesh.
+
+> **Database Mesh is not a static definition, but an evolving dynamic concept.**
+
+Database Mesh 1.0 has been focusing on the governance of database traffic. It can support data sharding, load balancing, observability, auditing and other capabilities based on database protocol sensibility, which have tackled part of the problems related to traffic governance. However, many capabilities are still yet to be built for operators and database administrators (DBAs). For instance, can a unified configuration be used to declare database access? Can we restrict resource access [...]
+
+Developers may pay more attention to operational efficiency, cost overhead, database protocol type and access information rather than where the data is stored. Operators and database administrators (DBAs) are more concerned about the automation, stability, security, monitoring and alarming of database services. In addition, DBAs also focus on the changes, capacity, secure access, backup and migration of data. All of these factors are tied with database reliability engineering.
+
+It is precisely with the in-depth understanding of database governance scenarios and the pursuit of ultimate user experience that led to the creation of Database Mesh 2.0. Database Mesh 2.0 can achieve high-performance scalability through programmability to address the challenge of database governance on the cloud.
+
+**The goals of Database Mesh 2.0**
+Database Mesh 2.0 focuses on how to achieve the following goals in a cloud native environment:
+
+- Further reduce the mental burden of developers, improve development efficiency, and provide a transparent and intuitive user experience with database infrastructure.
+- Build a database governance framework including database traffic, runtime resources, reliability in a configurable, pluggable and customizable manner.
+- Provide standard user interfaces for typical scenarios in multiple database fields such as heterogeneous data sources, cloud native databases, and distributed databases.
+
+> **Developer experience**
+
+As mentioned above, business developers are mainly concerned about business logic and implementation instead of infrastructure, operation and maintenance features. Developement experience will move towards [Serverless](https://www.redhat.com/en/topics/cloud-native-apps/what-is-serverless), which means it will become more and more transparent and intuitive when accessing databases. Developers only need to understand the type of data storage required by their business, and then use preset [...]
+
+> **Programmable**
+
+For database traffic, different scenarios have different load balancing policies and firewall rules, which can be provided to users in the form of configuration. Furthermore, runtime resources such as traffic and bandwidth can be restricted by loading programmable plugins. Both configurations and plugins are designed to provide users with the maximum flexibility within the framework, implementing the Unix design philosophy of “separation of mechanism and policy”.
+
+> **Standard interface**
+
+In the process of migrating databases to the cloud, the migration complexity has increased due to many issues such as deployment mode, data migration, and data capacity. If you have a complete set of operating interfaces, you can achieve unified governance across different database environments, thus smoothing the process of cloud adoption in the future.
+
+**Database Mesh 2.0 governance framework**
+Database Mesh 2.0 provides a database-centric governance framework to achieve the three goals introduced above:
+
+- Databases are first-class citizens. All abstractions are centered on database governance, such as access control, traffic governance, and observability.
+- Engineer-oriented experience: developers can continue to develop through easy to use database declarations and definitions regardless of the location of the database. For operation and maintenance personnel and DBAs, it provides a variety of abstraction of database governance behavior to realize automatic database reliability engineering.
+- Cloud native: it is built and implemented oriented towards cloud native, suitable to various cloud environments with an open ecosystem and implementation mechanism. Vendor lock-in is effectively elimated.
+
+
+The set of governance framework relies on the following work loads:
+
+- Virtual database: a database endpoint accessible to developers.
+- Traffic strategy: governance strategies for database access traffic such as sharding, load balance, traffic control and circuit breaker.
+- Access control: provides fine-grained access control based on specified rules, such as table level.
+- Security statement: data security statements such as data encryption.
+- Audit application: record applications’ operation behavior on the database, such as accessing the risk control system.
+- Observability: configuration of database observability such as access traffic, running state, and performance indicators etc.
+- Event bus: an event bus that accepts data changes.
+- QoS statements: resource QoS metrics set to improve the overall SLO metrics of the database.
+- Backup plan: perform database backups as scheduled tasks.
+- `Schema` pipeline: manage database `schema` changes in code to improve the success rate of database DDL and DML changes.
+The above design framework enables development to be more centralized and efficient and cloud computing more user-friendly. In other words, Database Mesh is making big strides towards scalability, ease of use and standardization.
+
+**That’s Database 2.0.**
+
+## 3. Database Mesh community
+The [Database Mesh official website](https://www.database-mesh.io/) has been launched. The corresponding specification definition is open sourced on this [Github](https://github.com/database-mesh/database-mesh) repository. The community holds an online discussion every two weeks:
+
+- [Mailing list](https://groups.google.com/g/database-mesh)
+- [Biweekly meeting of English community](https://meet.google.com/yhv-zrby-pyt) (from February 27, 2022), on Wednesday 9:00 AM PST
+- [Biweekly meeting of Chinese community](https://meeting.tencent.com/dm/6UXDMNsHBVQO) (from April 27, 2022), on Wednesday 9:00 PM GMT+8
+- [Slack](https://databasemesh.slack.com/)
+- [Meeting minutes](https://bit.ly/39Fqt3x)
+
+You’re welcome to join the official community for discussion. The Database Mesh community welcomes enthusiasts from from all over the world to build the ecosystem together.
+
+SphereEx, a company founded by Zhang Liang (who is also the initiator of Database Mesh), will launch [Pisanix](https://www.pisanix.io/) next month, which is an open source solution oriented database mesh.
+
+## Authors
+**Miao Liyao**
+
+**Github:** @mlycore
+
+
+
+The Head of Cloud R&D at [SphereEx](https://www.sphere-ex.com/), a promoter of open source, specializing in SaaS and Database Mesh
+
+In 2015, he began to study [Kubernetes](https://kubernetes.io/) and was one of the earliest cloud native practitioners in China. In 2016, he established the “Container Era” WeChat blog and contributed over 600 technical articles. He previously was an infrastructure architect, cloud product leader, cloud native R&D engineer at 株式会社ネットスターズ([NETSTARS](https://netstars.co.jp/en/)), Beijing Chuanyang Technology, [Ant Financial Services Group](https://www.antgroup.com/en), [YeePay](https://glo [...]
+
+**Zhang Liang**
+
+**Github:** @terrymanu
+
+
+Zhang Liang, the founder & CEO of [SphereEx](https://www.sphere-ex.com/), served as the head of the architecture and database team of many large well-known Internet enterprises. He is enthusiastic about open source and is the founder and PMC chair of Apache ShardingSphere, [ElasticJob](https://shardingsphere.apache.org/elasticjob/), and other well-known open source projects.
+
+He is now a member of the [Apache Software Foundation](https://www.apache.org/), [a Microsoft MVP](https://mvp.microsoft.com/), [Tencent Cloud TVP](https://cloud.tencent.com/tvp), and [Huawei Cloud MVP](https://developer.huaweicloud.com/mvp) and has more than 10 years of experience in the field of architecture and database. He advocates for elegant code, and has made great achievements in distributed database technology and academic research. He has served as a producer and speaker at do [...]
+
diff --git a/docs/blog/content/material/2022_06_08_How_does_Apache_ShardingSphere_standardize_and_format_code_We use_Spotless.en.md b/docs/blog/content/material/2022_06_08_How_does_Apache_ShardingSphere_standardize_and_format_code_We use_Spotless.en.md
new file mode 100644
index 00000000000..1871401d765
--- /dev/null
+++ b/docs/blog/content/material/2022_06_08_How_does_Apache_ShardingSphere_standardize_and_format_code_We use_Spotless.en.md
@@ -0,0 +1,221 @@
++++
+title = "How does Apache ShardingSphere standardize and format code? We use Spotless"
+weight = 59
+chapter = true
++++
+
+Why do we need to format code? Simply put, it’s to make code easier to read, understand, and modify.
+
+As a Top-Level Apache open source project, [ShardingSphere](https://shardingsphere.apache.org/) has 400 contributors as of today. Since most developers do not have the same coding style, it is not easy to standardize the project’s overall code format in a GitHub open collaboration model. To solve this issue, ShardingSphere uses [Spotless](https://github.com/diffplug/spotless/tree/main/plugin-maven) to unify code formatting.
+
+## What is Spotless?
+Spotless is a multi-lingual code formatting tool that supports [Maven](https://maven.apache.org/) and [Gradle](https://gradle.org/) building with plugin.
+
+Devs can use Spotless in two ways: reviewing code for format-related issues, and formatting code.
+
+> The ShardingSphere community uses Maven to build its projects — and Spotless uses Maven for its demos.
+
+## How to use it?
+Let’s check the official demo below:
+
+```
+user@machine repo % mvn spotless:check
+[ERROR] > The following files had format violations:
+[ERROR] src\main\java\com\diffplug\gradle\spotless\FormatExtension.java
+[ERROR] -\t\t····if·(targets.length·==·0)·{
+[ERROR] +\t\tif·(targets.length·==·0)·{
+[ERROR] Run 'mvn spotless:apply' to fix these violations.
+user@machine repo % mvn spotless:apply
+[INFO] BUILD SUCCESS
+user@machine repo % mvn spotless:check
+[INFO] BUILD SUCCESS
+```
+When you check the project code with `mvn spotless:check`，an error occurs, then you format the code with `mvn spotless:apply`. And once you check it again, the formatting error has magically disappeared.
+
+**1. Preparing your environment**
+ShardingSphere uses Spotless to adding Java file `licenseHeader` and formatting Java code.
+
+Spotless has several Java code formatting methods, such as: `googleJavaFormat`, `eclipse`, `prettier` etc.
+
+For customization reasons, we chose `eclipse` for Java code formatting.
+
+
+
+```
+**a) Add `licenseHeader` according to project requirements**
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+```
+Note: remember to include a space at the end of the `licenseHeader`. Otherwise there will be no space between the `licenseHeader` and the package.
+
+**b) Add `shardingsphereeclipseformatter.xml`**
+
+```xml
+?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="13">
+ <profile kind="CodeFormatterProfile" name="'ShardingSphere Apache Current'" version="13">
+ <setting id="org.eclipse.jdt.core.compiler.source" value="1.8"/>
+ <setting id="org.eclipse.jdt.core.compiler.compliance" value="1.8"/>
+ <setting id="org.eclipse.jdt.core.compiler.codegen.targetPlatform" value="1.8"/>
+ <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="true"/>
+ <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+ <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="200"/>
+ <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="200"/>
+ <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="space"/>
+ <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="1"/>
+ <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="false"/>
+ <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="false"/>
+ <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+ <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="16"/>
+ <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+ <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="16"/>
+ <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+ <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="160"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="10"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="106"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="106"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="106"/>
+ <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call.count_dependent" value="16|5|80"/>
+ </profile>
+</profiles>
+```
+For latest rules of ShardingSphere, see `[shardingsphereeclipseformatter.xml](https://github.com/apache/shardingsphere/blob/master/src/resources/shardingsphere_eclipse_formatter.xml)`. For references, check the `[eclipse-java-google-style.xml](https://github.com/google/styleguide/blob/gh-pages/eclipse-java-google-style.xml)` file.
+
+The content of `shardingsphereeclipseformatter.xml` is tailor-made in accordance with the ShardingSphere code specification and can be changed flexibly.
+
+**c) Add Maven plugin**
+
+```xml
+<plugin>
+ <groupId>com.diffplug.spotless</groupId>
+ <artifactId>spotless-maven-plugin</artifactId>
+ <version>2.22.1</version>
+ <configuration>
+ <java>
+ <eclipse>
+ <file>${maven.multiModuleProjectDirectory}/src/resources/shardingsphere_eclipse_formatter.xml</file>
+ </eclipse>
+ <licenseHeader>
+ <file>${maven.multiModuleProjectDirectory}/src/resources/license-header</file>
+ </licenseHeader>
+ </java>
+ </configuration>
+</plugin>
+```
+
+Spotless supports specified formatting directories and the exclusion of specified directories. For further information, see `plugin-maven#java`. If not specified, when check or apply is executed, all of the project code will be affected by default.
+
+**d) Execute code formatting**
+
+After performing the above three steps, you can execute commands in your project to check the Java code for compliance with the specification, as well as the code formatting features.
+
+```
+user@machine repo % mvn spotless:apply
+[INFO] BUILD SUCCESS
+user@machine repo % mvn spotless:check
+[INFO] BUILD SUCCESS
+```
+
+## 2. Binding the Maven Life Cycle
+In the actual ShardingSphere application, you can opt to bind Spotless apply to the compile phase so that it is automatically formatted when mvn install is executed locally.
+
+```xml
+<plugin>
+ <groupId>com.diffplug.spotless</groupId>
+ <artifactId>spotless-maven-plugin</artifactId>
+ <version>2.22.1</version>
+ <configuration>
+ <java>
+ <eclipse>
+ <file>${maven.multiModuleProjectDirectory}/src/resources/shardingsphere_eclipse_formatter.xml</file>
+ </eclipse>
+ <licenseHeader>
+ <file>${maven.multiModuleProjectDirectory}/src/resources/license-header</file>
+ </licenseHeader>
+ </java>
+ </configuration>
+ <executions>
+ <execution>
+ <goals>
+ <goal>apply</goal>
+ </goals>
+ <phase>compile</phase>
+ </execution>
+ </executions>
+</plugin>
+
+```
+
+## 3. IDEA formatting
+If you want to check a single file for compliance when writing code, executing `mvn spotless:check` or `mvn spotless:apply` will be a bit unwieldy, as by default the formatting scope is the entire project.
+
+IntelliJ IDEA’s native formatting functionality can be replaced by shardingsphereeclipseformatter.xml.
+
+This way, you can format your code at any time during the writing process, improving efficiency significantly.
+
+IDEA Version: 2019.3.4
+
+**a) Install the plugin Eclipse Code Formatter
+**
+
+
+**b) Select shardingsphereeclipseformatter.xml as the default formatting template**
+
+
+
+Spotless code formatting can be done using IDEA code formatting shortcuts.
+
+## FAQ
+**1. Conflicts between Spotless and Checkstyle**
+[Checkstyle](https://github.com/checkstyle/checkstyle) is a tool for checking Java source code for compliance with code standards or a set of validation rules (best practices).
+
+In extreme circumstances, Spotless formatted code cannot pass Checkstyle checking.
+
+The underlying cause is a conflict between the checking mechanism and formatting configurations set by both. For example, Spotless formats a newline with a 16-space indent, while Checkstyle checks for a 12-space newline.
+
+```java
+private static Collection<PreciseHintShadowValue<Comparable<?>>> createNoteShadowValues(final ShadowDetermineCondition shadowDetermineCondition) {
+ // format that can pass Checkstyle
+ return shadowDetermineCondition.getSqlComments().stream().<PreciseHintShadowValue<Comparable<?>>>map(
+ each -> new PreciseHintShadowValue<>(tableName, shadowOperationType, each)).collect(Collectors.toList());
+ // After being formatted by Spotless
+ return shadowDetermineCondition.getSqlComments().stream().<PreciseHintShadowValue<Comparable<?>>>map(
+ each -> new PreciseHintShadowValue<>(tableName, shadowOperationType, each)).collect(Collectors.toList());
+}
+```
+This case requires devs to weigh the trade-offs. There are two solutions: modify Spotless’ formatting rules, or modify Checkstyle’s checking rules.
+
+**2. Formatting conflict between CRLF & LF**
+
+See [https://github.com/diffplug/spotless/issues/1171](https://github.com/diffplug/spotless/issues/1171)
+
+## Summary
+Apache ShardingSphere uses Spotless to format legacy code, and the subsequent standardization of code formatting, which helps keeping the project’s code tidy.
+
+Of course, Spotless is not limited to Java code formatting, but also includes the formatting of file types such as `Pom` and `Markdown`, which will soon be applied in ShardingSphere.
+
+## Author
+**Longtai**
+
+[Github ID](https://github.com/longtai-cn): longtai-cn
+
+[Apache ShardingSphere](https://shardingsphere.apache.org/) Contributor; hippo4j author (2.2K GitHub stars).
diff --git a/docs/blog/content/material/2022_06_10_Apache_ShardingSphere_Enterprise_Applications_Bilibili.en.md b/docs/blog/content/material/2022_06_10_Apache_ShardingSphere_Enterprise_Applications_Bilibili.en.md
new file mode 100644
index 00000000000..1660cf44a61
--- /dev/null
+++ b/docs/blog/content/material/2022_06_10_Apache_ShardingSphere_Enterprise_Applications_Bilibili.en.md
@@ -0,0 +1,93 @@
++++
+title = "Apache ShardingSphere Enterprise Applications — Bilibili"
+weight = 60
+chapter = true
++++
+
+> To further understand application scenarios, and enterprises’ needs, and improve dev teams’ understanding of Apache ShardingSphere, our community launched the “Enterprise Visits”
+> series.
+
+
+[Apache ShardingSphere](https://shardingsphere.apache.org/)’s core contributor team was invited to the headquarters of [Bilibili](https://www.bilibili.com/) in Shanghai. Our PMC Chair, Zhang Liang, discussed with Bilibili’s tech team the e-commerce and digital entertainment verticals application scenarios, and the capabilities of different versions of ShardingSphere.
+
+With the unprecedented growth of data volume and increasingly diversified data application scenarios, different platforms, businesses, and scenarios have resulted in database applications’ fragmentation. The challenges facing databases today are totally different from the ones they were conceived to solve. This is also reflected in the growth of Bilibili’s e-commerce business.
+
+For over a decade, Bilibili has built an ecosystem community centered on users, creators, and content, while producing high-quality videos as well. With an increasing number of users, Bilibili has also gradually developed peripheral business ecosystems such as its subscription revenue model. The expansion of business lines and application scenarios brought great challenges for Bilibili’s tech team, especially in the management and application of backend data.
+
+During the visit, our community and Bilibili mainly discussed these three points:
+
+## The SQL warm-up feature jointly built with Bilibili:
+When Bilibili queries goods and orders with batch priority in its business, it is often necessary to manually warm-up SQL during the initial linking process to improve overall performance. However, in the process of manual warm-up, parameters of different lengths cannot be used as a SQL to warm-up due to the use of `foreach` syntax of the [Mybatis](https://mybatis.org/mybatis-3/index.html) framework.
+
+Apache ShardingSphere can see the SQL execution plan through the `preview`, thus warming up the SQL. In the future, we plan to provide a separate SQL warm-up interface and merge the SQL warm-up time into the startup time. ShardingSphere will start on its own after SQL is warmed up.
+
+[Apache ShardingSphere](https://shardingsphere.apache.org/) is an open-source project driven by the needs of the community. Currently, many capabilities’ development is driven by specific user requirements, which are fed back to the community after development and gradually integrated into Apache ShardingSphere.
+
+Therefore, the ShardingSphere community invited Bilibili’s tech team to get involved in terms of the SQL warm-up feature.
+
+With the expansion of Apache ShardingSphere’s application scenarios, there is a higher expectation for ShardingSphere’s capabilities to adapt to a variety of special business scenarios. In the previous “Enterprise Visits” series, the ShardingSphere community recognized that even though it has more than 100 feature modules, enterprises from various verticals have different expectations from ShardingSphere.
+
+## Bilibili’s circuit breaker automation in traffic spike scenarios:
+
+With the growth of Bilibili’s e-commerce scale, as is often the case with many e-commerce businesses, started to adopt front-end strategies such as cash rebates and flash deals in order to improve user retention.
+
+On the backend, however, when the rebate performance of the warehouse is equal to the number of concurrent transactions while exceeding its own connection number limit, it can only be stopped through manual disconnection via DBA based on the number of SKU at the business level. Manual intervention is inefficient and consumes DBAs’ energy, so [ShardingSphere-Proxy](https://shardingsphere.apache.org/document/current/en/quick-start/shardingsphere-proxy-quick-start/) is expected to provide a [...]
+
+However, the flash deal scenario is too demanding, so [Redis](https://redis.io/) still represents a better choice. Achieving automation simply requires setting rules and thresholds.
+
+Sinking data to Proxy can also achieve the capabilities of Redis, but no matter how the upper layer changes, the bottom of the database will not change. Therefore, it is better for DBAs to take the initiative to operate the circuit breaker mechanism. Otherwise, after setting a threshold, if the connection between the application and the database has a slight timeout, a large number of transactions will be cut off instantly, which can easily cause a business outage.
+
+Currently, a better way is to dig out all kinds of key information and display it on the visual interface based on Proxy, to facilitate the real-time comparison and operation of DBA instead of achieving automation.
+
+## The Apache ShardingSphere registry:
+In the Apache ShardingSphere architecture, the registry provides distributed governance capabilities and is fully open to users since its computing node ([Shardingsphere-proxy](https://shardingsphere.apache.org/document/current/en/quick-start/shardingsphere-proxy-quick-start/)) is stateless without data storage capability. Therefore, user accounts and authorization information need to be stored in the registry.
+
+Concurrently, with the help of the registry, Apache ShardingSphere can distribute information to multiple computing nodes in the cluster in real-time, greatly reducing maintenance costs for users when using the cluster and improving management efficiency.
+
+In cluster mode, Apache ShardingSphere integrates third-party registry components [ZooKeeper](https://zookeeper.apache.org/) and [Etcd](https://etcd.io/) to achieve metadata and configuration sharing in the cluster environment. At the same time, with the help of the notification and coordination ability of the registry, it ensures the real-time synchronization of the cluster when the shared data changes. And the business will not be aware of changes from the registry.
+
+## Q&A with Bilibili
+**Q: Is there a performance loss when using JDBC to connect to the governance center?**
+
+A: No. It only connects to the governance center during initialization, and the governance center will send a push when there is a change.
+
+**Q: How does [Sysbench](https://wiki.gentoo.org/wiki/Sysbench) conduct a stress test on Apache ShardingSphere?**
+
+A: The two deployment types of Apache ShardingSphere, JDBC and Proxy, are both tested by Sysbench. ShardingSphere has a newly designed Sysbench-like Java program on the JDBC end that can be used to conduct a pressure test to JDBC and Proxy. It can also ensure that the official Sysbench and our Java program share the same standard.
+
+**Q: Can ShardingSphere converge the connection number?**
+
+A: ShardingSphere-Proxy can converge the connection number, but it will definitely lead to performance loss.
+
+**Q: Can Proxy identify slow SQL?**
+
+A: Currently, the open-source version doesn’t support this function, because most users of the open-source version are Internet enterprises with a low tolerance for performance loss. Thus, the number of probes is relatively small.
+
+**Q: Does [ElasticJob](https://shardingsphere.apache.org/elasticjob/) belong to Apache ShardingSphere?**
+
+A: ElasticJob is currently used as the migration tool by Apache ShardingSphere. Additionally, ElasticJob can also be used for liveness probes.
+
+**Q: Are Internet enterprises using Proxy on a large scale?**
+
+A: Most Internet users choose the mixed deployment model, using JDBC for development and better performance, and Proxy for management. Financial customers prefer to use Proxy because they can take Proxy as a database for unified management without additional learning costs.
+
+**Q: We are currently using ShardingSphere version 4.1.1, what does it support for transactions?**
+
+A: Both versions 4.11 and 5.1.0 support [XA](https://docs.oracle.com/database/121/TTCDV/xa_dtp.htm#TTCDV327) distributed transaction management. We plan to develop the global transaction manager ([GTM](https://docs.oracle.com/cd/E17276_01/html/programmer_reference/xa_build.html)) which is scheduled to start in the second half of this year.
+
+## Get in touch with us
+If you have applied Apache ShardingSphere solutions in your business or if you want to quickly understand and introduce the Apache ShardingSphere 5.X ecosystem to your business, you’ll probably like for someone from our community to help you out and share the Apache ShardingSphere technology with your team.
+
+Feel free to reach out to us on one of our official community channels, such as Twitter or Slack.
+
+If we both agree that ShardingSphere is suitable for your business scenarios, our community team will be happy to connect with you and your engineers to take their questions.
+
+**Apache ShardingSphere Project Links:**
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
\ No newline at end of file
diff --git "a/docs/blog/content/material/2022_06_16_Understanding_Apache_ShardingSphere's_SPI_and_why_it\342\200\231s_simpler_than_Dubbo\342\200\231s.en.md" "b/docs/blog/content/material/2022_06_16_Understanding_Apache_ShardingSphere's_SPI_and_why_it\342\200\231s_simpler_than_Dubbo\342\200\231s.en.md"
new file mode 100644
index 00000000000..3354bc44f22
--- /dev/null
+++ "b/docs/blog/content/material/2022_06_16_Understanding_Apache_ShardingSphere's_SPI_and_why_it\342\200\231s_simpler_than_Dubbo\342\200\231s.en.md"
@@ -0,0 +1,270 @@
++++
+title = "Understanding Apache ShardingSphere's SPI, and why it’s simpler than Dubbo’s"
+weight = 61
+chapter = true
++++
+
+
+
+
+## Why learn [ShardingSphere](https://shardingsphere.apache.org/)’s SPI?
+You might already be familiar with [Java](https://www.java.com/en/) and [Dubbo](https://dubbo.apache.org/en/)’s SPI ([Service Provider Interface](https://en.wikipedia.org/wiki/Service_provider_interface)) mechanism, so you may wonder “why would I learn about [ShardingSphere](https://shardingsphere.apache.org/)’s SPI mechanism?” The reasons are quite simple:
+
+1. ShardingSphere’s source code is simpler and easier to adapt.
+2. The execution of ShardingSphere’s SPI mechanism is quite smooth, with less code required for day-to-day operations. Unlike Dubbo’s SPI mechanism and its additional features related to [IoC](https://medium.com/@amitkma/understanding-inversion-of-control-ioc-principle-163b1dc97454), the one in ShardingSphere only preserves the fundamental structure, making it effortless to use.
+
+## Understanding ShardingSphere’s SPI
+We also have to mention some shortcomings found in the [Java SPI](https://docs.oracle.com/javase/tutorial/sound/SPI-intro.html) mechanism:
+
+1. Instances of the [ServiceLoader](https://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html) class with multiple concurrent threads are not safe to use.
+2. Each time you get an element, you need to iterate through all the elements, and you can’t load them on demand.
+3. When the implementation class fails to load, an exception is prompted without indicating the real reason, making the error difficult to locate.
+4. The way to get an implementation class is not flexible enough. It can only be obtained through the [Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html) form, not based on one parameter to get the corresponding implementation class.
+
+In light of this, let’s see how [ShardingSphere](https://shardingsphere.apache.org/) solves these problems in a simple way.
+
+## Loading SPI class
+Dubbo is a direct rewrite of its own SPI, including the SPI file name and the way the file is configured, in stark contrast to [JDK](https://www.oracle.com/java/technologies/downloads/). Let’s briefly compare the differences between the uses of these two:
+
+**Java SPI**
+
+Add interface implementation class under the folder `META-INF/services`
+
+```
+optimusPrime = org.apache.spi.OptimusPrime
+bumblebee = org.apache.spi.Bumblebee
+```
+
+**Dubbo SPI**
+
+Add the implementation class of the interface to the folder `META-INF/services`, configure by means of `key`, `value` like the following example:
+
+```
+optimusPrime = org.apache.spi.OptimusPrime
+bumblebee = org.apache.spi.Bumblebee
+```
+
+We can see now that Dubbo’s Java SPI is completely different from the JDK SPI.
+
+## How does ShardingSphere easily extend the JDK SPI?
+
+Unlike the Dubbo implementation concept, ShardingSphere extends the JDK SPI with less code.
+
+1. The configuration is exactly the same as in the Java SPI.
+Let’s take the `DialectTableMetaDataLoader` interface implementation class as an example:
+
+`DialectTableMetaDataLoader.class`
+
+```java
+public interface DialectTableMetaDataLoader extends StatelessTypedSPI {
+ /**
+ * Load table meta data.
+ *
+ * @param dataSource data source
+ * @param tables tables
+ * @return table meta data map
+ * @throws SQLException SQL exception
+ */
+ Map<String, TableMetaData> load(DataSource dataSource, Collection<String> tables) throws SQLException;
+}
+public interface TypedSPI {
+ /**
+ * Get type.
+ *
+ * @return type
+ */
+ String getType();
+ /**
+ * Get type aliases.
+ *
+ * @return type aliases
+ */
+ default Collection<String> getTypeAliases() {
+ return Collections.emptyList();
+ }
+}
+```
+`StatelessTypedSPI` interface takes it from `TypedSPI` and multiple interfaces are used to meet the principle of single interface responsibility. `TypedSPI` is the key of the `Map` where subclasses need to specify their own SPI.
+
+Here you don’t need to care about what methods are defined by the `DialectTableMetaDataLoader` interface, you just have to focus on how the subclasses are loaded by SPI. If it is a Java SPI, to load the subclasses, you just define it by the full class name in `META-INF/services`.
+
+
+
+As you can see, it is exactly the same as the native java SPI configuration. So how about its shortcomings?
+
+## Using the Factory Method Pattern
+For every interface that needs to be extended and created by SPI, there usually is a similar `xxDataLoaderFactory` for creating and acquiring the specified SPI extension class.
+
+`DialectTableMetaDataLoaderFactory`
+
+```java
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class DialectTableMetaDataLoaderFactory {
+ static {
+ ShardingSphereServiceLoader.register(DialectTableMetaDataLoader.class);
+ }
+ /**
+ * Create new instance of dialect table meta data loader.
+ *
+ * @param databaseType database type
+ * @return new instance of dialect table meta data loader
+ */
+ public static Optional<DialectTableMetaDataLoader> newInstance(final DatabaseType databaseType) {
+ return TypedSPIRegistry.findRegisteredService(DialectTableMetaDataLoader.class, databaseType.getName());
+ }
+}
+```
+Here you can see that a static block is used, and all the `DialectTableMetaDataLoader` implementation classes are registered through `ShardingSphereServiceLoader.register` while class loading is in process. By using `TypedSPIRegistry.findRegisteredService`, we can get our specified spi extension class.
+
+```
+TypedSPIRegistry.findRegisteredService(final Class<T> spiClass, final String type)
+```
+So we just have to pay attention to `ShardingSphereServiceLoader.register` and `ypedSPIRegistry.findRegisteredService` approaches.
+
+**`ShardingSphereServiceLoader`**
+
+```java
+@NoArgsConstructor(access =AccessLevel.PRIVATE)
+public final class ShardingSphereServiceLoader {
+ private static final Map<Class<?>, Collection<object>> SERVICES = new ConcurrentHashMap<>();
+ /**
+ *Register service.
+ *
+ *@param serviceInterface service interface
+ */
+ public static void register(final Class<?> serviceInterface){
+ if (!SERVICES.containsKey(serviceInterface)) {
+ SERVICES.put(serviceInterface, load(serviceInterface) ) ;
+ }
+ }
+
+ private static <T> Collection<Object> load(final Class<T> serviceInterface) {
+ Collection<Object> result = new LinkedList<>();
+ for (T each: ServiceLoader. load(serviceInterface)) {
+ result.add(each);
+ }
+ return result;
+ }
+
+ /**
+ *Get singleton service instances.
+ *
+ *@param service service class
+ * @param <T> type of service
+ *@return service instances
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Collection<T> getSingletonServiceInstances(final Class<T> service) {
+ return (Collection<T>) SERVICES.getorDefault(service,Collections.emptyList());
+ }
+
+ /**
+ *New service instances.
+ *
+ * eparam service service class
+ *@param <T> type of service
+ *@return service instances
+ */
+ @SuppressWarnings ("unchecked" )
+ public static <T> Collection<T> newserviceInstances(final Class<T> service){
+ if(!SERVICES.containskey(service)) {
+ return Collections.emptyList();
+ }
+ Collection<object> services = SERVICES.get(service);
+ if (services.isEmpty()){
+ return Collections.emptyList();
+ }
+ Collection<T> result = new ArrayList<>(services.size());
+ for (Object each: services) {
+ result.add((T) newServiceInstance(each.getClass()));
+ }
+ return result;
+ }
+
+ private static Object newServiceInstance(final Class<?> clazz) {
+ try{
+ return clazz.getDeclaredConstructor( ) . newInstance( ) ;
+ } catch (final ReflectiveOperationException ex) {
+ throw new ServiceLoaderInstantiationException(clazz, ex);
+ }
+ }
+}
+```
+We can see that all SPI classes are placed in this `SERVICES`property.
+
+```java
+private static final Map<Class<?>, Collection<Object>> SERVICES = new ConcurrentHashMap<>();
+```
+
+
+And registering is pretty simple too, just use the SPI api embedded in java.
+
+```java
+public static void register(final Class<?> serviceInterface) {
+ if (!SERVICES.containsKey(serviceInterface)) {
+ SERVICES.put(serviceInterface, load(serviceInterface));
+ }
+ }
+private static <T> Collection<Object> load(final Class<T> serviceInterface) {
+ Collection<Object> result = new LinkedList<>();
+ for (T each : ServiceLoader.load(serviceInterface)) {
+ result.add(each);
+ }
+ return result;
+ }
+```
+**`TypedSPIRegistry`**
+
+The `findRegisteredService` method in `TypedSPIRegistry` is essentially a call to the `getSingletonServiceInstancesmethod` of the `ShardingSphereServiceLoader`.
+
+```java
+public static <T extends StatelessTypedSPI> Optional<T> findRegisteredService(final Class<T> spiClass, final String type) {
+ for (T each : ShardingSphereServiceLoader.getSingletonServiceInstances(spiClass)) {
+ if (matchesType(type, each)) {
+ return Optional.of(each);
+ }
+ }
+ return Optional.empty();
+ }
+private static boolean matchesType(final String type, final TypedSPI typedSPI) {
+ return typedSPI.getType().equalsIgnoreCase(type) || typedSPI.getTypeAliases().contains(type);
+ }
+```
+Here you can see that the class extension is using `getType` or `getTypeAliases` in `TypedSPI` to get a match, which is why each SPI needs to implement the `TypedSPI` interface.
+
+Now let’s see the `newServiceInstances` method in `ShardingSphereServiceLoader`
+
+```java
+public static <T> Collection<T> newServiceInstances(final Class<T> service) {
+ if (!SERVICES.containsKey(service)) {
+ return Collections.emptyList();
+ }
+ Collection<Object> services = SERVICES.get(service);
+ if (services.isEmpty()) {
+ return Collections.emptyList();
+ }
+ Collection<T> result = new ArrayList<>(services.size());
+ for (Object each : services) {
+ result.add((T) newServiceInstance(each.getClass()));
+ }
+ return result;
+ }
+```
+You can see that it is also very simple to find all implementations class returns of the interface directly in `SERVICES` registered through the static code block.
+
+Although short, this short walkthrough basically introduced ShardingSphere’s SPI source code. We’re sure that you have already noticed it’s much easier and simpler to work with ShardingSphere’s SPI than Dubbo's SPI mechanism.
+
+## Summary
+Both ShardingSphere and Dubbo’s SPIs meet the requirement of finding the specified implementation class by key, without having to reload all the implementation classes every time you use it, solving the concurrent loading problem. However, compared to Dubbo, the ShardingSphere SPI is more streamlined and easier to use.
+
+You can refer to the ShardingSphere implementation later on when writing your own SPI extensions, as it is simpler to implement, and elegant to work with. You can write an expandable configuration file parser based on SPI so that we can understand what SPI is capable of as well as its application scenarios.
+
+**Apache ShardingSphere Project Links:**
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
diff --git "a/docs/blog/content/material/2022_06_21_Heterogeneous_migration_reducing_Dangdang\342\200\231s_customer_system_RTO_60x_and_increasing_speed_by_20%.en.md" "b/docs/blog/content/material/2022_06_21_Heterogeneous_migration_reducing_Dangdang\342\200\231s_customer_system_RTO_60x_and_increasing_speed_by_20%.en.md"
new file mode 100644
index 00000000000..07ca575f588
--- /dev/null
+++ "b/docs/blog/content/material/2022_06_21_Heterogeneous_migration_reducing_Dangdang\342\200\231s_customer_system_RTO_60x_and_increasing_speed_by_20%.en.md"
@@ -0,0 +1,130 @@
++++
+title = "Heterogeneous migration: reducing Dangdang’s customer system RTO 60x and increasing speed by 20%"
+weight = 62
+chapter = true
++++
+
+> [Apache ShardingSphere](https://shardingsphere.apache.org/) helps [Dangdang](https://www.crunchbase.com/organization/dangdang-com) rebuild its customer system with 350 million users, and seamlessly transition from a [PHP](https://www.php.net/)+[SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-downloads) technology stack to a Java+ShardingSphere+[MySQL](https://www.mysql.com/) stack. The performance, availability, and maintainability of its customer system have been sig [...]
+
+## Dangdang’s customer system
+Dangdang’s customer system is mainly responsible for account registration, login, and privacy data maintenance. Its previous technology stack was based on PHP and SQL Server, which means a standard centralized architecture, as shown in the figure below.
+
+
+
+Before the rebuild project started, several business modules of the customer system had encountered multiple problems and technical challenges, such as logical decentralization, low throughput, and high operation & maintenance costs.
+
+To improve customers’ shopping experience, Dangdang’s technical team decided to optimize the business logic and underlying data architecture to achieve the availability, scalability, and comprehensive improvement of the customer system in multiple scenarios. The rebuild also introduced many technological innovations such as cross-data source double write, read/write splitting, intelligent gateway, and gray release.
+
+Dangdang’s technical team completed the system rebuild within half a year, from demand design, sharding planning, logic optimization, and stress testing to its official launch.
+
+The project used Java to reconstruct more than ten modules, build distributed database solutions through ShardingSphere & MySQL, and finally complete the online migration of heterogeneous databases. The project boasts the following highlights:
+
+- Reconstruct PHP business code using Java language.
+- Replace SQL Server with ShardingSphere & MySQL.
+- Complete online data migration of 350 million users.
+- Complete a seamless launch through the data double-write scheme.
+
+## Pain points & challenges
+
+**Business pain points**
+At the business level, the registration and login logic of some modules of the customer system was scattered at different ends. This resulted in high maintenance costs, and the old technical architecture was limited in terms of performance improvement and high availability.
+
+- **Maintenance difficulty:** the registration and login logic of multiple platforms is scattered, so business maintenance is complicated.
+- **Limited performance:** the PHP & SQL Server, a centralized technical architecture, had insufficient throughput.
+- **Poor availability and security:** If the active/standby status of SQL Server changes, the subscription database becomes invalid and the reconfiguration takes a window of time. The security of SQL Server running on Windows Server is poor due to viruses, and the upgrading takes a long time (>30min) after the patch is installed.
+
+**Challenges**
+
+- **Data integrity:** the customer system involves data of more than 350 million users. It is necessary to ensure data consistency and integrity after migrating from SQL Server to MySQL.
+- **API transparency:** the API is transparent to the caller to ensure that the caller does not change and to minimize the change of interface.
+- **Seamless switch:** the business system must be seamlessly switched over without impact on business.
+- **Time is short:** the system will be blocked before and after “[618 (aka JD.com Day)](https://edition.cnn.com/2020/06/18/tech/jd-618-china-coronavirus-intl-hnk/index.html) and [11.11 (aka Singles Day)](https://en.wikipedia.org/wiki/Singles%27_Day)” (two online shopping festivals in China), so we need to switch it between the two shopping promotions in a limited window of time, and then undergo the tests to prepare for the 11.11 shopping festival.
+
+## Solutions
+**Overall planning**
+To improve the maintainability, availability, and performance of the customer system, the R&D team reorganized the customer system architecture.
+
+At the application layer, the goal was to unify the function logic of all terminals and improve business maintainability.
+
+At the database layer, the centralized architecture was transformed into a distributed database architecture to improve performance and availability, which is exactly the open-source distributed solution built by ShardingSphere & MySQL.
+
+- **Application layer:** As Dangdang’s overall technology stack changed, its business development language changed from PHP to Java.
+- **Middleware:** As a mature open-source database middleware, ShardingSphere, was used to achieve data sharding.
+- **Database:** Multiple MySQL clusters were used to replace SQL Server databases.
+
+
+The overall architecture design introduced multiple schemes, such as distributed primary-key generation strategy, shard management, data migration verification, and gray release.
+
+## Distributed primary-key generation strategy
+
+Distributed primary-key generation strategy is the first problem to be solved if database architecture is to be transformed from a centralized architecture to a distributed one based on middleware.
+
+During the system rebuild, we chose to build two or more database ID-generating servers. Each server had a `Sequence` table that records the current `ID` of each table. The step size of `ID` that increases in the `Sequence` table is the number of servers. The starting values are staggered so that the ID generation is hashed to each server node.
+
+## Implementing sharding (Apache ShardingSphere）
+During the customer system rebuild, database sharding was completed through Apache ShardingSphere, and the read/write splitting function was also enabled.
+
+Due to the requirements of the customer system for high concurrency and low latency, the access end chose [ShardingSphere-JDBC](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-jdbc), which is positioned as a lightweight Java framework and provides additional services in Java’s JDBC layer.
+
+It connects directly to the database via the client and provides services in the form of a `jar` package without additional deployment and dependence. It can be viewed as an enhanced version of the JDBC driver, fully compatible with JDBC and various [ORM](https://www.techopedia.com/definition/24200/object-relational-mapping--orm) frameworks.
+
+
+
+**Sharding:** ShardingSphere supports a complete set of sharding algorithms, including `modulo` operation, `hash`, `range`, `time`, and customized algorithms. Customers use the `modulo` sharding algorithm to split large tables.
+**Read-write splitting:** in addition to Sharding, ShardingSphere’s read/write splitting function is also enabled to make full use of [MHA](https://myheroacademia.fandom.com/wiki/Cluster) cluster resources and improve system throughput capacity.
+
+
+
+## Double-write & data synchronization
+Data synchronization runs through the whole rebuild project, and the integrity and consistency of data migration are vital to the rebuild.
+
+This example periodically synchronizes SQL Server’s historical data to MySQL based on Elastic-Job synchronization. During the database switchover, a backup scheme is used to double-write the database to ensure data consistency. The process consists of:
+
+**Step 1:** implement the double-write mechanism
+
+Disconnect link 1, get through links 2, 3, 4, and then 9, 10.
+
+**Step 2:** switch the login service
+
+Disconnect links 9,10, get through link 7 and disconnect link 5.
+
+**Step 3:** switch read service
+
+Get through link 8 and disconnect link 6.
+
+**Step 4:** cancel the double-write mechanism
+
+Disconnect link 2 and complete the switchover.
+
+
+
+Data verification is performed periodically on both the service side and the database side. Different frequencies are used in different time periods to sample or fully check data integrity. `COUNT/SUM` is also verified on the database side.
+
+Customer system reconstruction adopts an apollo-based gray release. In the process of new login processing, configuration items are gradually released and sequential cutover within a small range is implemented to ensure the launch success rate. The rebuilt system architecture is shown in the following figure.
+
+
+
+## Advantages
+After the rebuild, the response speed of Dangdang’s customer system is significantly improved, and the daily operation & maintenance costs are also reduced.
+
+The distributed solution provided by ShardingSphere plays a big part in this. The solution is suitable for various high-traffic Internet platform services, as well as e-commerce platforms and other data-processing systems.
+
+- **Performance improvement:** response speed increased by more than 20%.
+- **High availability:** RTO is reduced to less than 30s owing to the ShardingSphere & MySQL design.
+- **Easy to maintain:** business logic and database maintainability are significantly improved.
+- **Seamless migration:** complete online cutover of each module within 6 months, and window time is zero.
+
+## Conclusion
+This is ShardingSphere’s second implementation by Dangdang, following the previous one we shared in the post “[Asia’s E-Commerce Giant Dangdang Increases Order Processing Speed by 30% — Saves Over Ten Million in Technology Budget with Apache ShardingSphere](https://shardingsphere.medium.com/asias-e-commerce-giant-dangdang-increases-order-processing-speed-by-30-saves-over-ten-million-113a976e0165)”.
+
+Apache ShardingSphere provides strong support for enterprise systems, as the project strives for simplicity and perfection, to achieve simpler business logic and maximum performance.
+
+**Apache ShardingSphere Project Links:**
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
\ No newline at end of file
diff --git a/docs/blog/content/material/2022_06_28_Cloud_native_deployment_for_a_high-performance_data_gateway_new API driver_Apache_ShardingSphere_5.1.2_is_released.en.md b/docs/blog/content/material/2022_06_28_Cloud_native_deployment_for_a_high-performance_data_gateway_new API driver_Apache_ShardingSphere_5.1.2_is_released.en.md
new file mode 100644
index 00000000000..7aae790320b
--- /dev/null
+++ b/docs/blog/content/material/2022_06_28_Cloud_native_deployment_for_a_high-performance_data_gateway_new API driver_Apache_ShardingSphere_5.1.2_is_released.en.md
@@ -0,0 +1,407 @@
++++
+title = "Cloud native deployment for a high-performance data gateway + new API driver: Apache ShardingSphere 5.1.2 is released"
+weight = 63
+chapter = true
++++
+
+Following the release of Apache ShardingSphere 5.1.1, our community integrated 1,028 PRs from contributors all over the world to bring you the latest 5.1.2 version. The new version includes a lot of improvements in terms of functions, performance, tests, documentation, examples, etc.
+
+Standout new features include:
+
+- ShardingSphere-Proxy Helm Chart.
+- SQL dialect translation.
+- Using ShardingSphere-JDBC as a Driver.
+
+These new capabilities boosted ShardingSphere’s data gateway capability, enabling ShardingSphere to be deployed on the cloud while optimizing user experience.
+
+In addition to the above-mentioned new features, this update also improves SQL parsing support, kernel, runtime mode, and elastic scaling support for [PostgreSQL](https://www.postgresql.org/) / [openGauss](https://opengauss.org/en/) schema, auto-scaling, transactions, and [DistSQL](https://medium.com/nerd-for-tech/intro-to-distsql-an-open-source-more-powerful-sql-bada4099211) in terms of user experience.
+
+This post will give you an overview of the ShardingSphere 5.1.2 updates.
+
+## New Features
+**ShardingSphere-Proxy configuration using Helm**
+ShardingSphere-Proxy provides Docker images for deployment in containers. However, for those who need to deploy ShardingSphere-Proxy on [Kubernetes](https://kubernetes.io/), you have to go through some procedures such as database driver mounting, configuration mounting, custom algorithm mounting, etc., which make the deployment process relatively tedious and causes high operation & maintenance costs.
+
+This update brings the new ShardingSphere-Proxy Helm Chart, a new feature donated to the Apache ShardingSphere community by [SphereEx](https://www.sphere-ex.com/), a provider of enterprise-grade, cloud-native data-enhanced computing products, and solutions. This development allows Apache ShardingSphere to embrace ahead cloud-native computing.
+
+
+
+ShardingSphere relies on a registry to store metadata in cluster mode, and ShardingSphere-Proxy’s Helm Chart can automatically deploy ZooKeeper clusters allowing you to quickly build ShardingSphere-Proxy clusters.
+
+Due to the limits imposed by open source protocol, ShardingSphere-Proxy’s binary distribution package and Docker image are not packaged with MySQL JDBC driver, so users need to manually add the MySQL JDBC driver to the classpath to use MySQL as ShardingSphere’s storage node.
+
+For such cases, ShardingSphere-Proxy Helm Chart can automatically obtain the MySQL JDBC driver in the Pod’s Init container, reducing your deployment operation costs.
+
+**SQL dialect translation**
+With increased database diversification, the coexistence of multiple types of databases is now the norm. The scenarios in which heterogeneous databases are accessed using one SQL dialect are becoming a trend.
+
+The existence of multiple diversified databases makes it difficult to standardize SQL dialects for accessing databases, meaning that engineers need to use different dialects for different types of databases - lacking a unified query platform.
+
+Automatically translating different types of database dialects into one dialect that can be used by back-end databases allows engineers to access all back-end heterogeneous databases using any one database dialect, significantly reducing development and maintenance costs.
+
+Apache ShardingSphere 5.1.2 is an important step to building a highly productive data gateway. This update enables a new SQL dialect translation capability that supports dialect conversion between major open source databases.
+
+For example, you can use a [MySQL](https://www.mysql.com/) client to connect to ShardingSphere-Proxy and send SQL based on MySQL dialect, and ShardingSphere can automatically recognize the user protocol and storage node type to complete SQL dialect translation, accessing heterogeneous storage nodes such as PostgreSQL and vice versa.
+
+
+
+## Using ShardingSphere-JDBC as Driver
+In past versions, ShardingSphere-JDBC was available for users in the form of `Datasource`. Projects or tools that do not use `Datasource`, previously would need to first be modified in order to be able to introduce ShardingSphere-JDBC, which increases development costs.
+
+In Apache ShardingSphere 5.1.2, ShardingSphere-JDBC implements the standardized JDBC Driver interface, which allows you to introduce ShardingSphere-JDBC as a Driver.
+
+Users can obtain `Connection` directly through `DriverManager`:
+
+```java
+Class.forName("org.apache.shardingsphere.driver.ShardingSphereDriver");
+Connection conn = DriverManager.getConnection("jdbc:shardingsphere:classpath:config.yaml");
+```
+
+Or use `Datasource` to obtain `Connection`:
+
+```java
+// Take HikariCP as an example
+HikariDataSource dataSource = new HikariDataSource();
+dataSource.setDriverClassName("org.apache.shardingsphere.driver.ShardingSphereDriver");
+dataSource.setJdbcUrl("jdbc:shardingsphere:classpath:config.yaml");
+Connection conn = dataSource.getConnection();
+```
+
+## Optimizations of the existing capabilities
+**Kernel**
+In this update, ShardingSphere merged lots of PRs to improve SQL parsing support. SQL parsing optimizations take up a large proportion of the update log.
+
+ShardingSphere provided preliminary support for PostgreSQL / openGauss schema in 5.1.1.
+
+In this 5.1.2 update, the kernel, cluster mode, and auto-scaling support for PostgreSQL / openGauss schema has been improved. For example, support for schema structure has been added to metadata pairs, and schema customization is also supported in kernel and auto-scaling.
+
+**ShardingSphere-Proxy**
+As the market for servers using ARM CPUs becomes more popular, ShardingSphere-Proxy also provides images for arm64 architecture on Docker as well.
+
+When it comes to MySQL, ShardingSphere-Proxy fixed the issue where packets longer than 8 MB could not be received, and further supports receiving data larger than 16 MB in total.
+
+**Auto-scaling**
+In addition to supporting PostgreSQL schema customization, auto-scaling also implements automatic table creation when migrating PostgreSQL, and fixes the problem where PostgreSQL incremental migration would report errors when encountering null fields values. In addition to these features, auto-scaling also reduces resource consumption during migration and provides support for incremental migration in openGauss 3.0.
+
+## Release notes
+The full release note for ShardingSphere 5.1.2 can be found in the following sections. Note that this update adjusts a small number of APIs, so please refer to the API Adjustments section for more details.
+
+**New Features**
+Kernel: alpha version of SQL dialect conversion for MySQL and PostgreSQL.
+
+Kernel: Support for PostgreSQL and openGauss custom schema.
+
+Kernel: Support for PostgreSQL and openGauss `create`/`alter`/`drop` view statements.
+
+Kernel: support for openGauss cursor statements.
+
+Kernel: support for using system libraries customization.
+
+Kernel: support acquisition of openGauss and MySQL create table statements.
+
+Kernel: support acquisition of PostgreSQL create table statements.
+
+Access terminal: officially support rapid deployment of a ShardingSphere-Proxy cluster that includes a ZooKeeper cluster in Kubernetes using Helm.
+
+Access terminal: support for ShardingSphere JDBC Driver.
+
+Auto Scaling: support for PostgreSQL automatic table building.
+
+Auto Scaling: support for PostgreSQL and openGauss custom schema table migration.
+
+Auto Scaling: support migration of string primary key table.
+
+Operation mode: Governance Center supports PG/openGauss three-level structure.
+
+Operation mode: Governance Center supports Database level distributed locking.
+
+**Optimization**
+Kernel: support for PostgreSQL and openGauss copy statements.
+
+Kernel: support for PostgreSQL alter/ drop index statements.
+
+Kernel: support for MySQL update force index statements.
+
+Kernel: support for openGauss `create`/`alter`/`drop` schema statements.
+
+Kernel: optimize `RoundRobinReplicaLoadBalanceAlgorithm` and `RoundRobinTrafficLoadBalanceAlgorithm` algorithm logic.
+
+Kernel: optimize metadata loading logic when front-end driver database type and back-end do not match.
+
+Kernel: refactor metadata loading logic.
+
+Kernel: optimization of show processlist statement function.
+
+Kernel: improved loading performance in scenarios involving a large number of tables.
+
+Kernel: support for comment statement execution
+
+Kernel: support for view statement execution in PostgreSQL and openGauss sharding scenarios.
+
+Kernel: support for Oracle `CREATE ROLLBACK SEGMENT` statement.
+
+Kernel: support for parsing openGauss `DROP TYPE`
+
+Kernel: support for parsing openGauss `ALTER TYPE`
+
+Kernel: support for parsing Oracle `DROP DISKGROUP`
+
+Kernel: support for parsing Oracle `CREATE DISKGROUP`
+
+Kernel: support for parsing Oracle `DROP FLASHBACK ARCHIVE`
+
+Kernel: support parsing openGauss `CHECKPOINT`
+
+Kernel: support parsing Oracle `CREATE FLASHBACK ARCHIVE`
+
+Kernel: support parsing PostgreSQL `Close`
+
+Kernel: support parsing openGauss `DROP CAST`
+
+Kernel: support parsing openGauss `CREATE CAST`
+
+Kernel: support parsing Oracle `CREATE CONTROL FILE`
+
+Kernel: support parsing openGauss `DROP DIRECTORY`
+
+Kernel: support parsing openGauss `ALTER DIRECTORY`
+
+Kernel: support parsing openGauss `CREATE DIRECTORY`
+
+Kernel: support parsing PostgreSQL Checkpoint
+
+Kernel: support parsing openGauss `DROP SYNONYM`
+
+Kernel: support parsing openGauss `CREATE SYNONYM`
+
+Kernel: support parsing openGauss `ALTER SYNONYM`
+
+Kernel: support parsing PostgreSQL `CALL` statement
+
+Kernel: support parsing Oracle `CREATE PFILE`
+
+Kernel: support parsing Oracle `CREATE SPFILE`
+
+Kernel: support parsing Oracle `ALTER SEQUENCE`
+
+Kernel: support parsing Oracle `CREATE CONTEXT`
+
+Kernel: support for parsing Oracle `ALTER PACKAGE`
+
+Kernel: support for parsing Oracle `CREATE SEQUENCE`
+
+Kernel: support for parsing Oracle `ALTER ATTRIBUTE DIMENSION`
+
+Kernel: support for parsing Oracle `ALTER ANALYTIC VIEW`
+
+Kernel: loading `SQLVisitorFacade` with ShardingSphere Spi
+
+Kernel: loading `DatabaseTypedSQLParserFacade` with ShardingSphere Spi
+
+Kernel: support parsing Oracle `ALTER OUTLINE`
+
+Kernel: support parsing Oracle `DROP OUTLINE`
+
+Kernel: support parsing Oracle `drop edition`
+
+Kernel: support parsing SQLServer `WITH` Common Table Expression
+
+Kernel: optimize SubquerySegment’s start and end indexes in with statements
+
+Kernel: reconstructing `JoinTableSegment`
+
+Kernel: support parsing Oracle `DROP SYNONYM`
+
+Kernel: support parsing Oracle `CREATE DIRECTORY`
+
+Kernel: support parsing Oracle `CREATE SYNONYM
+`
+Kernel: support parsing SQLServer `XmlNamespaces` clause
+
+Kernel: support parsing Oracle `Alter Database Dictionary`
+
+Kernel: support parsing SQLServer clause of `SELECT` statement
+
+Kernel: support parsing Oracle `ALTER DATABASE LINK`
+
+Kernel: support for parsing Oracle `CREATE EDITION`
+
+Kernel: support parsing Oracle `ALTER TRIGGER`
+
+Kernel: support parsing SQLServer `REVERT` statement
+
+Kernel: support parsing PostgreSQL `DROP TEXT SEARCH`
+
+Kernel: support parsing PostgreSQL `drop server`
+
+Kernel: support parsing Oracle `ALTER VIEW`
+
+Kernel: support parsing PostgreSQL `drop access method`
+
+Kernel: support parsing PostgreSQL `DROP ROUTINE`
+
+Kernel: support parsing SQLServer `DROP USER`
+
+Kernel: support parsing Oracle `DROP TRIGGER`
+
+Kernel: support parsing PostgreSQL `drop subscription`
+
+Kernel: support parsing PostgreSQL `drop operator class`
+
+Kernel: support parsing PostgreSQL `DROP PUBLICATION`
+
+Kernel: support parsing Oracle `DROP VIEW`
+
+Kernel: support parsing PostgreSQL `DROP TRIGGER
+`
+Kernel: support parsing Oracle `DROP DIRECTORY`
+
+Kernel: support parsing PostgreSQL `DROP STATISTICS`
+
+Kernel: support parsing PostgreSQL `drop type`
+
+Kernel: support parsing PostgreSQL `DROP RULE`
+
+Kernel: support parsing SQLServer `ALTER LOGIN`
+
+Kernel: support parsing PostgreSQL `DROP FOREIGN DATA WRAPPER`
+
+Kernel: support parsing PostgreSQL `DROP EVENT TRIGGER` statement.
+
+Access Terminal: ShardingSphere-Proxy MySQL supports receiving request packets over 16 MB in size.
+
+Access Terminal: ShardingSphere-Proxy adds `SO_BACKLOG` configuration item.
+
+Access Terminal: ShardingSphere-Proxy `SO_REUSEADDR` is enabled by default.
+
+Access Terminal: ShardingSphere-Proxy Docker image with aarch64 support.
+
+Access Terminal: ShardingSphere-Proxy MySQL support default MySQL version number.
+
+Access Terminal: ShardingSphere-Proxy PostgreSQL /openGauss supports more character sets.
+
+Access Terminal: ShardingSphere-Proxy adds default port configuration items.
+
+Auto Scaling: scaling is compatible with the HA port for data synchronization when thread_pool is enabled in openGauss 3.0.
+
+Auto Scaling: optimize the logic of Zookeeper event handling in `PipelineJobExecutor` to avoid zk blocking events.
+
+Auto Scaling: scaling data synchronization is case-insensitive for table names.
+
+Auto Scaling: improved PostgreSQL/openGauss replication slot cleanup.
+
+Auto Scaling: improved lock protection in preparation phase
+
+Auto Scaling: improve data synchronization in PostgreSQL rebuild scenarios after the same record is deleted.
+
+Auto Scaling: data sources created by scaling are not cached at the bottom.
+
+Resilient Scaling: reuse data sources as much as possible to reduce database connection occupancy.
+
+DistSQL: `REFRESH TABLE METADATA` supports specified PostgreSQL’s schema.
+
+DistSQL: add check for binding tables under `ALTER SHARDING TABLE RULE`
+
+Operational mode: ShardingSphere-JDBC support for configuring database connection names.
+
+Distributed transactions: prohibit DistSQL execution in transactions.
+
+Distributed transaction: autocommit = 0, DML will automatically open transaction in DDL part.
+
+## Bug fixes
+Kernel: fix PostgreSQL and openGauss show statement parsing exceptions.
+
+Kernel: fix PostgreSQL and openGauss time extract function parsing exceptions.
+
+Kernel: fix PostgreSQL and openGauss select mod function parsing exceptions.
+
+Kernel: fix the execution exception of multiple schema join statements in read/write separation scenario.
+
+Kernel: fix exception in execution executing create schema statement in encryption scenario.
+
+Kernel: fix drop schema if exist statement exception.
+
+Kernel: fix routing error with `LAST_INSERT_ID()`
+
+Kernel: fix use database execution exception in no data source state.
+
+Kernel: fix function creation statement with set var.
+
+Access: fix null pointer caused by field case mismatch in ShardingSphere-Proxy PostgreSQL /openGauss `Describe PreparedStatement`
+
+Access: fix ShardingSphere-Proxy PostgreSQL /openGauss not returning to correct tag after schema DDL execution.
+
+Auto Scaling: fix MySQL unsigned type error in the scaling process.
+
+Auto Scaling: fix a connection leak problem when the consistency check fails to create a data source.
+
+Auto Scaling: fixes an issue where `ShardingSphereDataSource` initialization process ignores rules other than sharding.
+
+Auto-scaling: support for jobs being closed in the preparation phase.
+
+Auto-scaling: fixes data source url and jdbcurl compatibility issues.
+
+Auto-scaling: fixes creation timing issues of openGauss data replication to avoid possible incremental data loss.
+
+Auto-scaling: improve job state persistence to ensure that special cases are not overwritten with the old state.
+
+Auto-scaling: fix PostgreSQL’s inability to correctly resolve null when using TestDecoder for incremental migration.
+
+DistSQL: fix `SET VARIABLE` changes not taking effect in standalone and in-memory modes.
+
+DistSQL: fix the problem where `SHOW INSTANCE LIST` is not consistent with actual data.
+
+DistSQL: fix the case-sensitive problem in sharding rules.
+
+Run mode: fix the problem of metadata missing in the new version after the scaling feature changes the table splitting rules.
+
+Distributed transaction: fix the problem that `indexinfo` obtained according to catalog is empty.
+
+## Refactoring
+Auto-scaling: refactoring `jobConfig` to facilitate reuse and extension of new types of jobs.
+
+Run mode: optimize the storage structure of compute nodes in the registry center.
+
+Run mode: use `uuid` to substitute `ip@port` as a unique instance identifier.
+
+## API Adjustments
+DistSQL: `EXPORT SCHEMA CONFIG` is adjusted to `EXPORT DATABASE CONFIG`
+
+DistSQL: `IMPORT SCHEMA CONFIG` is adjusted to `IMPORT DATABASE CONFIG`
+
+Run mode: Adjust `db-discovery` algorithm configuration.
+
+DistSQL: `SHOW SCHEMA RESOURCES` is adjusted to `SHOW DATABASE RESOURCES`
+
+DistSQL: `COUNT SCHEMA RULES` is adjusted to `COUNT DATABASE RULES`
+
+Permissions: permission provider `ALL_PRIVILEGES_PERMITTED` updated to `ALL_PERMITTED`
+
+Permissions: Permissions provider `SCHEMA_PRIVILEGES_PERMITTED` updated to `DATABASE_PERMITTED`
+
+## Community shoutout
+Thanks to the efforts made by the 54 ShardingSphere contributors, who submitted a total of 1028 PRs, to make the ShardingSphere 5.1.2 release possible.
+
+
+
+**Relevant links:**
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere twitter
+](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
+
+[Download Link](https://shardingsphere.apache.org/document/current/cn/downloads/)
+
+[Release Notes](https://github.com/apache/shardingsphere/blob/master/RELEASE-NOTES.md)
+
+## Author
+**Weijie Wu**
+
+**SphereEx Infrastructure R&D Engineer, Apache ShardingSphere PMC**
+
+Weijie focuses on the R&D of Apache ShardingSphere’s Access Terminal and ShardingSphere’s subproject [ElasticJob](https://shardingsphere.apache.org/elasticjob/).
diff --git a/docs/blog/content/material/2022_06_30_ShardingSphere_&_Database_Mesh.en.md b/docs/blog/content/material/2022_06_30_ShardingSphere_&_Database_Mesh.en.md
new file mode 100644
index 00000000000..1928ede9f65
--- /dev/null
+++ b/docs/blog/content/material/2022_06_30_ShardingSphere_&_Database_Mesh.en.md
@@ -0,0 +1,128 @@
++++
+title = "ShardingSphere & Database Mesh"
+weight = 64
+chapter = true
++++
+
+Some time ago, [SphereEx](https://www.sphere-ex.com/en/), a startup formed by [Apache ShardingSphere](https://shardingsphere.apache.org/)’s core contributor team, officially launched the [Database Mesh 2.0](https://faun.pub/database-mesh-2-0-database-governance-in-a-cloud-native-environment-ac24080349eb) concept and its associated open source solution “Pisanix”, sparking discussion and reflection in the community about ShardingSphere and Database Mesh.
+
+Some community users might be wondering why would you go through the trouble of
+starting from scratch in a new field when you’re already part of a successful open source project like Apache ShardingSphere? Another question that can come to mind is whether with the cloud-native trend, ShardingSphere will gradually be incorporated into the Database Mesh concept in the future?
+
+With the introduction of the Database Mesh 2.0 concept, SphereEx has charted a different course for open source development, seemingly in conflict with the already successful ShardingSphere, but in reality, the two complement each other while being interdependent.
+
+This post will focus on the ShardingSphere community’s views of the Database Mesh concept, and the future development path and will walk you through the guiding philosophy of Apache ShardingSphere, Database Plus, and how it’s related to the Database Mesh concept.
+
+## What changed from microservices governance to service governance under cloud-native databases?
+
+Compared with microservices, cloud-native database governance has a different focus in terms of feature selection.
+
+First, databases have status and requests that cannot be routed to peer nodes at will as happens with services, making data sharding important for databases. Since database connections are inherently related to the status, starting or stopping a new database instance often means data synchronization and replication, making the ability to auto-discover instances less important compared to microservices.
+
+If the database is viewed as a microservice, although database access can be governed via Service Mesh, it is still subjected to many limitations. At the same time, databases have some special governance attributes, like communication protocols, resource management, load balancing based on data requests, database, and table splitting, observability, access control, etc., all of which cannot be simply understood and solved just by applying the concept of service, and must rely on database [...]
+
+Hence the development of Database Mesh. SphereEx put forward the Database Mesh 2.0 concept which focuses on how to achieve the following goals in a cloud-native environment:
+
+1. Reduce the burden on developers, improve development efficiency, and provide a transparent and seamless experience when using the database infrastructure.
+2. Implement a governance framework covering database traffic, runtime resources, and stability guarantees in a way that is easier to configure, plug, and program.
+3. Provide a standard user interface for typical scenarios in multiple database domains such as heterogeneous data sources, cloud-native databases, and distributed databases.
+4. Provide capabilities such as data sharding, load balancing, observability, auditing, etc., which have helped solve some traffic governance problems in database governance.
+
+Recently, when business applications started to be packaged and delivered in containers and to be released numerous times every day to Kubernetes infrastructures in various data centers using CI/CD streams, we couldn’t help but think about how to implement database reliability engineering in cloud environments and finally came up with Database Mesh 2.0.
+
+## The difference between ShardingSphere’s Database Plus and Database Mesh
+
+**First, the philosophy is different. In fact, judging from their principles and concepts, Database Plus and Database Mesh are quite different.**
+
+When it comes to Database Mesh, SphereEx believes that cloud-native database governance has some common ground but also possesses its own uniqueness. The common issues can be solved by standardization and automation, while the unique ones can be solved by providing a flexible scaling mechanism that allows engineers to configure and implement on-demand. This requires a high capacity for programming in order to meet scaling requirements when addressing database governance challenges on the cloud.
+
+As for Database Plus, the Apache ShardingSphere community sees it as a design for a distributed database system that aims to build an overall ecosystem including fragmented heterogeneous databases, providing global scalability and overlay computational capabilities on the premise of maximizing the native computational capabilities of the database. It makes the interaction between applications and databases directed by the standards built by Database Plus, shielding the impact database fr [...]
+
+With the inevitable trend of cloud-native databases, Database Mesh and Database Plus are bound to have some overlap. In a cloud-native and distributed database scenario, there will be more interactions between ShardingSphere and Database Mesh.
+
+**Second, application scenarios are different too.**
+
+ShardingSphere, guided by the Database Plus concept, is primarily used in distributed database scenarios, while Database Mesh is primarily implemented to guide more specific practices for database reliability in cloud-native scenarios.
+
+Being two different designs in two different domains, Database Plus and Database Mesh both represent innovative ideas in their respective data governance scenarios, leading to the creation of the two open-source solutions ShardingSphere and [Pisanix](https://github.com/database-mesh/pisanix).
+
+Database Mesh 2.0 aspires to provide a database-centered governance framework:
+
+1. Databases as a priority: all actions revolve around database governance, such as access control, traffic governance, observability, etc.
+2. Engineer-oriented experience: developers, can work on convenient and easy-to-use database declarations and definitions, without caring about the database location. For maintenance & operations teams and DBAs, multiple abstract methods for database governance are provided to automate database reliability engineering.
+3. Cloud-native: suitable for different cloud environments with an open ecosystem and implementation mechanism, to build and achieve cloud-native orientation without worrying about vendor lock-in.
+
+On the other hand, with the prospect of achieving connectivity, enhancement, and pluggability, Database Plus aims to build a computing ecosystem on top of fragmented heterogeneous databases to solve the problems of local architecture selection, technology and maintenance & operation high complexity, lack of standards in the databases’ upper layer, and lack of coordination and management among databases.
+
+In a nutshell, Apache ShardingSphere, a project guided by the Database Plus concept, is of great practical value for distributed database scenarios while Database Mesh is the ideal solution for difficulties in database governance in cloud-native scenarios.
+
+**Finally, the business scenarios and demands are different**
+
+From relational databases to distributed databases, multiple database coexistence for enterprise applications has become the norm as application scenarios keep expanding and database performance varies in different scenarios.
+
+Fragmentation is the trend since one single database category cannot be applied to all scenarios. Driven by business scenarios, the use of distributed database solutions has achieved industry consensus, to cope with heavy traffic, higher concurrency, and increasing pressure on the database.
+
+In different scenarios and from different user perspectives, developers are more concerned about operational efficiency, cost overhead, and database protocol types and access information, not so much about where the data is stored. Maintenance & operations teams and DBAs are more concerned about automation, stability, security, monitoring and alerting of database services, etc.
+
+Additionally, DBAs also pay attention to data changes, capacity, secure access, backup, migration, etc. It is the deep understanding of database governance scenarios and the pursuit for a better user experience that together gave birth to the core idea of Database Mesh 2.0: to achieve high performance scaling through programming, and meet the challenges of database governance on the cloud.
+
+## With cloud-native applications booming: will there be a disconnect between ShardingSphere and the cloud?
+
+Back in 2018, when Service Mesh was gaining traction, Apache ShardingSphere PMC Chair Zhang Liang had already taken advantage of Service Mesh and proposed the Database Mesh concept, envisioning whether there was a model that could effectively combine the advantages of JDBC and Proxy clients while avoiding their disadvantages to achieve a true cloud-based infrastructure with auto-scaling + zero intrusion + decentralization. The ShardingSphere Sidecar was the solution born during Database [...]
+
+As distributed approaches and cloud-native went on to become the trend, ShardingSphere, with characteristics of being a community-oriented, open-source project, must keep up with rapid changes happening in different business operations and different scenarios. It has therefore undergone a transformation from Sharding-JDBC to ShardingSphere, changing not only its name but also its positioning and technological ecosystem construction.
+
+**Is Pisanix a cloud-based version of ShardingSphere rewritten in Rust and Go?**
+
+Recently, SphereEx introduced Pisanix, an open source solution for Database Mesh. As for Pisa-Proxy, the core component of Pisanix for database traffic, it shares similarities with ShardingSphere-Proxy making it easy to think of these two as a result of refactoring.
+
+Of course, it is not just Pisanix and ShardingSphere-Proxy, but all MySQL database proxies have a similar architectural design. Especially in regards to databases, there is a certain amount of similarity. The key is to find differences between products. For Pisanix and ShardingSphere-Proxy, they differ in what you want to achieve when you get the data and what problems you want to solve.
+
+Therefore, Pisanix cannot simply be considered a rewrite of ShardingSphere with Rust. They are completely different, except at the entry point because there are always similarities when it comes to databases.
+
+
+
+On the other hand, many users will naturally identify Database Mesh and ShardingSphere-Sidecar as the same thing. However, the two are very different at the kernel level.
+
+As an implementation of the Database Mesh concept, Pisanix is now able to take on some of the data governance capabilities of the original ShardingSphere-Sidecar in a cloud-native environment, making it easy for users to use ShardingSphere in a cloud-based environment.
+
+Sidecar does not serve as the kernel of Database Mesh, which must be oriented towards a specific, engineering-related problem, and Sidecar is just one of the forms of deployment Database Mesh concept. It is possible that one-day Pisanix-Proxy will not be structured as Sidecar, or that it evolves into a very thin middle layer. All in all, Sidecar is just a means to achieve governance capabilities.
+
+Database Mesh’s real core focuses on the expansion of user experience and database service governance. If more database types are available in the future and more scenarios, both cloud-based and off the cloud, emerge, the concept of Database Mesh will also be further expanded, which is exactly what Database Mesh is aiming at.
+
+What Database Mesh wants to do is to block out various factors on the cloud, and unify the various behaviors of the upper layer database to govern. However, protocols and maintenance & operation properties of different databases are quite different, so the tricky part lies in whether we can abstract a standard governance behavior.
+
+The technical solution itself is one of many choices, but the essential part is always the user experience. Whether to choose Java or Rust or Python is only one part of the technical solution, with the objective being the vitality of the project and its ecosystem, which must be considered carefully.
+
+## A glance at the future of databases: ShardingSphere + Database Mesh +….
+
+## Can Database Mesh govern ShardingSphere?
+If you think of ShardingSphere as a high-performance distributed database, governing ShardingSphere is the same as governing MySQL, TiDB, and other databases for Database Mesh.
+
+So while it can be governed, ShardingSphere itself does not necessarily require support as its design concept, Database Plus, is to enhance those capabilities that MySQL itself does not inherently possess through connectivity, enhancement, and pluggability. Through ShardingSphere, a native database can be combined with the underlying database to deploy more computing power on the application side, turning it into a high-performance distributed database that avoids wasting resources and p [...]
+
+## Opportunities in cloud-native scenarios
+Next, let’s take a look at the industry. As we all know, the cloud represents the future, the irreversible direction. Therefore, whether a project, a product, or an idea can serve this cause will directly affect its lifecycle and impact. This is why ShardingSphere is so committed to its cloud-based initiatives.
+
+Guided by the Database Plus concept, Apache ShardingSphere can extend existing features to provide enterprises and cloud computing platforms with more powerful capabilities across different database products. The underlying compatibility with multiple databases and with all kinds of database products in the cloud makes R&D tasks seamless.
+
+Maintaining its neutral position, ShardingSphere can also ensure that the cloud experience is the same as the experience with local operations, supporting multi-cloud architectures and providing the same experience in different cloud infrastructures, which is precisely what ShardingSphere is good at in cloud-native scenarios.
+
+As two completely independent design philosophies, Database Plus and Database Mesh are not in competition with each other. On the contrary, Database Mesh and Database Plus can work well with each other.
+
+Both can provide solutions based on the existing fragmented ecosystem of databases and major issues that users are facing. Despite their different approaches, they both represent the best ways to solve data governance problems in different scenarios.
+
+**Relevant links:**
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
+
+[Download Link](https://shardingsphere.apache.org/document/current/cn/downloads/)
+
+[Database Mesh](https://www.database-mesh.io/)
+
+[Pisanix Project](https://github.com/database-mesh/pisanix)
\ No newline at end of file