You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ji...@apache.org on 2023/03/27 03:36:04 UTC
[shardingsphere] branch master updated: Some small fixes to recent Blogs and upload another 2 (#24851)
This is an automated email from the ASF dual-hosted git repository.
jianglongtao 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 8b4697f6dc5 Some small fixes to recent Blogs and upload another 2 (#24851)
8b4697f6dc5 is described below
commit 8b4697f6dc58dc63f82d6f95629973da1fbef528
Author: FPokerFace <11...@users.noreply.github.com>
AuthorDate: Mon Mar 27 11:35:52 2023 +0800
Some small fixes to recent Blogs and upload another 2 (#24851)
---
...QL_Syntax__ShardingSphere_5.3.0_Deep_Dive.en.md | 20 +-
...re_Proxy_High_Availability_Cluster_on_AWS.en.md | 14 +-
..._Based_on_ShardingSphere_Demo_&_User_Case.en.md | 16 +-
...y_Database Protocol_Interaction_Explained.en.md | 251 +++++++++++++++
..._Update_Spring_Configuration_Update_Guide.en.md | 358 +++++++++++++++++++++
...xy_Database Protocol_Interaction_Explained1.png | Bin 0 -> 124621 bytes
...y_Database Protocol_Interaction_Explained10.png | Bin 0 -> 252614 bytes
...y_Database Protocol_Interaction_Explained11.png | Bin 0 -> 154791 bytes
...y_Database Protocol_Interaction_Explained12.png | Bin 0 -> 44339 bytes
...y_Database Protocol_Interaction_Explained13.png | Bin 0 -> 74390 bytes
...y_Database Protocol_Interaction_Explained14.png | Bin 0 -> 207320 bytes
...xy_Database Protocol_Interaction_Explained2.png | Bin 0 -> 130283 bytes
...xy_Database Protocol_Interaction_Explained3.png | Bin 0 -> 85514 bytes
...xy_Database Protocol_Interaction_Explained4.png | Bin 0 -> 84469 bytes
...xy_Database Protocol_Interaction_Explained5.png | Bin 0 -> 115578 bytes
...xy_Database Protocol_Interaction_Explained6.png | Bin 0 -> 76210 bytes
...xy_Database Protocol_Interaction_Explained7.png | Bin 0 -> 138770 bytes
...xy_Database Protocol_Interaction_Explained8.png | Bin 0 -> 45125 bytes
...xy_Database Protocol_Interaction_Explained9.png | Bin 0 -> 230186 bytes
...x_Update_Spring_Configuration_Update_Guide1.png | Bin 0 -> 20278 bytes
20 files changed, 634 insertions(+), 25 deletions(-)
diff --git a/docs/blog/content/material/2023_01_04_Refactoring_the_DistSQL_Syntax__ShardingSphere_5.3.0_Deep_Dive.en.md b/docs/blog/content/material/2023_01_04_Refactoring_the_DistSQL_Syntax__ShardingSphere_5.3.0_Deep_Dive.en.md
index 20e5c79d87b..b5f20311bda 100644
--- a/docs/blog/content/material/2023_01_04_Refactoring_the_DistSQL_Syntax__ShardingSphere_5.3.0_Deep_Dive.en.md
+++ b/docs/blog/content/material/2023_01_04_Refactoring_the_DistSQL_Syntax__ShardingSphere_5.3.0_Deep_Dive.en.md
@@ -10,7 +10,7 @@ chapter = true
[DistSQL (Distributed SQL)](https://shardingsphere.apache.org/document/5.1.0/en/concepts/distsql/) is ShardingSphere's SQL-like functional language. Since we released[ version 5.0.0-Beta](https://shardingsphere.apache.org/blog/en/material/ss_5.0.0beta/), we've been iterating rapidly and providing users with features including rule management, cluster management, and metadata management. It was an incremental improvement process including many steps.
-At the same time, DistSQL is still releatively young. The[ ShardingSphere](https://shardingsphere.apache.org/) community often receives fresh ideas and suggestions about DistSQL, which means fast growth with lots of possible different development directions.
+At the same time, DistSQL is still releatively young. The [ShardingSphere](https://shardingsphere.apache.org/) community often receives fresh ideas and suggestions about DistSQL, which means fast growth with lots of possible different development directions.
Before releasing [version 5.3.0](https://medium.com/faun/shardingsphere-5-3-0-is-released-new-features-and-improvements-bf4d1c43b09b?source=your_stories_page-------------------------------------), our community refactored DistSQL systematically and optimized its syntax. This blog post will illustrate those adjustments one by one.
@@ -92,7 +92,7 @@ The new release 5.3.0 has upgraded DistSQL. We have completely sorted out and re

-*Description: keyword* `INSTANCE` *is updated to* `COMPUTE NODE`*.*
+*Description: keyword* `INSTANCE` *is updated to* `COMPUTE NODE`.
**Storage Node**
@@ -100,7 +100,7 @@ The new release 5.3.0 has upgraded DistSQL. We have completely sorted out and re
*Description:*
-*Keyword* `RESOURCE` *is updated to* `STORAGE NODE / STORAGE UNIT`*, which corresponds to instance-level storage and database-level storage respectively.*
+*Keyword* `RESOURCE` *is updated to* `STORAGE NODE / STORAGE UNIT`, *which corresponds to instance-level storage and database-level storage respectively*.
*The* `STORAGE NODE` *is reserved and is not used currently.*
@@ -122,7 +122,7 @@ Global rule syntax is not adjusted this time.
*Description:*
-`PROCESS CONFIGURATION` *keyword is changed to* `RULE`*.*
+`PROCESS CONFIGURATION` *keyword is changed to* `RULE`.
*Remove* `CREATE` *and* `DROP` *operations because* `MIGRATION RULE` *has default values.*
@@ -134,7 +134,7 @@ Global rule syntax is not adjusted this time.
*Description:*
-`CONFIG` *is changed to* `CONFIGURATION`*, which is more accurate.*
+`CONFIG` *is changed to* `CONFIGURATION`, *which is more accurate*.
*The* `REFRESH DATABASE METADATA` *statement is added to pull the configuration from the governance center to forcibly refresh the local metadata.*
@@ -156,7 +156,7 @@ The syntax related to data encryption is not adjusted this time. Please refer to
*Description:*
-*Remove the syntax for independently creating sharding algorithms and distributed ID generators and integrate them into the rule definition of* `CREATE SHARDING TABLE RULE`*.*
+*Remove the syntax for independently creating sharding algorithms and distributed ID generators and integrate them into the rule definition of* `CREATE SHARDING TABLE RULE`.
*Other syntax is not adjusted.*
@@ -164,7 +164,7 @@ The syntax related to data encryption is not adjusted this time. Please refer to

-*Description: by default, only one single-table router can be created. And* `CREATE` *is updated to* `SET`*.*
+*Description: by default, only one single-table router can be created. And* `CREATE` *is updated to* `SET`.
## **Relation Object**
@@ -174,7 +174,7 @@ The syntax related to data encryption is not adjusted this time. Please refer to
*Description:*
-*Remove the syntax for creating a* `DB_DISCOVERY TYPE` *and* `HEARTBEAT` *independently and integrate them into the rule definition of the* `CREATE DB_DISCOVERY RULE`*.*
+*Remove the syntax for creating a* `DB_DISCOVERY TYPE` *and* `HEARTBEAT` *independently and integrate them into the rule definition of the* `CREATE DB_DISCOVERY RULE`.
*Other syntax is not adjusted.*
@@ -204,9 +204,9 @@ TYPE(NAME="random")
*Description:*
-*Remove syntax for creating shadow algorithms independently and integrate it into the rule definition of* `CREATE SHADOW RULE`*.*
+*Remove syntax for creating shadow algorithms independently and integrate it into the rule definition of* `CREATE SHADOW RULE`.
-*Add statements to* `ALTER` *and* `SHOW` *default shadow algorithm, corresponding to* `CREATE DEFAULT SHADOW ALGORITHM`*.*
+*Add statements to* `ALTER` *and* `SHOW` *default shadow algorithm, corresponding to* `CREATE DEFAULT SHADOW ALGORITHM`.
# Property Specification Optimization
diff --git a/docs/blog/content/material/2023_02_09_Leverage_Terraform_to_Create_an_Apache_ShardingSphere_Proxy_High_Availability_Cluster_on_AWS.en.md b/docs/blog/content/material/2023_02_09_Leverage_Terraform_to_Create_an_Apache_ShardingSphere_Proxy_High_Availability_Cluster_on_AWS.en.md
index 1561ce0d7d1..5b91df7c439 100644
--- a/docs/blog/content/material/2023_02_09_Leverage_Terraform_to_Create_an_Apache_ShardingSphere_Proxy_High_Availability_Cluster_on_AWS.en.md
+++ b/docs/blog/content/material/2023_02_09_Leverage_Terraform_to_Create_an_Apache_ShardingSphere_Proxy_High_Availability_Cluster_on_AWS.en.md
@@ -12,9 +12,9 @@ With this in mind, we plan to use Terraform to create a ShardingSphere-Proxy hig
## Terraform
-[Terraform](https://www.terraform.io/) is [Hashicorp](https://www.hashicorp.com/)’s open source infrastructure automation orchestration tool that uses IaC philosophy to manage infrastructure changes.
+[Terraform](https://www.terraform.io/) is [Hashicorp](https://www.hashicorp.com/)'s open source infrastructure automation orchestration tool that uses IaC philosophy to manage infrastructure changes.
-It’s supported by public cloud vendors such as AWS, GCP, AZURE and a variety of other providers from the community, and has become one of the most popular practices in the “Infrastructure as Code” space.
+It's supported by public cloud vendors such as AWS, GCP, AZURE and a variety of other providers from the community, and has become one of the most popular practices in the "Infrastructure as Code" space.
**Terraform has the following advantages:**
@@ -24,7 +24,7 @@ Terraform is suitable for multi-cloud scenarios, deploying similar infrastructur
*Automated management infrastructure*
-Terraform’s ability to create reusable modules reduces human-induced deployment and management errors.
+Terraform's ability to create reusable modules reduces human-induced deployment and management errors.
*Infrastructure as code*
@@ -309,7 +309,7 @@ variable "zk_servers" {
**Configure AutoScalingGroup**
-We’ll create an AutoScalingGroup to allow it to manage ShardingSphere-Proxy instances. The health check type of the AutoScalingGroup is changed to “ELB” to allow the AutoScalingGroup to move out bad nodes in time after load balancing fails to perform a health check on the instance.
+We'll create an AutoScalingGroup to allow it to manage ShardingSphere-Proxy instances. The health check type of the AutoScalingGroup is changed to "ELB" to allow the AutoScalingGroup to move out bad nodes in time after load balancing fails to perform a health check on the instance.
The changes to `load_balancers` and `target_group_arns` are ignored when creating the AutoScalingGroup.
@@ -504,13 +504,13 @@ resource "aws_iam_instance_profile" "ss" {
## Deployment
-Once all Terraform configurations have been created, you’ll be ready to deploy the ShardingSphere-Proxy cluster. Before actually deploying, it’s recommended that you use the following command to check that the configuration performs as expected.
+Once all Terraform configurations have been created, you'll be ready to deploy the ShardingSphere-Proxy cluster. Before actually deploying, it's recommended that you use the following command to check that the configuration performs as expected.
```markdown
terraform plan
```
-After confirming the plan, it’s time to go ahead and actually execute it by running the following command
+After confirming the plan, it's time to go ahead and actually execute it by running the following command
```markdown
terraform apply
@@ -528,7 +528,7 @@ By default, we create an internal domain `proxy.shardingsphere.org` and the user
**Description:**
-DistSQL (Distributed SQL) is Apache ShardingSphere’s SQL-like operational language. It’s used in exactly the same way as standard SQL to provide SQL-level manipulation capabilities for incremental functionality, as described [here](https://shardingsphere.apache.org/document/current/cn/user-manual/shardingsphere-proxy/distsql/).
+DistSQL (Distributed SQL) is Apache ShardingSphere's SQL-like operational language. It's used in exactly the same way as standard SQL to provide SQL-level manipulation capabilities for incremental functionality, as described [here](https://shardingsphere.apache.org/document/current/cn/user-manual/shardingsphere-proxy/distsql/).
# Conclusion
diff --git a/docs/blog/content/material/2023_02_15_A_Distributed_Database_Load_Balancing_Architecture_Based_on_ShardingSphere_Demo_&_User_Case.en.md b/docs/blog/content/material/2023_02_15_A_Distributed_Database_Load_Balancing_Architecture_Based_on_ShardingSphere_Demo_&_User_Case.en.md
index a05ebc51b86..16320b004c2 100644
--- a/docs/blog/content/material/2023_02_15_A_Distributed_Database_Load_Balancing_Architecture_Based_on_ShardingSphere_Demo_&_User_Case.en.md
+++ b/docs/blog/content/material/2023_02_15_A_Distributed_Database_Load_Balancing_Architecture_Based_on_ShardingSphere_Demo_&_User_Case.en.md
@@ -22,7 +22,7 @@ It consists of two products, ShardingSphere-JDBC and ShardingSphere-Proxy, which
ShardingSphere-JDBC is a lightweight Java framework with additional services provided in the JDBC layer. ShardingSphere-JDBC simply adds computational operations before the application performs database operations, and the application process still connects directly to the database via the database driver.
-As a result, users don’t have to worry about load balancing with ShardingSphere-JDBC, and can focus on how their application is load balanced.
+As a result, users don't have to worry about load balancing with ShardingSphere-JDBC, and can focus on how their application is load balanced.
**SharidngSphere-Proxy Load Balancing Solution**
@@ -57,7 +57,7 @@ Therefore, in addition to considerations at the load balancing level, there are
***Consider on-demand connection creation for scenarios with long execution intervals***
-For example, if a connection’s single instance is created and used continuously, the database connection will be idle most of the time when executing a timed job with a 1-hour interval and a short execution time.
+For example, if a connection's single instance is created and used continuously, the database connection will be idle most of the time when executing a timed job with a 1-hour interval and a short execution time.
If the client itself is not aware of changes in the connection state, the long idle time increases the uncertainty of the connection state.
@@ -88,7 +88,7 @@ A while back, a community user provided feedback that the ShardingSphere-Proxy c
## Problem Description
-For the sake of our case, let’s consider that a user’s production environment uses a 3-node ShardingSphere-Proxy cluster, which serves applications through a cloud vendor’s ELB.
+For the sake of our case, let's consider that a user's production environment uses a 3-node ShardingSphere-Proxy cluster, which serves applications through a cloud vendor's ELB.

@@ -114,7 +114,7 @@ If you encounter any of the three reasons listed below, we recommend that you pe
- The problem will recur on an hourly basis.
- The issue is network related.
-- The issue does not affect the user’s real-time operations.
+- The issue does not affect the user's real-time operations.
**Packet Capture Phenomenon I**
@@ -139,9 +139,9 @@ The MySQL connection is established between the client and the ShardingSphere-Pr
The above packet capture results show that the client first initiated the `COM_QUIT` command to ShardingSphere-Proxy, i.e. the MySQL connection was disconnected by the client, including but not limited to the following possible scenarios:
- The application has finished using the MySQL connection and closed the database connection normally.
-- The application’s database connection to ShardingSphere-Proxy is managed by a connection pool, which performs a release operation for idle connections that have timed out or have exceeded their maximum lifetime.
+- The application's database connection to ShardingSphere-Proxy is managed by a connection pool, which performs a release operation for idle connections that have timed out or have exceeded their maximum lifetime.
-As the connection is actively closed on the application side, it does not theoretically affect other business operations, unless there is a problem with the application’s logic.
+As the connection is actively closed on the application side, it does not theoretically affect other business operations, unless there is a problem with the application's logic.
After several rounds of packet analysis, no RSTs were found to have been sent to the client by the ShardingSphere-Proxy in the minutes before and after the problem resurfaced.
@@ -284,8 +284,8 @@ private static String getProxyVersion(Statement statement) throws SQLException {
Expected results:
1. A client connection to the ShardingSphere-Proxy is established and the first query is successful.
-2. The client’s second query is successful.
-3. The client’s third query results in an error due to a broken TCP connection, as the nginx idle timeout is set to 1 minute.
+2. The client's second query is successful.
+3. The client's third query results in an error due to a broken TCP connection, as the nginx idle timeout is set to 1 minute.
The execution results are as expected. Due to differences between the programming language and the database driver, the error messages behave differently, but the underlying cause is the same: both are TCP connections have been disconnected.
diff --git a/docs/blog/content/material/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained.en.md b/docs/blog/content/material/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained.en.md
new file mode 100644
index 00000000000..9278e23f3cf
--- /dev/null
+++ b/docs/blog/content/material/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained.en.md
@@ -0,0 +1,251 @@
++++
+title = "ShardingSphere-Proxy Database Protocol Interaction Explained"
+weight = 89
+chapter = true
+
++++
+
+Database protocols are considered relatively unknown knowledge for most developers. Generally, users and developers use databases through off-the-shelf database clients and drivers, without manipulating database protocols directly.
+
+However, having some basic understanding of the features and processes of database protocols can help developers provide some ideas to identify troubleshooting problems when it comes to database functionality and performance issues.
+
+In this post, we will introduce the features of commonly used open source database protocols such as MySQL and PostgreSQL, and explain how ShardingSphere-Proxy interacts with clients at the database protocol level.
+
+# Introduction to the ShardingSphere Access Side
+
+The Apache ShardingSphere ecosystem includes ShardingSphere-JDBC and ShardingSphere-Proxy, deployable independently or in a hybrid deployment.
+
+They both provide standardised incremental functionality based on databases as storage nodes for a variety of application scenarios such as Java homogeneous, heterogeneous languages, cloud native and more.
+
+
+
+ShardingSphere-JDBC is a Java-based SDK that implements the standard JDBC and is lightweight and high performance, but also has obvious limitations. Nevertheless, the limitations of ShardingSphere-JDBC in terms of access are addressed by ShardingSphere-Proxy on the access side.
+
+- ShardingSphere-Proxy supports connections via any database client, database driver, and is not limited to JVM-based languages such as Java.
+- Simplifies data management. In particular, in scenarios where data sharding or encryption is used, ShardingSphere-Proxy can be used as a unified portal to manipulate data without having to consider the actual node where the data is stored or to manually decrypt it, etc.
+- Provides unified operation and maintenance control capabilities. In cluster mode, ShardingSphere-Proxy can be used to unify the management of ShardingSphere rules and configurations.
+- Heavyweight operations can be performed. ShardingSphere-JDBC is in the same process as the application, where heavyweight computation and I/O operations may impact application performance, while ShardingSphere-Proxy starts as a separate process and supports horizontal scaling, and performing heavyweight operations without impacting application performance.
+
+# Database Protocol Features
+
+There are already a number of specific interpretations of MySQL or PostgreSQL protocols on the Internet, so we won't go into detail in this article.
+
+This section focuses on the features of each database protocol, such as its support for Pipelining and how bulk operations are represented in the protocol.
+
+## MySQL Protocol
+
+The MySQL protocol is typically a “one question, one answer" protocol, e.g. to execute SQL using Prepared Statement. At the protocol level, you need to execute `COM_STMT_PREPARE` and `COM_STMT_EXECUTE` respectively.
+
+
+
+**Image source:** [MySQL documentation](https://dev.mysql.com/doc/dev/mysql-server/latest/mysqlx_protocol_use_cases.html).
+
+MySQL has added an X Plugin since 5.7.12, which allows MySQL to add support for document type stores while maintaining the original relational store.
+
+The X Plugin uses a new communication protocol, X Protocol, which uses port 33060 by default and supports pipelining, i.e. the client can send a batch of commands to the client at a time, reducing the RTT (Round-trip time) associated with the “one question, one answer" model (Round-trip time).
+
+For example, if a SQL is executed using `Prepared Statement`, at the protocol level there are `Prepare` and `Execute` steps, but at the network transport level, these two steps can be combined and sent. This can theoretically reduce the RTT by one compared to the original protocol.
+
+
+
+**Image source:** [MySQL documentation](https://dev.mysql.com/doc/dev/mysql-server/latest/mysqlx_protocol_use_cases.html).
+
+However, the X Plugin for MySQL does not seem to be catching on at the moment, and most scenarios are still based on the original MySQL protocol for client and server communication.
+
+In the case of batch operations, the MySQL protocol command `COM_STMT_EXECUTE`, which executes the `Prepared Statement `statement, can only send one set of parameters at a time, making the "one question, one answer" approach somewhat inefficient:
+
+
+
+**Image source:** [MySQL documentation](https://dev.mysql.com/doc/dev/mysql-server/latest/mysqlx_protocol_use_cases.html).
+
+The protocol itself is not designed to support batch operations, so they can only be optimised at the client level.
+
+In the case of MySQL Connector/J, for example, when the parameter `rewriteBatchedStatements` is enabled, MySQL Connector/J will internally take the multiple sets of parameters set by the `addBatch` method, combine insert values or compose update/delete into multiple statements, and send them at the protocol level sent in one go.
+
+This is a small increase in CPU overhead in exchange for a reduction in RTT. For example, for a Prepared Statement insert statement, add multiple parameters to execute:
+
+```Mysql
+INSERT INTO tbl VALUES (?, ?, ?);
+addBatch [1, "foo", "bar"]
+addBatch [2, "baz", "fuz"]
+```
+
+MySQL Connector/J Actual Execution Statement:
+
+```Mysql
+INSERT INTO tbl VALUES (1, "foo", "bar"),(2, "baz", "fuz");
+```
+
+For bulk update / delete, MySQL Connector/J will execute multiple statements via `COM_QUERY`, e.g:
+
+```Mysql
+UPDATE tbl SET name = ? WHERE id = ?;
+addBatch ["foo", 1]
+addBatch ["bar", 2]
+```
+
+MySQL Connector/J Actual Execution Statement:
+
+```Mysql
+UPDATE tbl SET name = "foo" WHERE id = 1;UPDATE tbl SET name = "bar" WHERE id = 2;
+```
+
+## PostgreSQL Protocol
+
+Compared to the MySQL protocol, the PostgreSQL protocol definition looks simpler and the PostgreSQL protocol supports Pipelining:
+
+PostgreSQL's Extended Query breaks up SQL execution into multiple steps, with the following common operations.
+
+- **Parse:** parses the SQL into a `Prepared Statement`.
+- **Describe:** Get the metadata of a `Prepared Statement` or `Portal`.
+- **Bind:** Bind the actual parameters of the `Prepared Statement` to produce an executable `Portal`; `Bind: Bind `the actual parameters of the `Prepared Statement` to produce an executable `Portal`.
+- **Execute:** executing the `Portal`.
+- **Close:** closes the `Prepared Statement` or `Portal`.
+
+An example of the PostgreSQL JDBC protocol interaction with the database is as follows:
+
+
+
+In a bulk operation scenario, the client can send multiple sets of parameters in one continuous `Bind`, `Execute`, which is multiple packets at the protocol level, but at the TCP transport level, one batch of packets can be sent out at a time.
+
+
+
+Pipelining-enabled protocols, combined with I/O multiplexing, offer certain advantages in terms of throughput. For example, Vert.x PostgreSQL, a database driver based on multiplexed I/O, scored first place in the TechEmpower Benchmark Round 15 test in the Single Query scenario (database spotting).
+
+
+
+Image source: [Tech Empower](https://www.techempower.com/benchmarks/#section=data-r15&test=db).
+
+## openGauss Protocol
+
+openGauss adds a Batch Bind message to the PostgreSQL Protocol 3.0, which only sends one set of parameters at a time.
+
+openGauss adds a Batch Bind message to support sending multiple sets of parameters at the same time.
+
+
+
+Additionally, openGauss has been enhanced in terms of authentication security. The general flow of the protocol is identical to that of PostgreSQL.
+
+# ShardingSphere-Proxy Front-End Interaction Flow Explained
+
+## Relationship between ShardingSphere-Proxy and Database Protocol
+
+Database protocols, like HTTP and other protocols, are the standard for communication between the client and the server. Each database defines its own protocol.
+
+For example, the MySQL database defines its own set of protocols, as well as the Protobuf-based X Protocol; PostgreSQL also defines its own set of protocols and etc.
+
+The average user or developer uses an off-the-shelf client or corresponding driver and the protocol is relatively transparent to them. Therefore, ShardingSphere-Proxy implements the database protocol and serves it to the public, so that users can use ShardingSphere-Proxy as if it were a database.
+
+The specific database protocol versions currently supported by ShardingSphere-Proxy are:
+
+- MySQL Protocol 4.1 (since MySQL 4.1)
+- PostgreSQL Protocol 3.0 (since PostgreSQL 7.4)
+- openGauss Protocol 3.00 / 3.50 / 3.51
+
+## Overall Process for the Access Side
+
+ShardingSphere-Proxy and ShardingSphere-JDBC share the ShardingSphere kernel module and provide different access to users.
+
+ShardingSphere-Proxy exists as a standalone process and provides services to the outside world as a database protocol. ShardingSphere-JDBC is a set of SDKs that can be called directly by users through code.
+
+
+
+## ShardingSphere-Proxy Front-end Process
+
+The ShardingSphere-Proxy front-end uses Netty to implement the database protocol. The Netty event-driven approach to front-end connections allows the ShardingSphere-Proxy front-end to maintain a large number of client connections.
+
+The protocol unwrapping and encoding logic is mainly performed in the Netty `EventLoop` thread. As the ShardingSphere-Proxy backend still uses JDBC to interact with the database, a dedicated thread pool is used to execute the ShardingSphere kernel logic and database interaction after the protocol data has been unpacked to avoid blocking in the Netty `EventLoop` thread.
+
+
+
+`PacketCodecs` are mainly used for unpacking and encoding data. As mentioned earlier in the introduction to database protocols, the PostgreSQL protocol supports pipelining and can send a batch of packets at a time.
+
+## Example:
+
+The following diagram shows the request protocol for a PostgreSQL client to execute the `select current_schema()` statement using `Prepared Statement`, where the SQL parsing and execution steps of `Prepared Statement` are sent by the client to the server for execution in one go.
+
+
+
+What the server receives is a stream of bytes. How can this stream be split into multiple protocol packets?
+
+Taking the PostgreSQL protocol format as an example, except for the Startup Message, the format of each protocol packet is 1 byte of message type + 4 bytes of data length (including the length itself) + data, with the following structure:
+
+
+
+The MySQL protocol packet format is similar.
+
+The `PacketCodec` simply follows the protocol format definition and splits the incoming byte stream correctly.
+
+After the byte stream has been split, the remaining steps are to parse the data according to the database protocol and get the SQL and parameters to be executed.
+
+Once the SQL and parameters are available, the rest of the execution process is essentially the same as executing SQL via ShardingSphere-JDBC.
+
+After the ShardingSphere-Proxy backend executes SQL via JDBC, the result set is a Java object and the `PacketCodec` calls the specific encoding logic to convert the Java object into a byte stream according to the database protocol, assembles it into a packet and responds to the client.
+
+
+
+This is the general flow of the ShardingSphere-Proxy front-end database protocol interaction.
+
+## How to Feedback Suspected Proxy Protocol Issues to the ShardingSphere Community?
+
+Due to the differences in computing power between ShardingSphere-Proxy and databases, the Proxy does not yet have 100% support for database protocols, and there are inevitably some unsupported cases in the process.
+
+This article gives some suggestions for feedback when users encounter problems with Proxy that are suspected to be caused by imperfect implementation of the Proxy protocol.
+
+## Demo Available for Simple Problem Replication
+
+If you have a problem that can be reproduced by constructing simple code (e.g. just using Python and installing a few simple dependencies), you can provide the code and steps to reproduce the problem directly in the Github issue.
+
+**Case:** a community member has submitted a problem with aDjango.db [transaction to ShardingSphere-Proxy MySQL](https://github.com/apache/shardingsphere/issues/18461).
+
+The author provided a reproduction in the issue to help the ShardingSphere team fix the problem.
+
+## Directly Submit a Problem Fix PR
+
+For relatively simple issues, the ShardingSphere team can provide ideas for fixing them, and community members who are in a position to do so can consider submitting a PR to fix them directly.
+
+**Case:** a community member gave feedback on an issue with ShardingSphere-Proxy that was reporting an error[ when connecting to it via Python asyncpg](https://github.com/apache/shardingsphere/issues/23885).
+
+The problem is that the Python asyncpg database driver adds quotes to the encoding name when sending `client_encoding` to ShardingSphere-Proxy. The ShardingSphere-Proxy PostgreSQL does not take into account that the encoding name contains quotes (which is supported by the PostgreSQL database), resulting in an encoding recognition error.
+
+The issue's author was already in a position to reproduce the problem, and submitted a PR to fix the problem directly under the guidance of the ShardingSphere team.
+
+## Capture the Traffic Between the Client and the Proxy Using a Packet Capture Tool
+
+Some heterogeneous languages users may encounter issues with ShardingSphere-Proxy that are not related to a specific functionality and are suspected to be at the protocol level.
+
+Due to differences in the technology stack between the user and the ShardingSphere team, the ShardingSphere team may not be able to quickly reproduce the issue locally. In this case, consider feeding back to the ShardingSphere community by capturing network traffic between the client and the ShardingSphere-Proxy.
+
+There is a lot of information available on the Internet on how to use this tool, so we won't mention them here.
+
+**Case:** A .NET MySqlConnector using ShardingSphere-Proxy issue was submitted by a community member some time ago [with the following problem](https://github.com/apache/shardingsphere/issues/23857).
+
+There is an error about the .NET connection to ShardingSphere-Proxy reported in the Issue. According to the stack, the error is caused during `TryResetConnectionAsync` and the last exception is thrown under the Protocol-related code, so this could be a ShardingSphere-Proxy protocol implementation does not behave the same way as MySQL.
+
+```plaintext
+An error occurred using the connection to database .....
+
+ MySqlConnector.MySqlProtocolException: Packet received out-of-order. Expected 1; got 2.
+ at MySqlConnector.Protocol.Serialization.ProtocolUtility.<DoReadPayloadAsync>g__AddContinuation|5_0(ValueTask`1 readPacketTask, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, F
+unc`1 getNextSequenceNumber, ArraySegmentHolder`1 previousPayloads, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior) in /_/src/MySqlConnector/Protocol/Serialization/ProtocolUtility.cs:
+line 476
+ at MySqlConnector.Core.ServerSession.ReceiveReplyAsyncAwaited(ValueTask`1 task) in /_/src/MySqlConnector/Core/ServerSession.cs:line 943
+ at MySqlConnector.Core.ServerSession.TryResetConnectionAsync(ConnectionSettings cs, MySqlConnection connection, IOBehavior ioBehavior, CancellationToken cancellationToken) in /_/src/MySqlConnect
+or/Core/ServerSession.cs:line 616
+```
+
+As this issue is costly to reproduce, it's not easy for the ShardingSphere team to reproduce the issue locally, and the community has provided protocol traffic between the client and the Proxy.
+
+
+
+Based on the protocol packet capture results, the ShardingSphere team immediately identified the issue as a problem with the implementation of the ShardingSphere-Proxy MySQL packet encoding logic.
+
+## Relevant Links:
+
+**🔗** [**ShardingSphere Official Website**](https://shardingsphere.apache.org/)
+
+**🔗** [**ShardingSphere Official Project Repo**](https://github.com/apache/shardingsphere)
+
+**🔗** [**ShardingSphere Twitter**](https://twitter.com/ShardingSphere)
+
+**🔗** [**ShardingSphere Slack**](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
\ No newline at end of file
diff --git a/docs/blog/content/material/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide.en.md b/docs/blog/content/material/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide.en.md
new file mode 100644
index 00000000000..dfb97327af6
--- /dev/null
+++ b/docs/blog/content/material/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide.en.md
@@ -0,0 +1,358 @@
++++
+title = "ShardingSphere 5.3.x Update: Spring Configuration Update Guide"
+weight = 90
+chapter = true
+
++++
+
+
+
+Before 5.3.0, ShardingSphere-JDBC supported Java API, YAML, Spring Boot Starter, and Spring Namespace.
+
+However, compatibility with Spring has brought the following challenges to the community:
+
+- Many configuration files need to be adjusted when adding or updating API, which causes a heavy workload.
+- The community needs to maintain lots of configuration documents and examples.
+- Spring Bean life cycle management is susceptible to other project dependencies, such as PostProcessor.[1][2]
+- Spring Boot Starter and Spring Namespace's style differs from YAML in ShardingSphere.
+- Spring Boot Starter and Spring Namespace are affected by the update of Spring, causing more configuration compatibility problems.
+
+For example, in the latest release of Spring Boot 3.0.0,
+
+`spring.factories` supported in 2.x has been removed.[3][4]
+
+This is a challenge for ShardingSphere Spring Boot Starter users. It's hard to upgrade because it would cause new compatibility problems.
+
+As a result, our community decided to remove all Spring dependencies and configuration support in the ShardingSphere 5.3.0 Release.
+
+So, how do the ShardingSphere-JDBC users who need to use Spring Boot or Spring Namespace access ShardingSphere and upgrades? Read on to find the solutions.
+
+# **Impact**
+
+For the convenience of users who are using ShardingSphere Spring Boot Starter or ShardingSphere Spring Namespace to assess the impact of the upgrade, we have sorted out the impact of this upgrade:
+
+## Maven Coordinates
+
+The original Spring-related dependency coordinates will be invalid after the upgrade to ShardingSphere 5.3.0 and future versions.
+
+```xml
+<dependency>
+ <groupId>org.apache.shardingsphere</groupId>
+ <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
+ <version>${shardingsphere.version}</version>
+</dependency>
+
+<dependency>
+ <groupId>org.apache.shardingsphere</groupId>
+ <artifactId>shardingsphere-jdbc-core-spring-namespace</artifactId>
+ <version>${shardingsphere.version}</version>
+</dependency>
+```
+
+Adjusted to:
+
+```xml
+<dependency>
+ <groupId>org.apache.shardingsphere</groupId>
+ <artifactId>shardingsphere-jdbc-core</artifactId>
+ <version>${shardingsphere.version}</version>
+</dependency>
+```
+
+## Custom Algorithm
+
+The `AlgorithmProvided` classes will be removed as well after removing the Spring module. Logic related to Bean injection will be invalid after the update, though it has been previously used in the custom algorithm.
+
+For scenarios that require Spring Beans, developers need to proactively manage them.
+
+## Transaction
+
+There will be no `@ShardingSphereTransactionType` annotation, which supports declarative method-level transactions.
+
+If you need to change the transaction type, see Java API[5].
+
+## Configuration
+
+After the 5.3.0 update, the original Spring Boot Starter and Spring Namespace data source configuration will be invalid. See the next chapter to learn how to configure it after the update.
+
+# Guide
+
+## ShardingSphereDriver
+
+From 5.1.2, ShardingSphere-JDBC provides a native JDBC driver, `ShardingSphereDriver`. Engineers can access through configuration directly without rewriting the code.
+
+This way, the formats of ShardingSphere-JDBC and ShardingSphere-Proxy can be more unified. They can be reused with only a few changes. See User Manual-JDBC Driver[6] for details.
+
+After the update to 5.3.x, those who use Spring Boot Starter or Spring Namespace are advised to use `ShardingSphereDriver` to access ShardingSphered-JDBC.
+
+## For Spring Boot Starter Users
+
+## Before the Update
+
+The ShardingSphere configuration in `application.yml` is as follows:
+
+**application.yml**
+
+```yaml
+spring:
+ shardingsphere:
+ database:
+ name: sharding_db
+ datasource:
+ names: ds_0,ds_1
+ ds_0:
+ type: com.zaxxer.hikari.HikariDataSource
+ driver-class-name: com.mysql.cj.jdbc.Driver
+ jdbc-url: jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false
+ username: root
+ password:
+ ds_1:
+ type: com.zaxxer.hikari.HikariDataSource
+ driver-class-name: com.mysql.cj.jdbc.Driver
+ jdbc-url: jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false
+ username: root
+ password:
+ rules:
+ sharding:
+ default-database-strategy:
+ standard:
+ sharding-column: id
+ sharding-algorithm-name: database_inline
+ tables:
+ t_order:
+ actual-data-nodes: ds_$->{0..1}.t_order_$->{0..1}
+ table-strategy:
+ standard:
+ sharding-column: count
+ sharding-algorithm-name: t_order_inline
+ sharding-algorithms:
+ database_inline:
+ type: INLINE
+ props:
+ algorithm-expression: ds_$->{user_id % 2}
+ t_order_inline:
+ type: INLINE
+ props:
+ algorithm-expression: t_order_$->{order_id % 2}
+ props:
+ sql-show: true
+```
+
+## After the Update
+
+Create a new YAML configuration file in `resources`, such as `sharding.yaml`. Then rewrite the original configuration according to the user manual -YAML configuration[7].
+
+**sharding.yaml**
+
+```yaml
+dataSources:
+ ds_0:
+ dataSourceClassName: com.zaxxer.hikari.HikariDataSource
+ driverClassName: com.mysql.jdbc.Driver
+ jdbcUrl: jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false
+ username: root
+ password:
+ ds_1:
+ dataSourceClassName: com.zaxxer.hikari.HikariDataSource
+ driverClassName: com.mysql.jdbc.Driver
+ jdbcUrl: jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false
+ username: root
+ password:
+
+rules:
+- !SHARDING
+ tables:
+ t_order:
+ actualDataNodes: ds_$->{0..1}.t_order_$->{0..1}
+ tableStrategy:
+ standard:
+ shardingColumn: count
+ shardingAlgorithmName: t_order_inline
+ defaultDatabaseStrategy:
+ standard:
+ shardingColumn: id
+ shardingAlgorithmName: database_inline
+ shardingAlgorithms:
+ database_inline:
+ type: INLINE
+ props:
+ algorithm-expression: ds_$->{user_id % 2}
+ t_order_inline:
+ type: INLINE
+ props:
+ algorithm-expression: t_order_$->{order_id % 2}
+
+props:
+ sql-show: true
+```
+
+If the cluster mode is deployed and required configurations for the `namespace` exist, only `mode` needs to be configured.
+
+```yaml
+mode:
+ type: Cluster
+ repository:
+ type: ZooKeeper
+ props:
+ namespace: governance_ds
+ server-lists: localhost:2181
+ retryIntervalMilliseconds: 500
+ timeToLiveSeconds: 60
+ maxRetries: 3
+ operationTimeoutMilliseconds: 500
+```
+
+**application.yml**
+
+Replace the original ShardingSphere configuration with the ShardingSphereDriver configuration:
+
+```yaml
+spring:
+ datasource:
+ driver-class-name: org.apache.shardingsphere.driver.ShardingSphereDriver
+ url: jdbc:shardingsphere:classpath:sharding.yaml
+```
+
+## For Spring Namespace Users
+
+## Before the Update
+
+**spring-sharding.xml**
+
+```xml
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xmlns:tx="http://www.springframework.org/schema/tx"
+ xmlns:shardingsphere="http://shardingsphere.apache.org/schema/shardingsphere/datasource"
+ xmlns:sharding="http://shardingsphere.apache.org/schema/shardingsphere/sharding"
+ xsi:schemaLocation="http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans.xsd
+ http://www.springframework.org/schema/tx
+ http://www.springframework.org/schema/tx/spring-tx.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context.xsd
+ http://shardingsphere.apache.org/schema/shardingsphere/datasource
+ http://shardingsphere.apache.org/schema/shardingsphere/datasource/datasource.xsd
+ http://shardingsphere.apache.org/schema/shardingsphere/sharding
+ http://shardingsphere.apache.org/schema/shardingsphere/sharding/sharding.xsd
+ ">
+
+ <bean id="ds_0" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
+ <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+ <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
+ <property name="username" value="root"/>
+ <property name="password" value=""/>
+ </bean>
+
+ <bean id="ds_1" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
+ <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+ <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
+ <property name="username" value="root"/>
+ <property name="password" value=""/>
+ </bean>
+
+ <sharding:standard-strategy id="databaseStrategy" sharding-column="user_id" algorithm-ref="inlineStrategyShardingAlgorithm" />
+
+ <sharding:sharding-algorithm id="inlineStrategyShardingAlgorithm" type="INLINE">
+ <props>
+ <prop key="algorithm-expression">ds_${user_id % 2}</prop>
+ </props>
+ </sharding:sharding-algorithm>
+
+ <sharding:standard-strategy id="orderTableStrategy" sharding-column="order_id" algorithm-ref="orderTableAlgorithm" />
+
+ <sharding:sharding-algorithm id="orderTableAlgorithm" type="INLINE">
+ <props>
+ <prop key="algorithm-expression">t_order_${order_id % 2}</prop>
+ </props>
+ </sharding:sharding-algorithm>
+
+ <sharding:rule id="shardingRule">
+ <sharding:table-rules>
+ <sharding:table-rule logic-table="t_order" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+ </sharding:table-rules>
+ </sharding:rule>
+
+ <shardingsphere:data-source id="shardingDataSource" database-name="sharding-databases" data-source-names="ds_0,ds_1" rule-refs="shardingRule" >
+ <props>
+ <prop key="sql-show">true</prop>
+ </props>
+ </shardingsphere:data-source>
+</beans>
+```
+
+## After the Update
+
+**sharding.yaml**
+
+`sharding.yaml` has been added in the same format as Spring Boot's YAML above.
+
+**spring-sharding.xml**
+
+The original ShardingSphere configuration in `spring-sharding.xml` has been replaced with the configuration of ShardingSphereDriver.
+
+```xml
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+ <bean id="shardingDataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
+ <property name="driverClass" value="org.apache.shardingsphere.driver.ShardingSphereDriver" />
+ <property name="url" value="jdbc:shardingsphere:classpath:sharding.yaml" />
+ </bean>
+</beans>
+```
+
+🏆 Complete the above configuration and you can enjoy the new version of ShardingSphere-JDBC!
+
+# Conclusion
+
+This update greatly reduces the difference between ShardingSphere-JDBC and ShardingSphere-Proxy.
+
+It will help ShardingSphere-JDBC users to make a smooth transition to ShardingSphere cluster architecture. API standardization and configuration compatibility have made solid progress.
+
+For new ShardingSphere users, the configuration of `ShardingSphereDriver` is also easier and less intrusive.
+
+Since then, the Apache ShardingSphere community has been able to focus more on its own iterations, bringing ever-better features to all users and developers.
+
+For more information about the update, please refer to the user manual of the official website[8].
+
+If readers have any questions or suggestions about Apache ShardingSphere, please raise them on the GitHub issue[9], or visit our slack[10] for discussion.
+
+# Author
+
+**Jiahao Chen**
+
+*Middleware Development Engineer at SphereEx, Apache ShardingSphere Contributor*
+
+# Relevant Links:
+
+🔗 [ShardingSphere Official Website](https://shardingsphere.apache.org/)
+
+🔗 [ShardingSphere Official Project Repo](https://github.com/apache/shardingsphere)
+
+🔗 [ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+🔗 [ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[1] [issue: ShardingSphereAlgorithmPostProcessor.init()](https://github.com/apache/shardingsphere/issues/18093)
+
+[2] [issue: ShardingSphere Bean is not eligible for getting processed by all BeanPostProcessors](https://github.com/apache/shardingsphere/issues/11650)
+
+[3] [Spring Boot: Remove spring.factories auto-configuration support](https://github.com/spring-projects/spring-boot/issues/29699)
+
+[4] [issue: spring boot 3.0.0-M5 Failed to determine a suitable driver class](https://github.com/apache/shardingsphere/issues/21225)
+
+[5] [User Manual -Java API](https://shardingsphere.apache.org/document/current/en/user-manual/shardingsphere-jdbc/special-api/transaction/java-api/)
+
+[6] [User Manual -JDBC Driver](https://shardingsphere.apache.org/document/current/en/user-manual/shardingsphere-jdbc/yaml-config/jdbc-driver/)
+
+[7] [User Manual-YAML Configuration](https://shardingsphere.apache.org/document/current/en/user-manual/shardingsphere-jdbc/yaml-config/)
+
+[8] [User Manual](https://shardingsphere.apache.org/document/current/en/user-manual/)
+
+[9] [GitHub issue](https://github.com/apache/shardingsphere/issues)
+
+[10] [ShardingSphere Slack channel](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
\ No newline at end of file
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained1.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained1.png
new file mode 100644
index 00000000000..9d16df7aa13
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained1.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained10.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained10.png
new file mode 100644
index 00000000000..37ad5518c0c
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained10.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained11.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained11.png
new file mode 100644
index 00000000000..2d7968aacb8
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained11.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained12.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained12.png
new file mode 100644
index 00000000000..c3c8a947a8f
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained12.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained13.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained13.png
new file mode 100644
index 00000000000..a9767ad4e42
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained13.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained14.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained14.png
new file mode 100644
index 00000000000..d7e8377d860
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained14.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained2.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained2.png
new file mode 100644
index 00000000000..94ba79264f7
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained2.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained3.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained3.png
new file mode 100644
index 00000000000..30f957465dd
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained3.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained4.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained4.png
new file mode 100644
index 00000000000..6c93fc0ebff
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained4.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained5.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained5.png
new file mode 100644
index 00000000000..38d24f6c7f1
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained5.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained6.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained6.png
new file mode 100644
index 00000000000..78a6ad4fbb7
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained6.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained7.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained7.png
new file mode 100644
index 00000000000..b2ca628bed3
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained7.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained8.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained8.png
new file mode 100644
index 00000000000..b06ca17a59a
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained8.png differ
diff --git a/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained9.png b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained9.png
new file mode 100644
index 00000000000..55cb87d224f
Binary files /dev/null and b/docs/blog/static/img/2023_02_23_ShardingSphere-Proxy_Database Protocol_Interaction_Explained9.png differ
diff --git a/docs/blog/static/img/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide1.png b/docs/blog/static/img/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide1.png
new file mode 100644
index 00000000000..067e4617e21
Binary files /dev/null and b/docs/blog/static/img/2023_03_07_ShardingSphere_5.3.x_Update_Spring_Configuration_Update_Guide1.png differ