You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eventmesh.apache.org by mi...@apache.org on 2024/12/25 03:34:53 UTC
(eventmesh-site) branch master updated: [ISSUE #239] Add v1.11.0 release note (#240)
This is an automated email from the ASF dual-hosted git repository.
mikexue pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/eventmesh-site.git
The following commit(s) were added to refs/heads/master by this push:
new 916c37b32 [ISSUE #239] Add v1.11.0 release note (#240)
916c37b32 is described below
commit 916c37b32266cb5439dd5b802f7b73a69223ffd5
Author: mike_xwm <mi...@126.com>
AuthorDate: Wed Dec 25 11:34:48 2024 +0800
[ISSUE #239] Add v1.11.0 release note (#240)
* [ISSUE #239] Add v1.11.0 release note
* fix build error
* fix build error
---
docusaurus.config.js | 2 +-
events/release-notes/v1.11.0.md | 100 +++++
.../01-runtime-protocol.md | 401 +++++++++++++++++++++
.../01-event-handling-and-integration/02-https.md | 30 ++
.../03-cloudevents.md | 106 ++++++
.../04-event-bridge.md | 156 ++++++++
.../05-webhook.md | 324 +++++++++++++++++
.../06-workflow.md | 261 ++++++++++++++
.../_category_.json | 4 +
.../version-v1.11.0/design-document/01-spi.md | 113 ++++++
.../02-observability/01-metrics-export.md | 47 +++
.../design-document/02-observability/02-tracing.md | 87 +++++
.../02-observability/03-prometheus.md | 24 ++
.../design-document/02-observability/04-zipkin.md | 38 ++
.../design-document/02-observability/05-jaeger.md | 44 +++
.../02-observability/_category_.json | 4 +
.../version-v1.11.0/design-document/02-stream.md | 118 ++++++
.../design-document/03-connect/00-connectors.md | 51 +++
.../03-connect/01-rabbitmq-connector.md | 42 +++
.../03-connect/02-http-connector.md | 67 ++++
.../03-connect/03-redis-connector.md | 33 ++
.../03-connect/04-mongodb-connector.md | 36 ++
.../03-connect/05-knative-connector.md | 94 +++++
.../03-connect/06-lark-connector.md | 36 ++
.../03-connect/07-dingtalk-connector.md | 34 ++
.../03-connect/08-wecom-connector.md | 30 ++
.../03-connect/09-slack-connector.md | 25 ++
.../design-document/03-connect/_category_.json | 4 +
.../design-document/03-schema-registry.md | 134 +++++++
.../design-document/_category_.json | 5 +
.../version-v1.11.0/instruction/01-store.md | 48 +++
.../instruction/02-store-with-docker.md | 71 ++++
.../version-v1.11.0/instruction/03-runtime.md | 271 ++++++++++++++
.../instruction/04-runtime-with-docker.md | 168 +++++++++
.../version-v1.11.0/instruction/05-demo.md | 225 ++++++++++++
.../version-v1.11.0/instruction/06-operator.md | 97 +++++
.../version-v1.11.0/instruction/07-faq.md | 42 +++
.../version-v1.11.0/instruction/_category_.json | 5 +
versioned_docs/version-v1.11.0/introduction.md | 29 ++
versioned_docs/version-v1.11.0/roadmap.md | 96 +++++
.../version-v1.11.0/sdk-java/01-intro.md | 39 ++
versioned_docs/version-v1.11.0/sdk-java/02-http.md | 116 ++++++
versioned_docs/version-v1.11.0/sdk-java/03-tcp.md | 118 ++++++
versioned_docs/version-v1.11.0/sdk-java/04-grpc.md | 174 +++++++++
.../version-v1.11.0/sdk-java/_category_.json | 5 +
.../upgrade-guide/01-upgrade-guide.md | 15 +
.../version-v1.11.0/upgrade-guide/_category_.json | 5 +
versioned_sidebars/version-v1.11.0-sidebars.json | 89 +++++
versions.json | 1 +
49 files changed, 4063 insertions(+), 1 deletion(-)
diff --git a/docusaurus.config.js b/docusaurus.config.js
index d9e791726..76eb17e17 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -62,7 +62,7 @@ module.exports = {
{
type: 'doc',
docsPluginId: 'events',
- docId: 'release-notes/v1.10.0',
+ docId: 'release-notes/v1.11.0',
position: 'left',
label: 'Events',
},
diff --git a/events/release-notes/v1.11.0.md b/events/release-notes/v1.11.0.md
new file mode 100644
index 000000000..0d0daa871
--- /dev/null
+++ b/events/release-notes/v1.11.0.md
@@ -0,0 +1,100 @@
+---
+title: v1.11.0 Release
+date: 2024-12-24T18:00:00+00:00
+hide_table_of_contents: false
+author: xmw1992
+author_url: https://github.com/xmw1992
+author_image_url: https://avatars.githubusercontent.com/u/13237619
+sidebar_position: 13
+---
+
+## Feature
+
+- [Feature #4047](https://github.com/apache/eventmesh/issues/4047) Support chatGPT source connector
+- [Feature #4458](https://github.com/apache/eventmesh/issues/4458) Support mysql Sink Connector feature
+- [Feature #4788](https://github.com/apache/eventmesh/issues/4788) Support disruptor as memory queue
+- [Feature #4812](https://github.com/apache/eventmesh/issues/4812) Set up Admin Endpoints v2
+- [Feature #4824](https://github.com/apache/eventmesh/issues/4824) Add HTTP Sink Connector
+- [Feature #4847](https://github.com/apache/eventmesh/issues/4847) HTTPS/(m)TLSv1.3 support for HTTP Admin Server
+- [Feature #4852](https://github.com/apache/eventmesh/issues/4852) Support Jraft algorithm as meta storage
+- [Feature #4869](https://github.com/apache/eventmesh/issues/4869) Add Webhook support for HTTP Source Connector
+- [Feature #4931](https://github.com/apache/eventmesh/issues/4931) Add Registry Module and Support SPI
+- [Feature #4933](https://github.com/apache/eventmesh/issues/4933) Admin Server Module
+- [Feature #4935](https://github.com/apache/eventmesh/issues/4935) Add and Move the Pojo Used By Both Runtime and Admin to Common
+- [Feature #4937](https://github.com/apache/eventmesh/issues/4937) fix gradle dependecy and add runtime v2
+- [Feature #4939](https://github.com/apache/eventmesh/issues/4939) Add Canal Connector
+- [Feature #4979](https://github.com/apache/eventmesh/issues/4979) Canal Connector supports bidirectional data synchronization
+- [Feature #5031](https://github.com/apache/eventmesh/issues/5031) Http Connector Adaptation Work
+- [Feature #5039](https://github.com/apache/eventmesh/issues/5039) support full sync of mysql
+- [Feature #5040](https://github.com/apache/eventmesh/issues/5040) Support gtid mode for sync data with mysql
+- [Feature #5050](https://github.com/apache/eventmesh/issues/5050) prepare for createTask, verify data
+- [Feature #5108](https://github.com/apache/eventmesh/issues/5108) Abstracting and transforming EventMeshFunction, and implementing FunctionRuntime.
+
+## Enhancement
+
+- [Enhancement #3095](https://github.com/apache/eventmesh/issues/3095) Method invocation may produce 'NullPointerException'[MessageUtils]
+- [Enhancement #3833](https://github.com/apache/eventmesh/issues/3833) Do some code optimization.[ZookeeperMetaService]
+- [Enhancement #3411](https://github.com/apache/eventmesh/issues/3411) Do some code optimization[ReplyMessageProcessor]
+- [Enhancement #3430](https://github.com/apache/eventmesh/issues/3430) Refactor eventmesh-metrics-prometheus module
+- [Enhancement #3824](https://github.com/apache/eventmesh/issues/3824) Do some code optimization.[MessageEntity]
+- [Enhancement #3830](https://github.com/apache/eventmesh/issues/3830) InterruptedExceptions should not be ignored in the code.[ProducerImpl]
+- [Enhancement #4095](https://github.com/apache/eventmesh/issues/4095) Code optimization. [EtcdCustomService]
+- [Enhancement #4540](https://github.com/apache/eventmesh/issues/4540) Unit test for ThreadUtils
+- [Enhancement #4633](https://github.com/apache/eventmesh/issues/4633) Optimize the message body of the Rust SDK's returned reply message
+- [Enhancement #4665](https://github.com/apache/eventmesh/issues/4665) Unify 'LiteMessage' to 'EventMeshMessage'
+- [Enhancement #4677](https://github.com/apache/eventmesh/issues/4677) Tcp Codec enhancement
+- [Enhancement #4686](https://github.com/apache/eventmesh/issues/4686) Shell scripts should preserve LF line endings
+- [Enhancement #4694](https://github.com/apache/eventmesh/issues/4694) operator needs to start each component in order, and the component CPU resource limit.
+- [Enhancement #4697](https://github.com/apache/eventmesh/issues/4697) Use Fluent Logging API to provide accurate, concise, and elegant logging
+- [Enhancement #4707](https://github.com/apache/eventmesh/issues/4707) Update rust sdk toolchain
+- [Enhancement #4712](https://github.com/apache/eventmesh/issues/4712) Add shutdown for nacosConfigService
+- [Enhancement #4728](https://github.com/apache/eventmesh/issues/4728) Deploy eventmesh-operator to a k8s cluster
+- [Enhancement #4731](https://github.com/apache/eventmesh/issues/4731) Optimize the HttpRequestProcessor can obtain executor
+- [Enhancement #4750](https://github.com/apache/eventmesh/issues/4750) Integrate Runtime admin endpoints with Netty server phase 1
+- [Enhancement #4767](https://github.com/apache/eventmesh/issues/4767) Integrate Runtime admin endpoints with Netty server phase 2
+- [Enhancement #4795](https://github.com/apache/eventmesh/issues/4795) Optimize OffsetStorageWriterImpl#beginFlush method handle logic
+- [Enhancement #4796](https://github.com/apache/eventmesh/issues/4796) Create thread pool using custom ThreadPoolFactory
+- [Enhancement #4873](https://github.com/apache/eventmesh/issues/4873) Optimize some configuration information of HTTP Sink Connector
+- [Enhancement #4990](https://github.com/apache/eventmesh/issues/4990) Unit test for HttpConvertsUtils.java
+- [Enhancement #4991](https://github.com/apache/eventmesh/issues/4991) Unit test For LogUtil.java
+- [Enhancement #4992](https://github.com/apache/eventmesh/issues/4992) Unit test for JsonPathUtils.java
+- [Enhancement #5020](https://github.com/apache/eventmesh/issues/5020) Optimize unit tests and code [HTTP Connector]
+- [Enhancement #5044](https://github.com/apache/eventmesh/issues/5044) Data synchronization strong verification in mariadb gtid mode
+- [Enhancement #5048](https://github.com/apache/eventmesh/issues/5048) Add report verify request to admin for connector runtime
+- [Enhancement #5052](https://github.com/apache/eventmesh/issues/5052) Enhancement for source\sink connector
+- [Enhancement #5067](https://github.com/apache/eventmesh/issues/5067) Enhancement for eventmesh-admin-server
+- [Enhancement #5069](https://github.com/apache/eventmesh/issues/5069) Enhancement for http source/sink connector
+- [Enhancement #5071](https://github.com/apache/eventmesh/issues/5071) Enhancement for admin server and canal source/sink connector
+- [Enhancement #5073](https://github.com/apache/eventmesh/issues/5073) Fix eventmesh-admin-server createTask response error
+- [Enhancement #5075](https://github.com/apache/eventmesh/issues/5075) update eventmesh-admin-server create task response
+- [Enhancement #5077](https://github.com/apache/eventmesh/issues/5077) HTTP Sink Connector supports result callback
+- [Enhancement #5079](https://github.com/apache/eventmesh/issues/5079) Enhancement update for admin-server
+- [Enhancement #5081](https://github.com/apache/eventmesh/issues/5081) Enhancement update for connectors & admin-server
+- [Enhancement #5092](https://github.com/apache/eventmesh/issues/5092) Add test for EtcdCustomService.java
+- [Enhancement #5101](https://github.com/apache/eventmesh/issues/5101) Define and standardize some common configurations for all Sources
+- [Enhancement #5137](https://github.com/apache/eventmesh/issues/5137) update connector runtime v2 module
+- [Enhancement #5139](https://github.com/apache/eventmesh/issues/5139) update canal connector module
+- [Enhancement #5141](https://github.com/apache/eventmesh/issues/5141) update eventmesh-admin-server module
+- [Enhancement #5144](https://github.com/apache/eventmesh/issues/5144) update eventmesh-connector-http module
+
+## Bug
+
+- [Bug #4630](https://github.com/apache/eventmesh/issues/4630) Fix concurrency problem and split task handle threadpool
+- [Bug #4667](https://github.com/apache/eventmesh/issues/4667) Some connectors have not been included in the package
+- [Bug#4670](https://github.com/apache/eventmesh/issues/4670) Docker build failed due to a low JDK version
+- [Bug #4690](https://github.com/apache/eventmesh/issues/4690) Kafka Connector failed to start
+- [Bug #4695](https://github.com/apache/eventmesh/issues/4695) TcpClient not thread safety.
+- [Bug #4701](https://github.com/apache/eventmesh/issues/4701) Use tcp protocol client send message, it throw a DecoderException
+- [Bug #4723](https://github.com/apache/eventmesh/issues/4723) Can not obtain metadata when nacos enable authentication
+- [Bug #4770](https://github.com/apache/eventmesh/issues/4770) Empty class member cause NullpointerException
+- [Bug #4778](https://github.com/apache/eventmesh/issues/4778) Standalone MessageQueue does not down counter when dequeue
+- [Bug #4820](https://github.com/apache/eventmesh/issues/4820) EventHandler missing return json
+- [Bug #4855](https://github.com/apache/eventmesh/issues/4855) close tcp client failed
+- [Bug #5105](https://github.com/apache/eventmesh/issues/5105) Fix the retry mechanism of the HttpSinkConnector.
+- [Bug #5127](https://github.com/apache/eventmesh/issues/5127) Create topic error in Standalone mode
+
+## Doc
+
+- [Doc #4671](https://github.com/apache/eventmesh/issues/4671) Update LICENSE and NOTICE
+- [Doc #4683](https://github.com/apache/eventmesh/issues/4683) Documentation Needed for eventmesh-connector-redis
+- [Doc #4710](https://github.com/apache/eventmesh/issues/4710) Rewrite quick start and add operator deployment steps.
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/01-runtime-protocol.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/01-runtime-protocol.md
new file mode 100644
index 000000000..88c920393
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/01-runtime-protocol.md
@@ -0,0 +1,401 @@
+# EventMesh Runtime Protocol
+
+## TCP Protocol
+
+### Protocol Format
+
+|Name|Size|Description|
+|-|-|-|
+|Magic Code|9 bytes|Default: `EventMesh`|
+|Protocol Version|4 bytes|Default: `0000`|
+|Message Size|4 bytes|The total length of the message|
+|Header Size|4 bytes|The length of the message header|
+|Message Body||The content of the message|
+
+### Message Object in the Business Logic Layer
+
+#### Message Composition
+
+The `Package` class in the [`Package.java` file](https://github.com/apache/eventmesh/blob/master/eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/tcp/Package.java) is the TCP message object used in business logic layer. The class contains the `header` and `body` fields.
+
+```java
+public class Package {
+ private Header header;
+ private Object body;
+}
+
+public class Header {
+ private Command cmd;
+ private int code;
+ private String msg;
+ private String seq;
+}
+```
+
+#### Specification
+
+- Message Header (the `header` field): The `cmd` field in the `Header` class specifies the different types of messages.
+- Message Body (the `body` field): The type of the message body should be defined based on `cmd` field in the `Header` class.
+
+|Command|Type of Body|
+|-|-|
+| HEARTBEAT_REQUEST, HEARTBEAT_RESPONSE, HELLO_RESPONSE, CLIENT_GOODBYE_REQUEST, CLIENT_GOODBYE_RESPONSE, SERVER_GOODBYE_REQUEST, SERVER_GOODBYE_RESPONSE, LISTEN_REQUEST, LISTEN_RESPONSE, UNSUBSCRIBE_REQUEST, SUBSCRIBE_RESPONSE, UNSUBSCRIBE_RESPONSE, ASYNC_MESSAGE_TO_SERVER_ACK, BROADCAST_MESSAGE_TO_SERVER_ACK|N/A|
+|HELLO_REQUEST|UserAgent|
+|SUBSCRIBE_REQUEST|Subscription|
+| REQUEST_TO_SERVER, REQUEST_TO_CLIENT, RESPONSE_TO_SERVER, RESPONSE_TO_CLIENT, ASYNC_MESSAGE_TO_SERVER, ASYNC_MESSAGE_TO_CLIENT, BROADCAST_MESSAGE_TO_SERVER, BROADCAST_MESSAGE_TO_CLIENT, ASYNC_MESSAGE_TO_CLIENT_ACK, BROADCAST_MESSAGE_TO_CLIENT_ACK, RESPONSE_TO_CLIENT_ACK, REQUEST_TO_CLIENT_ACK|OpenMessage|
+|REDIRECT_TO_CLIENT|RedirectInfo|
+
+### Example of Client-Server Interaction
+
+```java
+public enum Command {
+ // Heartbeat
+ HEARTBEAT_REQUEST(0), // Client send heartbeat request to server
+ HEARTBEAT_RESPONSE(1), // Server reply heartbeat response to client
+
+ // Hello
+ HELLO_REQUEST(2), // Client send connect request to server
+ HELLO_RESPONSE(3), // Server reply connect response to client
+
+ // Disconncet
+ CLIENT_GOODBYE_REQUEST(4), // Client send disconnect request to server
+ CLIENT_GOODBYE_RESPONSE(5), // Server reply disconnect response to client
+ SERVER_GOODBYE_REQUEST(6), // Server send disconncet request to client
+ SERVER_GOODBYE_RESPONSE(7), // Client reply disconnect response to server
+
+ // Subscribe and UnSubscribe
+ SUBSCRIBE_REQUEST(8), // Slient send subscribe request to server
+ SUBSCRIBE_RESPONSE(9), // Server reply subscribe response to client
+ UNSUBSCRIBE_REQUEST(10), // Client send unsubscribe request to server
+ UNSUBSCRIBE_RESPONSE(11), // Server reply unsubscribe response to client
+
+ // Listen
+ LISTEN_REQUEST(12), // Client send listen request to server
+ LISTEN_RESPONSE(13), // Server reply listen response to client
+
+ // Send sync message
+ REQUEST_TO_SERVER(14), // Client (Producer) send sync message to server
+ REQUEST_TO_CLIENT(15), // Server push sync message to client(Consumer)
+ REQUEST_TO_CLIENT_ACK(16), // Client (Consumer) send ack of sync message to server
+ RESPONSE_TO_SERVER(17), // Client (Consumer) send reply message to server
+ RESPONSE_TO_CLIENT(18), // Server push reply message to client(Producer)
+ RESPONSE_TO_CLIENT_ACK(19), // Client (Producer) send acknowledgement of reply message to server
+
+ // Send async message
+ ASYNC_MESSAGE_TO_SERVER(20), // Client send async msg to server
+ ASYNC_MESSAGE_TO_SERVER_ACK(21), // Server reply ack of async msg to client
+ ASYNC_MESSAGE_TO_CLIENT(22), // Server push async msg to client
+ ASYNC_MESSAGE_TO_CLIENT_ACK(23), // Client reply ack of async msg to server
+
+ // Send broadcast message
+ BROADCAST_MESSAGE_TO_SERVER(24), // Client send broadcast msg to server
+ BROADCAST_MESSAGE_TO_SERVER_ACK(25), // Server reply ack of broadcast msg to client
+ BROADCAST_MESSAGE_TO_CLIENT(26), // Server push broadcast msg to client
+ BROADCAST_MESSAGE_TO_CLIENT_ACK(27), // Client reply ack of broadcast msg to server
+
+ // Redirect
+ REDIRECT_TO_CLIENT(30), // Server send redirect instruction to client
+}
+```
+
+### Client-Initiated Interaction
+
+|Scene|Client Request|Server Response|
+|-|-|-|
+| Hello | HELLO_REQUEST | HELLO_RESPONSE | |
+| Heartbeat | HEARTBEAT_REQUEST | HEARTBEAT_RESPONSE | |
+| Subscribe | SUBSCRIBE_REQUEST | SUBSCRIBE_RESPONSE | |
+| Unsubscribe | UNSUBSCRIBE_REQUEST | UNSUBSCRIBE_RESPONSE | |
+| Listen | LISTEN_REQUEST | LISTEN_RESPONSE | |
+| Send sync message | REQUEST_TO_SERVER | RESPONSE_TO_CLIENT | |
+| Send the response of sync message| RESPONSE_TO_SERVER | N/A | |
+| Send async message | ASYNC_MESSAGE_TO_SERVER | ASYNC_MESSAGE_TO_SERVER_ACK | |
+| Send broadcast message | BROADCAST_MESSAGE_TO_SERVER | BROADCAST_MESSAGE_TO_SERVER_ACK | |
+| Client start to disconnect | CLIENT_GOODBYE_REQUEST | CLIENT_GOODBYE_RESPONSE | |
+
+### Server-Initiated Interaction
+
+|Scene|Server Request|Client Response|Remark|
+|-|-| ------------------------------- | ---- |
+| Push sync message to client | REQUEST_TO_CLIENT | REQUEST_TO_CLIENT_ACK | |
+| Push the response message of sync message to client | RESPONSE_TO_CLIENT | RESPONSE_TO_CLIENT_ACK | |
+| Push async message to client | ASYNC_MESSAGE_TO_CLIENT | ASYNC_MESSAGE_TO_CLIENT_ACK | |
+| Push broadcast message to client | BROADCAST_MESSAGE_TO_CLIENT | BROADCAST_MESSAGE_TO_CLIENT_ACK | |
+| Server start to disconnect | SERVER_GOODBYE_REQUEST | -- | |
+| Server send redirect | REDIRECT_TO_CLIENT | -- | |
+
+### Type of Message
+
+#### Sync Message
+
+
+
+#### Async Message
+
+
+
+#### Boardcast Message
+
+
+
+## HTTP Protocol
+
+### Protocol Format
+
+The `EventMeshMessage` class in the [`EventMeshMessage.java` file](https://github.com/apache/eventmesh/blob/master/eventmesh-common/src/main/java/org/apache/eventmesh/common/EventMeshMessage.java) is the HTTP message definition of EventMesh Runtime.
+
+```java
+public class EventMeshMessage {
+ private String bizSeqNo;
+
+ private String uniqueId;
+
+ private String topic;
+
+ private String content;
+
+ private Map<String, String> prop;
+
+ private final long createTime = System.currentTimeMillis();
+}
+```
+
+### HTTP Post Request
+
+#### Heartbeat Message
+
+##### Request Header
+
+| Key | Description |
+| -------- | ---------------- |
+| Env | Enviroment of Client |
+| Region | Region of Client |
+| Idc | IDC of Client |
+| Dcn | DCN of Client |
+| Sys | Subsystem ID of Client |
+| Pid | Client Process ID |
+| Ip | Client Ip |
+| Username | Client username |
+| Passwd | Client password |
+| Version | Protocol version |
+| Language | Develop language |
+| Code | Request Code |
+
+##### Request Body
+
+|Key|Description|
+|-|-|
+|`clientType`|`ClientType.PUB` for Producer, `ClientType.SUB` for Consumer|
+|`heartbeatEntities`|Topic, URL, etc.|
+
+#### Subscribe Message
+
+##### Request Header
+
+The request header of the Subscribe message is identical to the request header of the Heartbeat message.
+
+##### Request Body
+
+|Key|Description|
+|-|-|
+|`topic`|The topic that the client requested to subscribe to|
+|`url`|The callback URL of the client|
+
+#### Unsubscribe Message
+
+##### Request Header
+
+The request header of the Unsubscribe message is identical to the request header of the Heartbeat message.
+
+##### Request Body
+
+The request body of the Unsubscribe message is identical to the request body of the Subscribe message.
+
+#### Send Async Message
+
+##### Request Header
+
+The request header of the Send Async message is identical to the request header of the Heartbeat message.
+
+##### Request Body
+
+|Key|Description|
+|-|-|
+|`topic`|Topic of the message|
+|`content`|The content of the message|
+|`ttl`|The time-to-live of the message|
+|`bizSeqNo`|The biz sequence number of the message|
+|`uniqueId`|The unique ID of the message|
+
+### Client-Initiated Interaction
+
+|Scene|Client Request|Server Response|Remark|
+|-|-|-|-|
+| Heartbeat | HEARTBEAT(203) | SUCCESS(0) or EVENTMESH_HEARTBEAT_ERROR(19) | |
+| Subscribe | SUBSCRIBE(206) | SUCCESS(0) or EVENTMESH_SUBSCRIBE_ERROR(17) | |
+| Unsubscribe | UNSUBSCRIBE(207) | SUCCESS(0) or EVENTMESH_UNSUBSCRIBE_ERROR(18) | |
+| Send async message | MSG_SEND_ASYNC(104) | SUCCESS(0) or EVENTMESH_SEND_ASYNC_MSG_ERR(14) | |
+
+### Server-Initiated Interaction
+
+|Scene|Client Request|Server Response|Remark|
+|-|-|-|-|
+|Push async message to the client|HTTP_PUSH_CLIENT_ASYNC(105)|`retCode`|The push is successful if the `retCode` is `0`|
+
+## gRPC Protocol
+
+### Protobuf
+
+The `eventmesh-protocol-gprc` module contains the [protobuf definition file](https://github.com/apache/eventmesh/blob/master/eventmesh-protocol-plugin/eventmesh-protocol-grpc/src/main/proto/eventmesh-client.proto) of the EventMesh client. The `gradle build` command generates the gRPC codes, which are located in `/build/generated/source/proto/main`. The generated gRPC codes are used in `eventmesh-sdk-java` module.
+
+### Data Model
+
+#### Message
+
+The message data model used by `publish()`, `requestReply()` and `broadcast()` APIs is defined as:
+
+```protobuf
+message RequestHeader {
+ string env = 1;
+ string region = 2;
+ string idc = 3;
+ string ip = 4;
+ string pid = 5;
+ string sys = 6;
+ string username = 7;
+ string password = 8;
+ string language = 9;
+ string protocolType = 10;
+ string protocolVersion = 11;
+ string protocolDesc = 12;
+}
+
+message SimpleMessage {
+ RequestHeader header = 1;
+ string producerGroup = 2;
+ string topic = 3;
+ string content = 4;
+ string ttl = 5;
+ string uniqueId = 6;
+ string seqNum = 7;
+ string tag = 8;
+ map<string, string> properties = 9;
+}
+
+message BatchMessage {
+ RequestHeader header = 1;
+ string producerGroup = 2;
+ string topic = 3;
+
+ message MessageItem {
+ string content = 1;
+ string ttl = 2;
+ string uniqueId = 3;
+ string seqNum = 4;
+ string tag = 5;
+ map<string, string> properties = 6;
+ }
+
+ repeated MessageItem messageItem = 4;
+}
+
+message Response {
+ string respCode = 1;
+ string respMsg = 2;
+ string respTime = 3;
+}
+```
+
+#### Subscription
+
+The subscription data model used by `subscribe()` and `unsubscribe()` APIs is defined as:
+
+```protobuf
+message Subscription {
+ RequestHeader header = 1;
+ string consumerGroup = 2;
+
+ message SubscriptionItem {
+ enum SubscriptionMode {
+ CLUSTERING = 0;
+ BROADCASTING = 1;
+ }
+
+ enum SubscriptionType {
+ ASYNC = 0;
+ SYNC = 1;
+ }
+
+ string topic = 1;
+ SubscriptionMode mode = 2;
+ SubscriptionType type = 3;
+ }
+
+ repeated SubscriptionItem subscriptionItems = 3;
+ string url = 4;
+}
+```
+
+#### Heartbeat
+
+The heartbeat data model used by the `heartbeat()` API is defined as:
+
+```protobuf
+message Heartbeat {
+ enum ClientType {
+ PUB = 0;
+ SUB = 1;
+ }
+
+ RequestHeader header = 1;
+ ClientType clientType = 2;
+ string producerGroup = 3;
+ string consumerGroup = 4;
+
+ message HeartbeatItem {
+ string topic = 1;
+ string url = 2;
+ }
+
+ repeated HeartbeatItem heartbeatItems = 5;
+}
+```
+
+### Service Definition
+
+#### Event Publisher Service
+
+```protobuf
+service PublisherService {
+ // Async event publish
+ rpc publish(SimpleMessage) returns (Response);
+
+ // Sync event publish
+ rpc requestReply(SimpleMessage) returns (Response);
+
+ // Batch event publish
+ rpc batchPublish(BatchMessage) returns (Response);
+}
+```
+
+#### Event Consumer Service
+
+```protobuf
+service ConsumerService {
+ // The subscribed event will be delivered by invoking the webhook url in the Subscription
+ rpc subscribe(Subscription) returns (Response);
+
+ // The subscribed event will be delivered through stream of Message
+ rpc subscribeStream(Subscription) returns (stream SimpleMessage);
+
+ rpc unsubscribe(Subscription) returns (Response);
+}
+```
+
+#### Client Hearthbeat Service
+
+```protobuf
+service HeartbeatService {
+ rpc heartbeat(Heartbeat) returns (Response);
+}
+```
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/02-https.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/02-https.md
new file mode 100644
index 000000000..8dcd90ee3
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/02-https.md
@@ -0,0 +1,30 @@
+# HTTPS
+
+1. Configuration in eventmesh-runtime
+
+```
+eventMesh.properties (add the following configurations)
+eventMesh.server.useTls.enabled=true // Default value: false
+
+Configuring environment variable
+-Dssl.server.protocol=TLSv1.1 // Default value: TLSv1.1
+-Dssl.server.cer=sChat2.jks // Place the file in the conPath directory specified by the startup script start.sh
+-Dssl.server.pass=sNetty
+```
+
+2. Configuration in eventmesh-sdk-java
+
+```
+// Create a producer
+LiteClientConfig eventMeshHttpClientConfig = new LiteClientConfig();
+...
+
+// Enable TLS
+eventMeshHttpClientConfig.setUseTls(true);
+LiteProducer producer = new LiteProducer(eventMeshHttpClientConfig);
+
+// Configure environment variables
+-Dssl.client.protocol=TLSv1.1 // Default value: TLSv1.1
+-Dssl.client.cer=sChat2.jks // Place the file in the conPath directory specified by the application
+-Dssl.client.pass=sNetty
+```
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/03-cloudevents.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/03-cloudevents.md
new file mode 100644
index 000000000..0f1a8a3c1
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/03-cloudevents.md
@@ -0,0 +1,106 @@
+# CloudEvents Integration
+
+## Introduction
+
+[CloudEvents](https://github.com/cloudevents/spec) is a specification for describing event data in common formats to provide interoperability across services, platforms and systems.
+
+As of May 2021, EventMesh contains the following major components: `eventmesh-runtime`, `eventmesh-sdk-java` and `eventmesh-connector-rocketmq`.
+For a customer to use EventMesh, `eventmesh-runtime` can be deployed as microservices to transmit
+customer's events between event producers and consumers. Customer's applications can then interact
+with `eventmesh-runtime` using `eventmesh-sdk-java` to publish/subscribe for events on given topics.
+
+CloudEvents support has been a highly desired feature by EventMesh users. There are many reasons
+for users to prefer using a SDK with CloudEvents support:
+
+- CloudEvents is a more widely accepted and supported way to describe events. `eventmesh-sdk-java`
+ currently uses the `EventMeshMessage` structure to describe events, which is less standardized.
+- CloudEvents's Java SDK has a wider range of distribution methods. For example, EventMesh users
+ currently need to use the SDK tarball or build from source for every EventMesh release. With
+ CloudEvents support, it's easier for users to take a dependency on EventMesh's SDK using CloudEvents's public distributions (e.g. through a Maven configuration).
+- CloudEvents's SDK supports multiple languages. Although EventMesh currently only supports a Java SDK, in future if more languages need to be supported, the extensions can be easier with experience on binding Java SDK with CloudEvents.
+
+## Requirements
+
+### Functional Requirements
+
+| Requirement ID | Requirement Description | Comments |
+| -------------- | ----------------------- | -------- |
+| F-1 | EventMesh users should be able to depend on a public SDK to publish/subscribe events in CloudEvents format | Functionality |
+| F-2 | EventMesh users should continue to have access to existing EventMesh client features (e.g. load balancing) with an SDK that supports CloudEvent | Feature Parity |
+| F-3 | EventMesh developers should be able to sync `eventmesh-sdk-java` and an SDK with CloudEvents support without much effort/pain | Maintainability |
+| F-4 | EventMesh support pluggable protocols for developers integrate other protocols (e.g. CloudEvents\EventMesh Message\OpenMessage\MQTT ...) | Functionality |
+| F-5 | EventMesh support the unified api for publish/subscribe events to/from Event Store | Functionality |
+
+### Performance Requirements
+
+| Requirement ID | Requirement Description | Comments |
+| -------------- | ----------------------- | -------- |
+| P-1 | Client side latency for SDK with CloudEvents support should be similar to current SDK | |
+
+## Design Details
+
+Binding with the CloudEvents Java SDK (similar to what Kafka already did, see Reference for more details)
+should be an easy way to achieve the requirements.
+
+### Pluggable Protocols
+
+
+
+### Process of CloudEvents under EventMesh
+
+#### For TCP
+
+##### SDK side for publish
+
+- add the CloudEvents identifier in `package` header
+- use `CloudEventBuilder` build the CloudEvent and put it into the `package` body
+
+##### SDK side for subscribe
+
+- add `convert` function under the `ReceiveMsgHook` interface, for converting the `package` body to the specific protocol with the identifier in `package` header
+- different protocols should implement the `ReceiveMsgHook` interface
+
+##### Server side for publish
+
+- design the protocol convert api contains `decodeMessage` interface which convert the package's body to CloudEvent
+- update `Session.upstreamMsg()` in `MessageTransferTask` change the input parameter Message to CloudEvent, the CloudEvent use the last step `decodeMessage` api convert
+- update `SessionSender.send()` change the input parameter `Message` to `CloudEvent`
+- update `MeshMQProducer` api support send `CloudEvents` in runtime
+- support the implementation in `connector-plugin` for send `CloudEvents` to EventStore
+
+##### Server side for subscribe
+
+- support change the `RocketMessage` to `CloudEvent` in connector-plugin
+
+- overwrite the `AsyncMessageListener.consume()` function, change the input parameter `Message` to `CloudEvent`
+
+- update the `MeshMQPushConsumer.updateOffset()` implementation change the the input parameter `Message` to `CloudEvent`
+
+- update `DownStreamMsgContext` , change the input parameter `Message` to `CloudEvent`, update the `DownStreamMsgContext.ackMsg`
+
+#### For HTTP
+
+##### SDK side for publish
+
+- support `LiteProducer.publish(cloudEvent)`
+- add the CloudEvents identifier in http request header
+
+##### SDK side for subscribe
+
+##### Server side for publish
+
+- support build the `HttpCommand.body` by pluggable protocol plugins according the protocol type in `HttpCommand` header
+- support publish the CloudEvent in message processors
+
+##### Server side for subscribe
+
+- update the `EventMeshConsumer.subscribe()`
+
+- update `HandleMsgContext` , change the input parameter `Message` to `CloudEvent`
+- update `AsyncHttpPushRequest.tryHTTPRequest()`
+
+## Appendix
+
+### References
+
+- <https://cloudevents.github.io/sdk-java/kafka>
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/04-event-bridge.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/04-event-bridge.md
new file mode 100644
index 000000000..09d2a433e
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/04-event-bridge.md
@@ -0,0 +1,156 @@
+# Event Bridge
+
+
+
+Event Bridge supports message delivery across mesh clusters. Below is a detailed design and experience steps for this feature.
+
+
+
+> Note: To experience this feature locally, you need to start two EventMesh instances and modify the port configuration in the `eventmesh-runtime` directory's `eventmesh.properties` file to avoid port conflicts. For the sake of the following descriptions, the event-bridge feature is presented according to the information in the above diagram.
+
+## 01 Remote Subscription
+
+**Description**: Initiates a remote subscription command to cluster2 EventMesh. Upon receiving the command, cluster2 EventMesh will invoke the local subscription interface of cluster1 EventMesh with the subscription information.
+
+**URL**: http://{cluster2 address}/eventmesh/subscribe/remote
+
+**Request Method**: POST
+
+**Request Parameters**: application/json format
+
+| Parameter | Type | Required | Description |
+| -------------- | ------ | -------- | ------------------------------------------------------------ |
+| url | String | Yes | Identifies the subscription URL, temporarily useless, will be replaced by (/eventmesh/bridge/publish) later, currently only for strong validation, will actually be replaced by the cluster2 EventMesh configuration information |
+| consumerGroup | String | Yes | Identifies the consumer group information, will be replaced by the configuration information of cluster2 EventMesh |
+| topic | List | Yes | Identifies the subscription information list |
+| mode | String | Yes | Identifies the consumption mode, divided into clustering mode and broadcast mode |
+| topic | String | Yes | Identifies the subscribed topic |
+| type | String | Yes | Identifies the consumption type, divided into synchronous and asynchronous |
+| remoteMesh | String | No | Identifies the remote mesh address, prioritized by obtaining from the registration center based on the topic, if not obtained, use this field to replace |
+
+**Request Example**:
+
+```json
+{
+ "url": "http://127.0.0.1:8088/sub/test",
+ "consumerGroup": "TEST-GROUP",
+ "topic": [
+ {
+ "mode": "CLUSTERING",
+ "topic": "TEST-TOPIC-HTTP-ASYNC",
+ "type": "ASYNC"
+ }
+ ],
+ "remoteMesh" : "http://127.0.0.1:10105/eventmesh/subscribe/local"
+}
+```
+
+## 02 Local Subscription
+
+**Description**: Initiates a local subscription command to cluster2 EventMesh. Upon receiving the subscription command, cluster2 EventMesh will start locally listening for messages received from Event Store and push them to the URL in the subscription information.
+
+**URL**: http://{cluster2 address}/eventmesh/subscribe/local
+
+**Request Method**: POST
+
+**Request Parameters**: application/json format
+
+| Parameter | Type | Required | Description |
+| -------------- | ------ | -------- | ------------------------------------------------------------ |
+| url | String | Yes | Identifies the subscription URL |
+| consumerGroup | String | Yes | Identifies the consumer group information |
+| topic | List | Yes | Identifies the subscription information list |
+| mode | String | Yes | Identifies the consumption mode, divided into clustering mode and broadcast mode |
+| topic | String | Yes | Identifies the subscribed topic |
+| type | String | Yes | Identifies the consumption type, divided into synchronous and asynchronous |
+
+**Request Example**:
+
+```JSON
+{
+ "url": "http://127.0.0.1:8088/sub/test",
+ "consumerGroup": "TEST-GROUP",
+ "topic": [
+ {
+ "mode": "CLUSTERING",
+ "topic": "TEST-TOPIC-HTTP-ASYNC",
+ "type": "ASYNC"
+ }
+ ]
+}
+```
+
+## 03 Send Message
+
+**Description**: Sends a message to cluster1 EventMesh. Upon receiving the message, cluster1 EventMesh will send it to Event Store, and then push the message received from Event Store to the URL `/eventmesh/bridge/publish` of cluster2 EventMesh.
+
+**URL**: http://{cluster1 address}/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC
+
+**Request Method**: POST
+
+**Request Parameters**: application/json format
+
+**Request Example**:
+
+```json
+{
+ "name":"test",
+ "age":"19"
+}
+```
+
+## 04 Remote Unsubscribe
+
+**Description**: Sends an unsubscribe command to cluster2 EventMesh. Upon receiving the command, cluster2 EventMesh will send it to cluster1 EventMesh, and cluster1 EventMesh will locally execute the unsubscribe.
+
+**URL**: http://{cluster2 address}/eventmesh/unsubscribe/remote
+
+**Request Method**: POST
+
+**Request Parameters**: application/json format
+
+| Parameter | Type | Required | Description |
+| -------------- | ------ | -------- | ------------------------------------------------------------ |
+| url | String | Yes | Identifies the URL to unsubscribe, temporarily useless, will be replaced by (/eventmesh/bridge/publish) later, currently only for strong validation, will actually be replaced by the group information of cluster2 eventmesh |
+| consumerGroup | String | Yes | Identifies the consumer group information to unsubscribe from, will use the group information of EventMesh cluster2 to replace |
+| topic | List | Yes | Identifies the subscription topic information list |
+
+**Request Example**:
+
+```json
+{
+ "consumerGroup": "EventMeshTest-consumerGroup",
+ "url": "http://127.0.0.1:8088/sub/test",
+ "topic": [
+ "TEST-TOPIC-HTTP-ASYNC"
+ ]
+}
+```
+
+## 05 Local Unsubscribe
+
+**Description**: Sends an unsubscribe command to cluster2 EventMesh. Upon receiving the command, cluster2 EventMesh will locally execute the unsubscribe.
+
+**URL**: http://{cluster2 address}/eventmesh/unsubscribe/local
+
+**Request Method**: POST
+
+**Request Parameters**: application/json format
+
+| Parameter | Type | Required | Description |
+| -------------- | ------ | -------- | ---------------------------- |
+| url | String | Yes | Identifies the URL to unsubscribe from |
+| consumerGroup | String | Yes | Identifies the consumer group information to unsubscribe from |
+| topic | List | Yes | Identifies the subscription topic information list |
+
+**Request Example**:
+
+```json
+{
+ "consumerGroup": "EventMeshTest-consumerGroup",
+ "url": "http://127.0.0.1:8088/sub/test",
+ "topic": [
+ "TEST-TOPIC-HTTP-ASYNC"
+ ]
+}
+```
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/05-webhook.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/05-webhook.md
new file mode 100644
index 000000000..f426b28f7
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/05-webhook.md
@@ -0,0 +1,324 @@
+# Use Webhook to subscribe events
+## Webhook usage process
+
+### The first step: Configure Webhook related information in EventMesh and start
+
+Configuration:
+
+```
+# Webhook HTTP payload listening port
+eventMesh.server.http.port=10105
+# Webhook config admin port
+eventMesh.server.admin.http.port=10106
+
+# Whether to start the Webhook admin service
+eventMesh.webHook.admin.start=true
+
+# Webhook event configuration storage mode. But currently only supports file and nacos
+eventMesh.webHook.operationMode=file
+
+# The file path of fileMode. If you write #{eventMeshHome}, in the eventMesh root directory
+eventMesh.webHook.fileMode.filePath= #{eventMeshHome}/webhook
+
+# The nacos storage mode. The configuration naming rule is eventMesh.webHook.nacosMode.{nacos native configuration key} For the specific configuration, please see [nacos github api](https://github.com/alibaba/nacos/blob/develop/api/src/main/java /com/alibaba/nacos/api/SystemPropertyKeyConst.java)
+## address of nacos
+eventMesh.webHook.nacosMode.serverAddr=127.0.0.1:8848
+
+# Webhook CloudEvent sending mode. This property is the same as the eventMesh.storage.plugin.type configuration.
+eventMesh.webHook.producer.connector=standalone
+```
+
+### The second step: Add Webhook configuration information
+
+Configuration information description:
+
+```java
+ /**
+ * The path called by the manufacturer. Manufacturer event call address, [http or https]://[domain or IP]:[port]/webhook/[callbackPath]
+ * for example: http://127.0.0.1:10105/webhook/test/event , The full url needs to be filled in the manufacturer call input
+ * callbackPath is the only
+ */
+ private String callbackPath;
+
+ /**
+ * manufacturer name, like github
+ */
+ private String manufacturerName;
+
+ /**
+ * manufacturer domain name, like www.github.com
+ */
+ private String manufacturerDomain;
+
+ /**
+ * Webhook event name, like rep-push
+ */
+ private String manufacturerEventName;
+
+ /**
+ * http header content type
+ */
+ private String contentType = "application/json";
+
+ /**
+ * description of this WebHookConfig
+ */
+ private String description;
+
+ /**
+ * secret key, for authentication
+ */
+ private String secret;
+
+ /**
+ * userName, for HTTP authentication
+ */
+ private String userName;
+
+ /**
+ * password, for HTTP authentication
+ */
+ private String password;
+
+ /**
+ * roll out event name, like topic to mq
+ */
+ private String cloudEventName;
+
+ /**
+ * roll out data format -> CloudEvent serialization mode
+ * If HTTP protocol is used, the request header contentType needs to be marked
+ */
+ private String dataContentType = "application/json";
+
+ /**
+ * id of cloudEvent, like uuid/manufacturerEventId
+ */
+ private String cloudEventIdGenerateMode;
+
+```
+
+#### Add WebHook config
+
+path: /webhook/insertWebHookConfig
+
+method: POST
+
+contentType: application/json
+
+input params:
+
+| field | desc | type | necessary | default |
+| -- | -- | -- | -- | -- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | manufacturer name | string | Y | null |
+| manufacturerDomain | manufacturer domain name | string | Y | null |
+| manufacturerEventName | manufacturer event name | string | Y | null |
+| contentType | http connettype | string | N | application/json |
+| description | configuration instructions | string | N | null |
+| secret | signature string | string | N | null |
+| userName | username | string | N | null |
+| password | password | string | N | null |
+| cloudEventName | cloudEvent name | string | Y | null |
+| cloudEventIdGenerateMode | cloudEvent event object identification method, uuid or event id | string | N |manufacturerEventId|
+
+E.g:
+
+```json
+{
+ "callbackPath":"/webhook/github/eventmesh/all",
+ "manufacturerName":"github",
+ "manufacturerDomain":"www.github.com",
+ "manufacturerEventName":"all",
+ "cloudEventName":"github-eventmesh"
+}
+```
+
+Output params: 1 for success, 0 for failure
+
+#### Query WebHook config by callback path
+
+path: /webhook/queryWebHookConfigById
+
+method: POST
+
+contentType： application/json
+
+input params:
+
+| field | desc | type | necessary | default |
+| -- | -- | -- | -- | -- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | the caller of this callbackPath belongs to | string | Y | null |
+
+E.g:
+
+```json
+{
+ "callbackPath":"/webhook/github/eventmesh/all",
+ "manufacturerName":"github"
+}
+```
+
+Output params:
+
+| field | desc | type | necessary | default |
+| -- | -- | -- | -- | -- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | manufacturer name | string | Y | null |
+| manufacturerDomain | manufacturer domain name | string | Y | null |
+| manufacturerEventName | manufacturer event name | string | Y | null |
+| contentType | http connettype | string | N | application/json |
+| description | configuration instructions | string | N | null |
+| secret | signature key | string | N | null |
+| userName | user name | string | N | null |
+| password | password | string | N | null |
+| cloudEventName | cloudEvent name | string | Y | null |
+| cloudEventIdGenerateMode | cloudEvent event object identification method, uuid or event id | string | N | manufacturerEventId |
+
+#### Query WebHook config by manufacturer
+
+path: /webhook/queryWebHookConfigByManufacturer
+
+method: POST
+
+contentType： application/json
+
+input params:
+
+| field | desc | type | necessary | default |
+| -- | -- | -- | -- | -- |
+| manufacturerName | manufacturer name | string | Y | null |
+| pageNum | page number of paging query | string | Y | null |
+| pageSize | page size of each page | string | Y | null |
+
+E.g:
+
+```json
+{
+ "manufacturerName":"github",
+ "pageNum":1,
+ "pageSize":2
+}
+```
+
+Output params:
+
+| field | desc | type | necessary | default |
+| -- | -- | -- | -- | -- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | manufacturer name | string | Y | null |
+| manufacturerDomain | manufacturer domain name | string | Y | null |
+| manufacturerEventName | manufacturer event name | string | Y | null |
+| contentType | http connettype | string | N | application/json |
+| description | configuration instructions | string | N | null |
+| secret | signature key | string | N | null |
+| userName | user name | string | N | null |
+| password | password | string | N | null |
+| cloudEventName | cloudEvent name | string | Y | null |
+| cloudEventIdGenerateMode | cloudEvent event object identification method, uuid or event id | string | N | manufacturerEventId |
+
+#### Update WebHook config
+
+path: /webhook/updateWebHookConfig
+
+method: POST
+
+contentType: application/json
+
+input params:
+
+| field | desc | type | necessary | default |
+| ------------------------ | ------------------------------------------------------------ | ------ | --------- | ------------------- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | manufacturer name | string | Y | null |
+| manufacturerDomain | manufacturer domain name | string | Y | null |
+| manufacturerEventName | manufacturer event name | string | Y | null |
+| contentType | http connettype | string | N | application/json |
+| description | configuration instructions | string | N | null |
+| secret | signature string | string | N | null |
+| userName | username | string | N | null |
+| password | password | string | N | null |
+| cloudEventName | cloudEvent name | string | Y | null |
+| cloudEventIdGenerateMode | cloudEvent event object identification method, uuid or event id | string | N | manufacturerEventId |
+
+E.g:
+
+```json
+{
+ "callbackPath":"/webhook/github/eventmesh/all",
+ "manufacturerName":"github",
+ "manufacturerDomain":"www.github.com",
+ "manufacturerEventName":"all",
+ "cloudEventName":"github-eventmesh"
+}
+```
+
+Output params: 1 for success, 0 for failure
+
+#### Delete WebHook config
+
+path: /webhook/deleteWebHookConfig
+
+method: POST
+
+contentType： application/json
+
+input params:
+
+| field | desc | type | necessary | default |
+| ---------------- | ------------------------------------------ | ------ | --------- | ------- |
+| callbackPath | call address, unique address | string | Y | null |
+| manufacturerName | the caller of this callbackPath belongs to | string | Y | null |
+
+E.g:
+
+```json
+{
+ "callbackPath":"/webhook/github/eventmesh/all",
+ "manufacturerName":"github"
+}
+```
+
+Output params: 1 for success, 0 for failure
+
+### The third step: Check if the configuration is successful
+
+1. file storage mode. Please go to the eventMesh.webHook.fileMode.filePath directory to view. The Filename is callbackPath.
+2. nacos storage mode. Please go to the nacos service configured by eventMesh.webHook.nacosMode.serverAddr to see this.
+
+### The fourth step: Configure the consumer of cloudevent
+
+### The fifth step: Configure Webhook related information in the manufacturer
+
+> For manufacturer's operation, please refer to [Manufacturer's Webhook operation instructions](#Manufacturer's-Webhook-operation-instructions).
+
+## Manufacturer's Webhook operation instructions
+
+### GitHub sign up
+
+#### The first step: Enter the corresponding project
+
+#### The second step: click setting
+
+
+
+#### The third step: click Webhooks
+
+
+
+#### The fourth step: Click on Add Webhook
+
+
+
+#### The fifth step: Fill in the Webhook information
+
+
+
+Payload URL: EventMesh service address and callbackPath, which must include the protocol header. For example, when the callback address `callbackPath` is `/webhook/github/eventmesh/all`, the Payload URL is `http://www.example.com:10105/webhook/github/eventmesh/all`.
+
+[http or https]://[domain or IP]:[port]/webhook/[callbackPath]
+
+Content type: http header content type
+
+Secret: signature string
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/06-workflow.md b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/06-workflow.md
new file mode 100644
index 000000000..76dd8b773
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/06-workflow.md
@@ -0,0 +1,261 @@
+# EventMesh Workflow
+
+## Business Problem
+
+Imaging you are building a simple Order Management System for an E-Commerce Store. The system should be able to receive and provision new orders from a store website. The provisioning process should be able to process all orders, handle payments, as well as process shipments.
+
+For high availability and high performance, you architect the system using event-driven architecture (EDA), and build microservice apps to handle store frontend, order management, payment processing, and shipment management. You deploy the whole system in a cloud environment. To handle high workloads, you leverage a messaging system to buffer the loads, and scale up multiple instances of microservices. The architecture could look similar to:
+
+
+
+While each microservice is acting on its own event channels, EventMesh plays a crucial role of doing Event Orchestration.
+
+We use [CNCF Serverless Workflow](https://serverlessworkflow.io/) to describe this Event Workflow Orchestration.
+
+## CNCF Serverless Workflow
+
+CNCF Serverless Workflow defines a vendor-neutral, open-source, and fully community-driven ecosystem for defining and running DSL-based workflows that target the Serverless technology domain.
+
+Serverless Workflow defines a Domain Specific Language (DSL) to describe stateful and stateless workflow-based orchestrations of serverless functions and microservices.
+
+More details could be found in its [official github site](https://github.com/serverlessworkflow/specification)
+
+## EventMesh Workflow
+
+We leverage Serverless Workflow DSL to describe the EventMesh workflow. Based on its spec, the workflow is consists of a series of workflow states used to describe the control-flow logic. At this time we only support event related workflow states. See the supported states in [Workflow DSL Design](#workflow-dsl-design-wip).
+
+A `workflow state` can include applicable `actions`, or services/functions that should be invoked during workflow execution. These `actions` can reference reusable `function` definitions which define how these functions/services should be invoked. They can also reference events that trigger event-based service invocations, and events to wait for that denote completion of such event-based service invocation completion.
+
+In EDA solution, we usually defined our event-driven microservice using AsyncAPI. Serverless workflow `function` definitions support defining invocation semantics using AsyncAPI. See [Using Funtions for AsyncAPI Service](https://github.com/serverlessworkflow/specification/blob/main/specification.md#using-functions-for-async-api-service-invocations) for more information.
+
+### AsyncAPI
+
+AsyncAPI is an open source initiative that seeks to improve the current state of Event-Driven Architectures (EDA).
+Our long-term goal is to make working with EDAs as easy as it is to work with REST APIs.
+That goes from documentation to code generation, discovery to event management.
+Most of the processes you apply to your REST APIs nowadays would be applicable to your event-driven/asynchronous APIs too.
+
+See AsyncAPI detail in the [official site](https://www.asyncapi.com/docs/guides)
+
+### Workflow Example
+
+In this example, we build the event-driven workflow of the Order management system above.
+
+First, we need to define AsyncAPI definitions for our microservice apps.
+
+- Online Store App
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Online Store application
+ version: '0.1.0'
+channels:
+ store/order:
+ subscribe:
+ operationId: newStoreOrder
+ message:
+ $ref : '#/components/NewOrder'
+
+```
+
+- Order Service
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Order Service
+ version: '0.1.0'
+channels:
+ order/inbound:
+ publish:
+ operationId: sendOrder
+ message:
+ $ref : '#/components/Order'
+ order/outbound:
+ subscribe:
+ operationId: processedOrder
+ message:
+ $ref : '#/components/Order'
+```
+
+- Payment Service
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Payment Service
+ version: '0.1.0'
+channels:
+ payment/inbound:
+ publish:
+ operationId: sendPayment
+ message:
+ $ref : '#/components/OrderPayment'
+ payment/outbound:
+ subscribe:
+ operationId: paymentReceipt
+ message:
+ $ref : '#/components/OrderPayment'
+```
+
+- Shipment Service
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Shipment Service
+ version: '0.1.0'
+channels:
+ shipment/inbound:
+ publish:
+ operationId: sendShipment
+ message:
+ $ref : '#/components/OrderShipment'
+```
+
+Once that is defined, we define the order workflow that describes our Order Management business logic.
+
+```yaml
+id: storeorderworkflow
+version: '1.0'
+specVersion: '0.8'
+name: Store Order Management Workflow
+states:
+ - name: Receive New Order Event
+ type: event
+ onEvents:
+ - eventRefs:
+ - NewOrderEvent
+ actions:
+ - eventRef:
+ triggerEventRef: OrderServiceSendEvent
+ resultEventRef: OrderServiceResultEvent
+ - eventRef:
+ triggerEventRef: PaymentServiceSendEvent
+ resultEventRef: PaymentServiceResultEvent
+ transition: Check Payment Status
+ - name: Check Payment Status
+ type: switch
+ dataConditions:
+ - name: Payment Successfull
+ condition: "${ .payment.status == 'success' }"
+ transition: Send Order Shipment
+ - name: Payment Denied
+ condition: "${ .payment.status == 'denied' }"
+ end: true
+ defaultCondition:
+ end: true
+ - name: Send Order Shipment
+ type: operation
+ actions:
+ - eventRef:
+ triggerEventRef: ShipmentServiceSendEvent
+ end: true
+events:
+ - name: NewOrderEvent
+ source: file://onlineStoreApp.yaml#newStoreOrder
+ type: asyncapi
+ kind: consumed
+ - name: OrderServiceSendEvent
+ source: file://orderService.yaml#sendOrder
+ type: asyncapi
+ kind: produced
+ - name: OrderServiceResultEvent
+ source: file://orderService.yaml#processedOrder
+ type: asyncapi
+ kind: consumed
+ - name: PaymentServiceSendEvent
+ source: file://paymentService.yaml#sendPayment
+ type: asyncapi
+ kind: produced
+ - name: PaymentServiceResultEvent
+ source: file://paymentService.yaml#paymentReceipt
+ type: asyncapi
+ kind: consumed
+ - name: ShipmentServiceSendEvent
+ source: file://shipmentService.yaml#sendShipment
+ type: asyncapi
+ kind: produced
+```
+
+The corresponding workflow diagram is the following:
+
+
+
+## EventMesh Workflow Engine
+
+In the following architecture diagram, the EventMesh Catalog, EventMesh Workflow Engine and EventMesh Runtime are running in three different processors.
+
+
+
+The steps running the workflow is the followings:
+
+1. Deploy the Publisher and Subscriber Apps in the environment.
+ Describe the App APIs using AsyncAPI, generate the asyncAPI yaml.
+ Register the Publisher and Subscriber Apps in EventMesh Catalog using AsyncAPI.
+
+2. Register the Serverless Workflow DSL in EventMesh Workflow Engine.
+
+3. EventMesh Workflow Engine query the EventMesh Catalog for Publisher and Subscribers required in Workflow DSL `function`
+
+4. Event-driven Apps are publish events to EventMesh Runtime to trigger the Workflow. EventMesh Workflow Engine also publish and subscribe events for orchestrating the events.
+
+### EventMesh Catalog Design
+
+EventMesh Catalog store the Publisher, Subscriber and Channel metadata. consists of the following modules:
+
+- AsyncAPI Parser
+
+ Using the SDK provided by AsyncAPI community (see [tool list](https://www.asyncapi.com/docs/community/tooling)),
+ parse and validated the AsyncAPI yaml inputs, and generate the AsyncAPI definition.
+
+- Publisher, Channel, Subscriber Modules
+
+ From the AsyncAPI definition store the Publisher, Subscriber and Channel information.
+
+### EventMesh Workflow Engine Design
+
+EventMesh Workflow Engine consists of the following modules:
+
+- Workflow Parser
+
+ Using the SDK provided by Serverless Workflow community (see supported [SDKs](https://github.com/serverlessworkflow/specification#sdks)),
+ parse and validated the workflow DSL inputs, and generate workflow definition.
+
+- Workflow Module
+
+ It manages a workflow instance life cycle, from create, start, stop to destroy.
+
+- State Module
+
+ It manages workflow state life cycle. We support the event-related states, and the supported state list below is Work-in-Progress.
+
+ | Workflow State | Description |
+ | --- | --- |
+ | Operation | Execute the AsyncAPI functions defined in the Actions |
+ | Event | Check if the defined Event matched, if so execute the defined AsyncAPI functions |
+ | Switch | Check the event is matched with the event-conditions, and execute teh defined AsyncAPI functions |
+ | Parallel | Execute the defined AsyncAPI functions in parallel |
+ | ForEach | Iterate the inputCollection and execute the defined AsyncAPI functions |
+
+- Action Module
+
+ It managed the functions inside the action.
+
+- Function Module
+
+ It manages the AsyncAPI functions by creating the publisher and/or subscriber in EventMesh Runtime, and manage the publisher/subscriber life cycle.
+
+ | AsyncAPI Operation | EventMesh Runtime |
+ | --- | --- |
+ | Publish | Publisher |
+ | Subscribe | Subscriber |
+
+- Event Module
+
+ It manages the CloudEvents data model, including event filter, correlation and transformation using the rules defined in the workflow DSL.
+
+- Retry Module
+
+ It manages the retry logic of the event publishing into EventMesh Runtime.
diff --git a/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/_category_.json b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/_category_.json
new file mode 100644
index 000000000..7706f4577
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-event-handling-and-integration/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Event Handling and Integration",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/design-document/01-spi.md b/versioned_docs/version-v1.11.0/design-document/01-spi.md
new file mode 100644
index 000000000..829145643
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/01-spi.md
@@ -0,0 +1,113 @@
+# Service Provider Interface
+
+## Introduction
+
+In order to improve scalability, EventMesh introduce the SPI (Service Provider Interface) mechanism, which can help to automatically find the concrete implementation
+class of the extended interface at runtime and load it dynamically. In EventMesh, all extension modules are implemented by using plugin.
+User can develop custom plugins by simply implementing extended interfaces, and select the plugin to be run at runtime by simply declare at configuration.
+
+## eventmesh-spi module
+
+The implementation of SPI is at eventmesh-spi module, there are three main classes `EventMeshSPI`, `EventMeshExtensionFactory` and `ExtensionClassLoader`.
+
+### EventMeshSPI
+
+EventMeshSPI is an SPI declaration annotation, all extended interface that want to be implemented should be declared by @EventMeshSPI.
+
+```java
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface EventMeshSPI {
+ /**
+ * If true, the spi instance is singleton
+ */
+ boolean isSingleton() default false;
+}
+```
+
+Use annotation to declare the interface is an SPI extended interface can improve the readability of the code.
+On the other hand, @EventMeshSPI contains a isSingleton attribute which used to declare whether the extension instance is a singleton.
+If this attribute is true, that means the instance of this interface will be singleton.
+
+### EventMeshExtensionFactory
+
+EventMeshExtensionFactory is a factory used to get the SPI extension instance which contains a static method `getExtension(Class<T> extensionType, String extensionName)`.
+
+```java
+public enum EventMeshExtensionFactory {
+ /**
+ * @param extensionType extension plugin class type
+ * @param extensionName extension instance name
+ * @param <T> the type of the plugin
+ * @return plugin instance
+ */
+ public static <T> T getExtension(Class<T> extensionType, String extensionName) {
+ /* ... */
+ }
+}
+```
+
+If you want to get the extension instance, you should use EventMeshExtensionFactory.
+
+### ExtensionClassLoader
+
+ExtensionClassLoader is used to load extension instance classed, it has two subclass MetaInfExtensionClassLoader and JarExtensionClassLoader.
+
+```java
+/**
+ * Load extension class
+ * <ul>
+ * <li>{@link MetaInfExtensionClassLoader}</li>
+ * <li>{@link JarExtensionClassLoader}</li>
+ * </ul>
+ */
+public interface ExtensionClassLoader {
+ /**
+ * load
+ *
+ * @param extensionType extension type class
+ * @param <T> extension type
+ * @return extension instance name to extension instance class
+ */
+ <T> Map<String, Class<?>> loadExtensionClass(Class<T> extensionType);
+}
+```
+
+MetaInfExtensionClassLoader used to load class from classPath, and JarExtensionClassLoader used to load class from extension jar on the plugin directory.
+In the future, we might support the implementation to load from the maven repository.
+
+## SPI use case
+
+The following is an example of how to use the SPI to declare a plugin.
+
+First, we create an eventmesh-connector-api module, and define the extension interface MeshMQProducer, and we use @EventMeshSPI on the MeshMQProducer,
+which indicates the MeshMQProducer is an SPI interface.
+
+```java
+@EventMeshSPI(isSingleton = false)
+public interface MeshMQProducer extends Producer {
+ /* ... */
+}
+```
+
+Then we create an eventmesh-connector-rocketmq module, which contains the concrete implementation named RocketMQProducerImpl.
+
+```java
+public class RocketMQProducerImpl implements MeshMQProducer {
+ /* ... */
+}
+```
+
+At the same time, we need to create a file with the full qualified name of the SPI interface under the resource/META-INF/eventmesh directory
+in the eventmesh-connector-rocketmq module.
+
+org.apache.eventmesh.api.producer.Producer
+
+The content of the file is the extension instance name and the corresponding instance full class name
+
+```properties
+rocketmq=org.apache.eventmesh.connector.rocketmq.producer.RocketMQProducerImpl
+```
+
+At this point, an SPI expansion module is complete. We can use `EventMeshExtensionFactory.getExtension(MeshMQProducer.class, "rocketmq")` to get the `RocketMQProducerImpl` instance.
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/01-metrics-export.md b/versioned_docs/version-v1.11.0/design-document/02-observability/01-metrics-export.md
new file mode 100644
index 000000000..331eab336
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/01-metrics-export.md
@@ -0,0 +1,47 @@
+# EventMesh Metrics (OpenTelemetry and Prometheus)
+
+## Introduction
+
+[EventMesh](https://github.com/apache/eventmesh) is a dynamic cloud-native eventing infrastructure.
+
+## An overview of OpenTelemetry
+
+OpenTelemetry is a collection of tools, APIs, and SDKs. You can use it to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.
+
+## An overview of Prometheus
+
+Power your metrics and alerting with a leading open-source monitoring solution.
+
+- Dimensional data
+- Powerful queries
+- Great visualization
+- Efficient storage
+- Simple operation
+- Precise alerting
+- Many client libraries
+- Many integrations
+
+## Requirements
+
+### Functional Requirements
+
+| Requirement ID | Requirement Description | Comments |
+| :------------- | ------------------------------------------------------------ | ------------- |
+| F-1 | EventMesh users should be able to observe HTTP metrics from Prometheus | Functionality |
+| F-2 | EventMesh users should be able to observe TCP metrics from Prometheus | Functionality |
+
+## Design Details
+
+use the meter instrument provided by OpenTelemetry to observe the metrics exist in EventMesh then export to Prometheus.
+
+1. Initialize a meter instrument
+
+2. set the Prometheus server
+
+3. different metrics observer built
+
+## Appendix
+
+### References
+
+<https://github.com/open-telemetry/docs-cn/blob/main/QUICKSTART.md#%E5%88%9B%E5%BB%BA%E5%9F%BA%E7%A1%80Span>
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/02-tracing.md b/versioned_docs/version-v1.11.0/design-document/02-observability/02-tracing.md
new file mode 100644
index 000000000..1b191965d
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/02-tracing.md
@@ -0,0 +1,87 @@
+# Distributed Tracing
+
+## Overview of OpenTelemetry
+
+OpenTelemetry is a collection of tools, APIs, and SDKs. You can use it to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.
+
+## Requirements
+
+- set tracer
+- different exporter
+- start and end span in server
+
+## Design Details
+
+- SpanProcessor: BatchSpanProcessor
+
+- Exporter: log(default), would be changed from properties
+
+```java
+// Configure the batch spans processor. This span processor exports span in batches.
+BatchSpanProcessor batchSpansProcessor =
+ BatchSpanProcessor.builder(exporter)
+ .setMaxExportBatchSize(512) // set the maximum batch size to use
+ .setMaxQueueSize(2048) // set the queue size. This must be >= the export batch size
+ .setExporterTimeout(
+ 30, TimeUnit.SECONDS) // set the max amount of time an export can run before getting
+ // interrupted
+ .setScheduleDelay(5, TimeUnit.SECONDS) // set time between two different exports
+ .build();
+OpenTelemetrySdk.builder()
+ .setTracerProvider(
+ SdkTracerProvider.builder().addSpanProcessor(batchSpansProcessor).build())
+ .build();
+```
+
+1. When using the method 'init()' of the class "EventMeshHTTPServer", the class "AbstractHTTPServer” will get the tracer
+
+```java
+super.openTelemetryTraceFactory = new OpenTelemetryTraceFactory(eventMeshHttpConfiguration);
+super.tracer = openTelemetryTraceFactory.getTracer(this.getClass().toString());
+super.textMapPropagator = openTelemetryTraceFactory.getTextMapPropagator();
+```
+
+2. then the trace in class "AbstractHTTPServer” will work.
+
+## Problems
+
+### How to set different exporter in class 'OpenTelemetryTraceFactory'? (Solved)
+
+After I get the exporter type from properties, how to deal with it.
+
+The 'logExporter' only needs to new it.
+
+But the 'zipkinExporter' needs to new and use the "getZipkinExporter()" method.
+
+## Solutions
+
+### Solution of different exporter
+
+Use reflection to get an exporter.
+
+First of all, different exporter must implement the interface 'EventMeshExporter'.
+
+Then we get the exporter name from the configuration and reflect to the class.
+
+```java
+//different spanExporter
+String exporterName = configuration.eventMeshTraceExporterType;
+//use reflection to get spanExporter
+String className = String.format("org.apache.eventmesh.runtime.exporter.%sExporter",exporterName);
+EventMeshExporter eventMeshExporter = (EventMeshExporter) Class.forName(className).newInstance();
+spanExporter = eventMeshExporter.getSpanExporter(configuration);
+```
+
+Additional, this will surround with try catch.If the specified exporter cannot be obtained successfully, the default exporter log will be used instead
+
+#### Improvement of different exporter
+
+SPI (To be completed)
+
+## Appendix
+
+### References
+
+<https://github.com/open-telemetry/docs-cn/blob/main/QUICKSTART.md>
+
+<https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/netty>
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/03-prometheus.md b/versioned_docs/version-v1.11.0/design-document/02-observability/03-prometheus.md
new file mode 100644
index 000000000..1bc6e0e55
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/03-prometheus.md
@@ -0,0 +1,24 @@
+# Observe Metrics with Prometheus
+
+## Prometheus
+
+[Prometheus](https://prometheus.io/docs/introduction/overview/) is an open-source system monitoring and alerting toolkit that collects and stores the metrics as time-series data. EventMesh exposes a collection of metrics data that could be scraped and analyzed by Prometheus. Please follow [the "First steps with Prometheus" tutorial](https://prometheus.io/docs/introduction/first_steps/) to download and install the latest release of Prometheus.
+
+## Edit Prometheus Configuration
+
+The `eventmesh-runtime/conf/prometheus.yml` configuration file specifies the port of the metrics HTTP endpoint. The default metrics port is `19090`.
+
+```properties
+eventMesh.metrics.prometheus.port=19090
+```
+
+Please refer to [the Prometheus configuration guide](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) to add the EventMesh metrics as a scrape target in the configuration file. Here's the minimum configuration that creates a job with the name `eventmesh` and the endpoint `http://localhost:19090`:
+
+```yaml
+scrape_configs:
+ - job_name: "eventmesh"
+ static_configs:
+ - targets: ["localhost:19090"]
+```
+
+Please navigate to the Prometheus dashboard (e.g. `http://localhost:9090`) to view the list of metrics exported by EventMesh, which are prefixed with `eventmesh_`.
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/04-zipkin.md b/versioned_docs/version-v1.11.0/design-document/02-observability/04-zipkin.md
new file mode 100644
index 000000000..07b130c6c
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/04-zipkin.md
@@ -0,0 +1,38 @@
+# Collect Trace with Zipkin
+
+## Zipkin
+
+Distributed tracing is a method used to profile and monitor applications built with microservices architecture. Distributed tracing helps pinpoint where failures occur and what causes poor performance.
+
+[Zipkin](https://zipkin.io) is a distributed tracing system that helps collect timing data needed to troubleshoot latency problems in service architectures. EventMesh exposes a collection of trace data that could be collected and analyzed by Zipkin. Please follow [the "Zipkin Quickstart" tutorial](https://zipkin.io/pages/quickstart.html) to download and install the latest release of Zipkin.
+
+## Configuration
+
+To enable the trace exporter of EventMesh Runtime, set the `eventMesh.server.trace.enabled` field in the `conf/eventmesh.properties` file to `true`.
+
+```properties
+# Trace plugin
+eventMesh.server.trace.enabled=true
+eventMesh.trace.plugin=zipkin
+```
+
+To customize the behavior of the trace exporter such as timeout or export interval, edit the `exporter.properties` file.
+
+```properties
+# Set the maximum batch size to use
+eventmesh.trace.max.export.size=512
+# Set the queue size. This must be >= the export batch size
+eventmesh.trace.max.queue.size=2048
+# Set the max amount of time an export can run before getting(TimeUnit=SECONDS)
+eventmesh.trace.export.timeout=30
+# Set time between two different exports (TimeUnit=SECONDS)
+eventmesh.trace.export.interval=5
+```
+
+To send the exported trace data to Zipkin, edit the `eventmesh.trace.zipkin.ip` and `eventmesh.trace.zipkin.port` fields in the `conf/zipkin.properties` file to match the configuration of the Zipkin server.
+
+```properties
+# Zipkin's IP and Port
+eventmesh.trace.zipkin.ip=localhost
+eventmesh.trace.zipkin.port=9411
+```
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/05-jaeger.md b/versioned_docs/version-v1.11.0/design-document/02-observability/05-jaeger.md
new file mode 100644
index 000000000..74066310c
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/05-jaeger.md
@@ -0,0 +1,44 @@
+# Collect Trace with Jaeger
+
+## Jaeger
+
+[Jaeger](https://www.jaegertracing.io/), inspired by [Dapper](https://research.google.com/pubs/pub36356.html) and [OpenZipkin](https://zipkin.io/), is a distributed tracing platform created by [Uber Technologies](https://uber.github.io/) and donated to [Cloud Native Computing Foundation](https://cncf.io/). It can be used for monitoring microservices-based distributed systems.
+
+For the installation of Jaeger, you can refer to the [official documentation](https://www.jaegertracing.io/docs/latest/getting-started/) of Jaeger. It is recommended to use docker image `jaegertracing/all-in-one` to quickly build the environment for testing.
+
+## Configuration
+
+To enable the trace exporter of EventMesh Runtime, set the `eventMesh.server.trace.enabled` field in the `conf/eventmesh.properties` file to `true`.
+
+```properties
+# Trace plugin
+eventMesh.server.trace.enabled=true
+eventMesh.trace.plugin=jaeger
+```
+
+To customize the behavior of the trace exporter such as timeout or export interval, edit the `exporter.properties` file.
+
+```properties
+# Set the maximum batch size to use
+eventmesh.trace.max.export.size=512
+# Set the queue size. This must be >= the export batch size
+eventmesh.trace.max.queue.size=2048
+# Set the max amount of time an export can run before getting(TimeUnit=SECONDS)
+eventmesh.trace.export.timeout=30
+# Set time between two different exports (TimeUnit=SECONDS)
+eventmesh.trace.export.interval=5
+```
+
+To send the exported trace data to Jaeger, edit the `eventmesh.trace.jaeger.ip` and `eventmesh.trace.jaeger.port` fields in the `conf/jaeger.properties` file to match the configuration of the Jaeger server.
+
+```properties
+# Jaeger's IP and Port
+eventmesh.trace.jaeger.ip=localhost
+eventmesh.trace.jaeger.port=14250
+```
+
+## Migrating from Zipkin
+
+Collector service exposes Zipkin compatible REST API `/api/v1/spans` which accepts both Thrift and JSON. Also there is `/api/v2/spans` for JSON and Proto.
+
+So you can also use the `eventmesh-trace-zipkin` plugin to collect trace with Jaeger. Please refer to the `eventmesh-trace-zipkin` documentation for the specific configuration. By default this feature in Jaeger is disabled. It can be enabled with `--collector.zipkin.host-port=:9411`.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/02-observability/_category_.json b/versioned_docs/version-v1.11.0/design-document/02-observability/_category_.json
new file mode 100644
index 000000000..9a251b1a4
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-observability/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Observability",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/design-document/02-stream.md b/versioned_docs/version-v1.11.0/design-document/02-stream.md
new file mode 100644
index 000000000..7f2534a5d
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/02-stream.md
@@ -0,0 +1,118 @@
+# EventMesh Stream
+
+## Overview of Event Streaming
+
+Event Streaming is an implementation of Pub/Sub architecture pattern,it consist of
+
+- Message or Event: Change of State.
+
+- Topic: Partition in messaging middle ware broker.
+
+- Consumer: Can subscribe to read events from broker topic.
+
+- Producer: Generate events
+
+Streaming of event is continuous flow of events in order to maintain order between events, events flow should be in a specific direction means from producers to consumers.
+
+## Requirements
+
+### Functional Requirements
+
+| Requirement ID | Requirement Description | Comments |
+| -------------- | ----------------------- | -------- |
+| F-1 | EventMesh users should be able to achieve Event Streaming functionality in EventMesh | Functionality |
+| F-2 | EventMesh users can apply dynamic user specific logics for routing, filter, transformation etc | Functionality |
+
+## Design Details
+
+We are introduce EventMesh Stream component allow us to use programming model and binder abstractions
+from Spring Cloud Stream natively within Apache Camel.
+
+[Spring-Cloud-Stream](https://spring.io/projects/spring-cloud-stream) Spring Cloud Stream is a framework for building
+highly scalable event-driven microservices connected with shared messaging systems.
+
+[Apache Camel](https://camel.apache.org/) Camel is an Open Source integration framework that empowers you to quickly
+and easily integrate various systems consuming or producing data.
+
+## Architecture
+
+
+
+## Design
+
+### EventMesh-Stream Component
+
+- Event
+- Event Channel
+- Event EndPoint
+- Event Pipes & Filters
+- Event Routes
+- Event Converter
+
+#### Event
+
+> A event is the smallest unit for transmitting data in system. It structure divided into headers, body and attachments.
+
+#### Event Channel
+
+> A event channel is a logical channel in system, we are achieving by Spring Cloud Stream programming model, it has abstract functionality around messaging channels(As of now Spring `MessageChannel`).
+
+#### Event EndPoint
+
+> A event endpoint is the interface between an application and a messaging system. We can define two types of endpoint
+
+- Consumer endpoint - Appears at start of a route and read incoming events from an incoming channel.
+- Producer endpoint - Appears at end of a route and write incoming events to an outgoing channel.
+
+#### Event Pipes & Filters
+
+> We can construct a route by creating chain of filters( Apache Camel `Processor`), where the output of one filter is fed into input for next filter in the pipeline.
+The main advantage of the pipeline is that you can create complex event processing logic.
+
+#### Event Routes
+
+> A event router, is a type of filter on consumer and redirect them to the appropriate target endpoint based on a decision criteria.
+
+#### Event Converter
+
+> The event converter that modifies the contents of a event, translating it to a different format(i.e cloudevents -> Event (Camel) -> Binder Message(Spring Message) and vice versa).
+
+## EventMesh-Stream Component Interfaces
+
+### Component
+
+Component interface is the primary entry point, you can use Component object as a factory to create EndPoint objects.
+
+
+
+### EndPoint
+
+EndPoint which is act as factories for creating Consumer, Producer and Event objects.
+
+- `createConsumer()` — Creates a consumer endpoint, which represents the source endpoint at the beginning of a route.
+- `createProducer()` — Creates a producer endpoint, which represents the target endpoint at the end of a route.
+
+
+
+#### Producer
+
+User can create following types of producer
+> Synchronous Producer-Processing thread blocks until the producer has finished the event processing.
+
+
+
+In future Producer Types:
+
+- Asynchronous Producer - Producer process the event in a sub-thread.
+
+#### Consumer
+
+User can create following types of consumer
+> Event-driven consumer-the processing of an incoming request is initiated when message binder call a method in consumer.
+
+
+
+In the Future
+
+- Scheduled poll consumer
+- Custom polling consumer
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/00-connectors.md b/versioned_docs/version-v1.11.0/design-document/03-connect/00-connectors.md
new file mode 100644
index 000000000..92552483a
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/00-connectors.md
@@ -0,0 +1,51 @@
+# Connectors
+
+## Connector
+
+A connector is an image or instance that interacts with a specific external service or underlying data source (e.g., Databases) on behalf of user applications. A connector is either a Source or a Sink.
+
+Connector runs as a standalone service by `main()`.
+
+## Source
+
+A source connector obtains data from an underlying data producer, and delivers it to targets after original data has been transformed into CloudEvents. It doesn't limit the way how a source retrieves data. (e.g., A source may pull data from a message queue or act as an HTTP server waiting for data sent to it).
+
+## Sink
+
+A sink connector receives CloudEvents and does some specific business logics. (e.g., A MySQL Sink extracts useful data from CloudEvents and writes them to a MySQL database).
+
+## CloudEvents
+
+A specification for describing event data in common formats to provide interoperability across services, platforms and systems.
+
+## Implements
+
+Add a new connector by implementing the source/sink interface using [eventmesh-openconnect-java](https://github.com/apache/eventmesh/tree/master/eventmesh-openconnect/eventmesh-openconnect-java).
+
+## Technical Solution
+
+### Structure and process
+
+
+
+### Design Detail
+
+
+
+### Description
+
+#### Worker
+
+Worker is divided into Source Worker and Sink Worker, which are triggered by the `Application` class and implement the methods of the `ConnectorWorker` interface respectively, which include the worker's running life cycle, and the worker carries the running of the connector. Workers can be lightweight and independent through mirroring Running, the eventmesh-sdk-java module is integrated internally, and the CloudEvents protocol is used to interact with EventMesh. Currently, the TCP client [...]
+
+#### Connector
+
+Connectors are divided into Source Connector and Sink Connector. Connectors have their own configuration files and run independently. Workers perform reflective loading and configuration analysis to complete Connector initialization and subsequent operation. Source Connector implements the poll method, and Sink Connector implements The put method uniformly uses `ConnectorRecord` to carry data. Both Source Connector and Sink Connector can operate independently.
+
+#### ConnectorRecord with CloudEvents
+
+`ConnectorRecord` is a connector layer data protocol. When workers interact with EventMesh, a protocol adapter needs to be developed to convert `ConnectorRecord` to CloudEvents protocol.
+
+#### Registry
+
+The Registry module is responsible for storing the synchronization progress of synchronizing data of different Connector instances, ensuring high availability between multiple Connector images or instances.
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/01-rabbitmq-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/01-rabbitmq-connector.md
new file mode 100644
index 000000000..09d6643b3
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/01-rabbitmq-connector.md
@@ -0,0 +1,42 @@
+# RabbitMQ
+
+## RabbitMQSinkConnector: From EventMesh to RabbitMQ
+
+1. launch your RabbitMQ server and EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. start your `RabbitMQConnectorServer`, it will subscribe to the topic defined in `pubSubConfig.subject` of EventMesh Runtime and send data to `connectorConfig.queueName` in your RabbitMQ.
+4. send a message to EventMesh with the topic defined in `pubSubConfig.subject` and then you will receive the message in RabbitMQ.
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TopicTest
+ idc: FT
+ env: PRD
+ group: rabbitmqSink
+ appId: 5031
+ userName: rabbitmqSinkUser
+ passWord: rabbitmqPassWord
+connectorConfig:
+ connectorName: rabbitmqSink
+ host: your.rabbitmq.server
+ port: 5672
+ username: coyrqpyz
+ passwd: passwd
+ virtualHost: coyrqpyz
+ exchangeType: TOPIC
+ # build-in exchangeName or name a new one after you create it in rabbitmq server.
+ exchangeName: amq.topic
+ # rabbitmq server will create the routingKey and queueName automatically after you connect to it if they aren't exist before.
+ routingKey: eventmesh
+ queueName: eventmesh
+ autoAck: true
+```
+
+## RabbitMQSourceConnector: From RabbitMQ to EventMesh
+
+1. launch your RabbitMQ server and EventMesh Runtime.
+2. enable sourceConnector and check `source-config.yml` (Basically the same as `sink-config.yml`)
+3. start your `RabbitMQConnectorServer`, it will subscribe to the queue defined in `connectorConfig.queueName` in your RabbitMQ and send data to `pubSubConfig.subject` of EventMesh Runtime.
+4. send a CloudEvent message to the queue and then you will receive the message in EventMesh.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/02-http-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/02-http-connector.md
new file mode 100644
index 000000000..3aeeb5b82
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/02-http-connector.md
@@ -0,0 +1,67 @@
+# HTTP
+
+## HTTP Source Connector
+
+### Configuration
+
+Before using HTTP source connector, you need to configure the server.
+- Please configure `sourceEnable` to `true` in `/resource/server-config.yml` to enable source functionality.
+- Please configure the source connector in `/resource/source-config.yml`, only the configuration under `connectorConfig` is described here:
+ - `connectorName`, name of the connector.
+ - (required) `path`, path of the API.
+ - (required) `port`, port of the API.
+ - `idleTimeout`, idle TCP connection timeout in seconds. A connection will timeout and be closed if no data is received nor sent within the `idleTimeout` seconds. The default is 0, which means don't timeout.
+
+### Startup
+
+1. start EventMesh Runtime
+2. start eventmesh-connector-http
+
+When finished, the HTTP source connector will act as an HTTP server.
+
+### Sending messages
+
+You can send messages to the source connector via HTTP.
+
+```yaml
+connectorConfig:
+ connectorName: httpSource
+ path: /test
+ port: 3755
+ idleTimeout: 5
+```
+
+The above example configures a URL `http://localhost:3755/test` in `source-config.yml`.
+
+You can send messages in `binary` mode or `structured` mode as specified in [cloudevent-spec](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/bindings/http-protocol-binding.md).
+
+Here are two examples:
+
+1. Sending a message in `binary` mode.
+
+```shell
+curl --location --request POST 'http://localhost:3755/test' \
+--header 'ce-id: 1' \
+--header 'ce-specversion: 1.0' \
+--header 'ce-type: com.example.someevent' \
+--header 'ce-source: /mycontext' \
+--header 'ce-subject: test_topic' \
+--header 'Content-Type: text/plain' \
+--data-raw 'testdata'
+```
+
+2. Sending a message in `structured` mode.
+
+```shell
+curl --location --request POST 'http://localhost:3755/test' \
+--header 'Content-Type: application/cloudevents+json' \
+--data-raw '{
+ "id": "1",
+ "specversion": "1.0",
+ "type": "com.example.someevent",
+ "source": "/mycontext",
+ "subject":"test_topic",
+ "datacontenttype":"text/plain",
+ "data": "testdata"
+}'
+```
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/03-redis-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/03-redis-connector.md
new file mode 100644
index 000000000..10aab6d33
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/03-redis-connector.md
@@ -0,0 +1,33 @@
+# Redis
+
+## RedisSinkConnector: From EventMesh to Redis topic queue
+
+1. start your Redis instance if needed and EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. start your `RedisConnectServer`, it will subscribe to the topic defined in `pubSubConfig.subject` of EventMesh Runtime and send data to `connectorConfig.topic` in your Redis.
+4. send a message to EventMesh with the topic defined in `pubSubConfig.subject` and then you will receive the message in Redis.
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TopicTest
+ idc: FT
+ env: PRD
+ group: redisSink
+ appId: 5031
+ userName: redisSinkUser
+ passWord: redisPassWord
+connectorConfig:
+ connectorName: redisSink
+ server: redis://127.0.0.1:6379
+ # the topic in redis
+ topic: SinkTopic
+```
+
+## RedisSourceConnector: From Redis topic queue to EventMesh
+
+1. start your Redis instance if needed and EventMesh Runtime.
+2. enable sourceConnector and check `source-config.yml` (Basically the same as `sink-config.yml`)
+3. start your `RedisConnectServer`, it will subscribe to the topic defined in `connectorConfig.topic` in your Redis and send data to `pubSubConfig.subject` of EventMesh Runtime.
+4. send a CloudEvent message to the topic in Redis, and you will receive the message in EventMesh.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/04-mongodb-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/04-mongodb-connector.md
new file mode 100644
index 000000000..4c4f8ac95
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/04-mongodb-connector.md
@@ -0,0 +1,36 @@
+# MongoDB
+
+## MongoDBSinkConnector: From EventMesh to MongoDB
+
+1. launch your MongoDB server and EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. start your MongoDBConnectorServer, it will subscribe to the topic defined in `pubSubConfig.subject` of EventMesh Runtime and send data to `connectorConfig.collection` in your MongoDB.
+4. send a message to EventMesh with the topic defined in `pubSubConfig.subject` and then you will receive the message in MongoDB.
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TopicTest
+ idc: FT
+ env: PRD
+ group: mongodbSink
+ appId: 5031
+ userName: mongodbSinkUser
+ passWord: mongodbPassWord
+connectorConfig:
+ connectorName: mongodbSink
+ # REPLICA_SET or STANDALONE is supported
+ connectorType: STANDALONE
+ # mongodb://root:root@127.0.0.1:27018,127.0.0.1:27019
+ url: mongodb://127.0.0.1:27018
+ database: yourDB
+ collection: yourCol
+```
+
+## MongoDBSourceConnector: From MongoDB to EventMesh
+
+1. launch your MongoDB server and EventMesh Runtime.
+2. enable sourceConnector and check `source-config.yml` (Basically the same as `sink-config.yml`)
+3. start your `MongoDBSourceConnector`, it will subscribe to the collection defined in `connectorConfig.collection` in your MongoDB and send data to `pubSubConfig.subject` of EventMesh Runtime.
+4. write a CloudEvent message to `yourCol` at `yourDB` in your MongoDB and then you will receive the message in EventMesh.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/05-knative-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/05-knative-connector.md
new file mode 100644
index 000000000..311872aee
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/05-knative-connector.md
@@ -0,0 +1,94 @@
+# Knative
+
+>With the changes in the design of the Knative connector, this document is currently temporarily outdated.
+
+## Prerequisite
+### Create Knative Source and Sink
+We use the *cloudevents-player* [Knative service](https://knative.dev/docs/serving/) as an example. If you do not know how to create *cloudevents-player* Knative service as source and sink, please follow the steps in this [link](https://knative.dev/docs/getting-started/first-source/#creating-your-first-source).
+
+### Set up EventMesh Configuration
+- Add the following lines to [eventmesh-starter/build.gradle](https://github.com/apache/eventmesh/blob/master/eventmesh-starter/build.gradle) file.
+```
+plugins {
+ id 'application'
+}
+
+application {
+ mainClass = project.hasProperty("mainClass") ? project.getProperty("mainClass") : 'org.apache.eventmesh.starter.StartUp'
+ applicationDefaultJvmArgs = [
+ '-Dlog4j.configurationFile=../eventmesh-runtime/conf/log4j2.xml', '-Deventmesh.log.home=../eventmesh-runtime/logs', '-Deventmesh.home=../eventmesh-runtime', '-DconfPath=../eventmesh-runtime/conf'
+ ]
+}
+
+dependencies {
+ implementation project(":eventmesh-connector-plugin:eventmesh-connector-knative")
+ implementation project(":eventmesh-runtime")
+}
+```
+- Add the following lines to [eventmesh-examples/build.gradle](https://github.com/apache/eventmesh/blob/master/eventmesh-examples/build.gradle) file.
+```
+plugins {
+ id 'application'
+}
+
+application {
+ mainClass = project.hasProperty("mainClass") ? project.getProperty("mainClass") : 'NULL'
+}
+```
+- Set `eventMesh.connector.plugin.type=knative` in [eventmesh-runtime/conf/eventmesh.properties](https://github.com/apache/eventmesh/blob/master/eventmesh-runtime/conf/eventmesh.properties) file.
+
+## Demo
+### Publish an Event Message from Knative and Subscribe from EventMesh
+#### Step 1: Start an EventMesh Runtime Server
+```bash
+$ cd eventmesh-starter
+$ ../gradlew -PmainClass=org.apache.eventmesh.starter.StartUp run
+```
+
+#### Step 2: Publish an Event Message from Knative
+```bash
+$ curl -i http://cloudevents-player.default.127.0.0.1.sslip.io -H "Content-Type: application/json" -H "Ce-Id: 123456789" -H "Ce-Specversion: 1.0" -H "Ce-Type: some-type" -H "Ce-Source: command-line" -d '{"msg":"Hello CloudEvents!"}'
+```
+
+#### Step 3: Subscribe from an EventMesh
+- Set `public static final String EVENTMESH_HTTP_ASYNC_TEST_TOPIC = "messages";` in [ExampleConstants.java](https://github.com/apache/eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/common/ExampleConstants.java) file.
+```bash
+$ cd eventmesh-examples
+$ ../gradlew -PmainClass=org.apache.eventmesh.http.demo.sub.SpringBootDemoApplication run
+```
+
+#### Expected Result
+The following message with `data` field as `Hello CloudEvents!` will be printed on the console of EventMesh server.
+```bash
+2022-09-05 16:37:58,237 INFO [eventMesh-clientManage-] DefaultConsumer(DefaultConsumer.java:60) - \
+[{"event":{"attributes":{"datacontenttype":"application/json","id":"123456789","mediaType":"application/json",\
+"source":"command-line","specversion":"1.0","type":"some-type"},"data":{"msg":"Hello CloudEvents!"},"extensions":{}},\
+"id":"123456789","receivedAt":"2022-09-05T10:37:49.537658+02:00[Europe/Madrid]","type":"RECEIVED"}]
+```
+
+### Publish an Event Message from EventMesh and Subscribe from Knative
+#### Step 1: Start an EventMesh Runtime Server
+```bash
+$ cd eventmesh-starter
+$ ../gradlew -PmainClass=org.apache.eventmesh.starter.StartUp run
+```
+
+#### Step 2: Publish an Event Message from EventMesh
+We use a test program to demo this function.
+```bash
+$ cd eventmesh-connector-plugin/eventmesh-connector-knative
+$ ../../gradlew clean test --tests KnativeProducerImplTest.testPublish
+```
+
+#### Step 3: Subscribe from Knative
+```bash
+$ curl http://cloudevents-player.default.127.0.0.1.sslip.io/messages
+```
+
+#### Expected Result
+The following message with `data` field as `Hello Knative from EventMesh!` will be printed on the console of EventMesh server.
+```bash
+2022-09-05 16:52:41,633 INFO [eventMesh-clientManage-] DefaultConsumer(DefaultConsumer.java:60) - \
+[{"event":{"attributes":{"datacontenttype":"application/json","id":"1234","mediaType":"application/json",\
+"source":"java-client","specversion":"1.0","type":"some-type"},"data":{"msg":["Hello Knative from EventMesh!"]},"extensions":{}},"id":"1234","receivedAt":"2022-09-05T10:52:32.999273+02:00[Europe/Madrid]","type":"RECEIVED"}]
+```
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/06-lark-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/06-lark-connector.md
new file mode 100644
index 000000000..3de3ab6e7
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/06-lark-connector.md
@@ -0,0 +1,36 @@
+# Feishu/Lark
+
+## Lark Sink Server Config And Start
+
+Before using eventmesh-connector-lark to sink events, you need to configure the server.
+
+- Please customize `sinkEnable`=`true`/`false` in `/resource/server-config.yml` to turn on/off the sink function.
+- Regarding `/resource/sink-config.yml`, only the configuration under `sinkConnectorConfig` is explained here:
+ - `connectorName`, specify the connector name
+ - (required) `appId`, the appId obtained from lark
+ - (required) `appSecret`, the appSecret obtained from lark
+ - `receiveIdType`, the type of receiving Id, the default and recommended use is `open_id`. Optional open_id/user_id/union_id/email/chat_id.
+ - (Required) `receiveId`, receive Id, needs to correspond to `receiveIdType`.
+ - `sinkAsync`, whether to asynchronously sink events
+ - `maxRetryTimes`, the maximum number of retransmissions when the sink event fails. The default is 3 times.
+ - `retryDelayInMills`, when the sink event fails, the time interval for retransmitting the event. Default is 1s, unit is milliseconds.
+
+## Sink CloudEvent To Lark
+
+When using the eventmesh-connector-lark sinking event, you need to add the corresponding extension filed in CloudEvent:
+
+- When key=`templatetype4lark`, value=`text`/`markdown`, indicating the text type of the event.
+- When text type is markdown, you can add extension: key=`markdownmessagetitle4lark`, value indicates the title of the event.
+- When key=`atusers4lark`, value=`id-0,name-0;id-1,name-1`, indicating that the event requires `@`certain users.
+ - It is recommended to use **open_id** for id.
+ - When the text is of text type, the id can be **open_id/union_id/user_id**; when the text is of markdown type, the id can be **open_id/user_id**. In particular, when the application type is [custom robot](https://open.larksuite.com/document/ukTMukTMukTM/ucTM5YjL3ETO24yNxkjN) and the text is of markdown type, only the use of **open_id** to `@` the user is supported.
+ - When the text is of text type and the id is invalid, name will be used instead for display; when the text is of markdown type and the id is invalid, an exception will be thrown directly (you should try to ensure the correctness of the id, and name can be considered omitted).
+- When key=`atall4lark`, value=`true`/`false`, indicating that the event requires `@` everyone.
+
+## Lark Open Platform API
+
+For the Lark open platform API involved in this module, please click the following link:
+
+- **Send Message**, please [view here](https://open.larksuite.com/document/server-docs/im-v1/message/create?appId=cli_a5e1bc31507ed00c)
+- **text**, please [view here](https://open.larksuite.com/document/server-docs/im-v1/message-content-description/create_json#c9e08671)
+- **markdown**, please [view here](https://open.larksuite.com/document/common-capabilities/message-card/message-cards-content/using-markdown-tags)
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/07-dingtalk-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/07-dingtalk-connector.md
new file mode 100644
index 000000000..4e3b729a1
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/07-dingtalk-connector.md
@@ -0,0 +1,34 @@
+# DingTalk
+
+## DingtalkSinkConnector: From EventMesh to DingTalk
+
+1. launch your EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. send a message to EventMesh with the topic defined in `pubSubConfig.subject`
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TEST-TOPIC-DINGTALK
+ idc: FT
+ env: PRD
+ group: dingTalkSink
+ appId: 5034
+ userName: dingTalkSinkUser
+ passWord: dingTalkPassWord
+sinkConnectorConfig:
+ connectorName: dingTalkSink
+ # Please refer to: https://open.dingtalk.com/document/orgapp/the-robot-sends-a-group-message
+ appKey: dingTalkAppKey
+ appSecret: dingTalkAppSecret
+ openConversationId: dingTalkOpenConversationId
+ robotCode: dingTalkRobotCode
+```
+
+### CloudEvent Attributes
+
+When using the eventmesh-connector-dingtalk sinking event, you need to add the corresponding extension filed in CloudEvent:
+
+- When key=`dingtalktemplatetype`, value=`text`/`markdown`, indicating the text type of the event.
+- When text type is markdown, you can add extension: key=`dingtalkmarkdownmessagetitle`, value indicates the title of the event.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/08-wecom-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/08-wecom-connector.md
new file mode 100644
index 000000000..62e834ef0
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/08-wecom-connector.md
@@ -0,0 +1,30 @@
+# WeCom
+
+## WecomSinkConnector: From EventMesh to WeCom
+
+1. launch your EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. send a message to EventMesh with the topic defined in `pubSubConfig.subject`
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TEST-TOPIC-WECOM
+ idc: FT
+ env: PRD
+ group: weComSink
+ appId: 5034
+ userName: weComSinkUser
+ passWord: weComPassWord
+sinkConnectorConfig:
+ connectorName: weComSink
+ # Please refer to: https://developer.work.weixin.qq.com/document/path/90236
+ robotWebhookKey: weComRobotWebhookKey
+```
+
+### CloudEvent Attributes
+
+When using the eventmesh-connector-wecom sinking event, you need to add the corresponding extension filed in CloudEvent:
+
+- When key=`wecomtemplatetype`, value=`text`/`markdown`, indicating the text type of the event.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/09-slack-connector.md b/versioned_docs/version-v1.11.0/design-document/03-connect/09-slack-connector.md
new file mode 100644
index 000000000..cee677985
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/09-slack-connector.md
@@ -0,0 +1,25 @@
+# Slack
+
+## SlackSinkConnector: From EventMesh to Slack
+
+1. launch your EventMesh Runtime.
+2. enable sinkConnector and check `sink-config.yml`.
+3. send a message to EventMesh with the topic defined in `pubSubConfig.subject`
+
+```yaml
+pubSubConfig:
+ # default port 10000
+ meshAddress: your.eventmesh.server:10000
+ subject: TEST-TOPIC-SLACK
+ idc: FT
+ env: PRD
+ group: slackSink
+ appId: 5034
+ userName: slackSinkUser
+ passWord: slackPassWord
+sinkConnectorConfig:
+ connectorName: slackSink
+ # Please refer to: https://api.slack.com/messaging/sending
+ appToken: slackAppToken
+ channelId: slackChannelId
+```
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/design-document/03-connect/_category_.json b/versioned_docs/version-v1.11.0/design-document/03-connect/_category_.json
new file mode 100644
index 000000000..b47c4291f
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-connect/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Connect",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/design-document/03-schema-registry.md b/versioned_docs/version-v1.11.0/design-document/03-schema-registry.md
new file mode 100644
index 000000000..b36815266
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/03-schema-registry.md
@@ -0,0 +1,134 @@
+# EventMesh Schema Registry (OpenSchema)
+
+## Overview of Schema and Schema Registry
+
+### Schema
+
+A Schema stands for the description of serialization instances(string/stream/file/...) and has two properties. First, it is also in the format of serialization type. Second, it defines what requirements such serialized instances should satisfy.
+
+Besides describing a serialization instance, a Schema may also be used for validating whether an instance is legitimate. The reason is that it defines the ```type```(and other properties) of a serialized instance and inside keys. Taking JSON Schema for example, it could not only be referred when describing a JSON string, but also be used for validating whether a string satisfies properties defined in the schema[[1]](#References).
+
+Commonly, there are JSON Schema, Protobuf Schema, and Avro Schema.
+
+### Schema Registry
+
+Schema Registry is a server provides RESTful interfaces. It could receive and store Schemas from clients, as well as provide intrefaces for other clients to retrieve Schemas from it.
+
+It could be applied to validation process and (de-)serialization process.
+
+### Comparison of Schema Registry in Different Projects
+
+Project | Application
+:---: | :---
+EMQ[[2]](#References) | Mainly in (de-)serialization process. Use "Schema Registry" and "Rule Matching" to transfer a message from one serialization format to another.
+Pulsar[[3]](#References) | Mainly in validation process. Use "Schema Registry" to validate a message.
+Confluentinc[[4]](#References) | In both validation and (de-)serialization process.
+
+## Overview of OpenSchema
+
+OpenSchema[[5]](#References) proposes a specification for data schema when exchanging the message and event in more and more modern cloud-native applications. It designs a RESTful interface for storing and retrieving such as Avro, JSON Schema, and Protobuf3 schemas from three aspects(subject/schema/compatibility).
+
+## Requirements(Goals)
+
+| Requirement ID | Requirement Description | Comments |
+| :------------- | ------------------------------------------------------------ | ------------- |
+| F-1 | In transmission, no message needs to contain schema information which bring efficiency. | Functionality |
+| F-2 | The message content from producer could be validated whether serialized correctly according to schema. | Functionality |
+
+## Design Details
+
+### Architecture
+
+
+
+### Process of Transferring Messages under Schema Registry
+
+
+
+The highlevel process of messages transmission contains 10 steps as follows:
+
+- 1: Consumer subscribes "TOPIC" messages from EventMesh.
+- 2: Producer registers a schema to EventMesh.
+- 3: EventMesh registers a schema to Schema Registry.
+- 4: Schema Registry returns the id of newly created schema; EventMesh caches such id and schema.
+- 5: EventMesh returns the id of schema to Producer.
+- 6: Producer patches the id in front of messages and send messages to EventMesh.
+- 7: EventMesh validates the messages in the entry port and send it to EventStore; EventMesh retrieves messages from EventStore.
+- 8: EventMesh unpatches the id and send it to Schema Registry(if such `<id, schema>` does not exists in local cache).
+- 9: Schema Registry returns schema and EventMesh caches it.
+- 10: EventMesh patches schema in front of messages and push it to consumer.
+
+## Current Progress
+
+### Status
+
+**Current state**: Developing
+
+**Discussion thread**: ISSUE #339
+
+### Proposed Changes
+
+The proposal has two aspects.
+
+First is a separated Open Schema Registry, which includes storage and compatibility check for schema.
+This proposal is under developing.
+
+Second is the integration of Open Schema in EventMesh, which includes validation for schema. This proposal is to be developed.
+
+As for the first proposal, some developing statuses are as follows.
+
+#### Status Code and Exception Code
+
+No. | Status Code | Exception Code | Description | status
+--- | :---: | :---: | :---: | :---:
+1 | 401 | 40101 | Unauthorized Exception | ✔
+2 | 404 | 40401 | Schema Non- Exception | ✔
+3 | ^ | 40402 | Subject Non-exist Exception | ✔
+4 | ^ | 40403 | Version Non-exist Exception | ✔
+5 | 409 | 40901 | Compatibility Exception | ✔
+6 | 422 | 42201 | Schema Format Exception | ✔
+7 | ^ | 42202 | Subject Format Exception | ✔
+8 | ^ | 42203 | Version Format Exception | ✔
+9 | ^ | 42204 | Compatibility Format Exception | ✔
+10 | 500 | 50001 | Storage Service Exception | ✔
+11 | ^ | 50002 | Timeout Exception | ✔
+
+#### API Development Status
+
+No. | Type | URL | response | exception | code | test
+--- | --- | --- | --- | --- | --- | ---
+1 | GET | /schemas/ids/{string: id} | `Schema.class` | 40101\40401\50001 | ✔ | ❌
+2 | GET | /schemas/ids/{string: id}/subjects | `SubjectAndVersion.class` | 40101\40401\50001 | ✔ | ❌
+3 | GET | /subjects | `List\<String>` | 40101\50001 | ✔ | ❌
+4 | GET | /subjects/{string: subject}/versions | `List\<Integer>` | 40101\40402\50001 | ✔ | ❌
+5 | DELETE | /subjects/(string: subject) | `List\<Integer>` | 40101\40402\50001 | ✔ | ❌
+6 | GET | /subjects/(string: subject) | `Subject.class` | 40101\40402\50001 | ✔ | ❌
+7 | GET | /subjects/(string: subject)/versions/(version: version)/schema | `SubjectWithSchema.class` | 40101\40402\40403\50001 | ✔ | ❌
+8 | POST | /subjects/(string: subject)/versions | `SchemaIdResponse.class` | 40101\40901\42201\50001\50002 | - | ❌
+9 | POST | /subjects/(string: subject)/ | `Subject.class` | 40101\40901\42202\50001\50002 | ✔ | ❌
+10 | DELETE | /subjects/(string: subject)/versions/(version: version) | `int` | 40101\40402\40403\40901\50001| - | ❌
+11 | POST | /compatibility/subjects/(string: subject)/versions/(version: version) | `CompatibilityResultResponse.class` | 40101\40402\40403\42201\42203\50001| - | ❌
+12 | GET | /compatibility/(string: subject) | `Compatibility.class` | 40101\40402\50001 | ✔ | ❌
+13 | PUT | /compatibility/(string: subject) | `Compatibility.class` | 40101\40402\40901\42204\50001 | - | ❌
+
+#### Overall Project Structure
+
+```SchemaController.java```+```SchemaService.java``` : ```OpenSchema 7.1.1~7.1.2 (API 1~2)```
+
+```SubjectController.java```+```SubjectService.java``` : ```OpenSchema 7.2.1~7.2.8 (API 3~10)```
+
+```CompatibilityController.java```+```CompatibilityService.java``` : ```OpenSchema 7.3.1~7.3.3 (API 11~13)``` + ```Check for Compatibility```
+
+
+
+## References
+
+[1] [schema validator (github.com)](https://github.com/search?q=schema+validator)
+
+[2] [EMQ: Schema Registry](https://www.jianshu.com/p/33e0655c642b)
+
+[3] [Pulsar: Schema Registry](https://mp.weixin.qq.com/s/PaB66-Si00cX80py5ig5Mw)
+
+[4] [confluentinc/schema-registry](https://github.com/confluentinc/schema-registry)
+
+[5] [openmessaging/openschema](https://github.com/openmessaging/openschema)
diff --git a/versioned_docs/version-v1.11.0/design-document/_category_.json b/versioned_docs/version-v1.11.0/design-document/_category_.json
new file mode 100644
index 000000000..f9283e2f0
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/design-document/_category_.json
@@ -0,0 +1,5 @@
+{
+ "position": 6,
+ "label": "Design Document",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/instruction/01-store.md b/versioned_docs/version-v1.11.0/instruction/01-store.md
new file mode 100644
index 000000000..ab06d8c61
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/01-store.md
@@ -0,0 +1,48 @@
+# Event Store
+
+## 1. Prerequisites
+
+- 64-bit OS, we recommend Linux/Unix.
+
+- 64-bit JDK 8 or JDK 11
+
+- 4GB+ available disk to deploy Event Store
+
+This document provides an example of deploying it with RocketMQ as Event Store, but you can also choose another [Event Store supported by EventMesh](../roadmap.md#event-store-implementation-status). If you choose default standalone mode, you could skip this file and go to the next step: Deploy EventMesh Runtime; if not, you could choose RocketMQ as the store layer.
+
+In a production environment, you should use an Event Store other than standalone to support greater throughput and higher availability.
+
+## 2. Download
+
+Download the Binary code (recommended: 4.9.*) from [RocketMQ Official](https://rocketmq.apache.org/download/). Here we take 4.9.4 as an example.
+
+```shell
+unzip rocketmq-all-4.9.4-bin-release.zip
+cd rocketmq-4.9.4/
+```
+
+
+
+## 3. Start
+
+Start Name Server:
+
+```shell
+nohup sh bin/mqnamesrv &
+tail -f ~/logs/rocketmqlogs/namesrv.log
+```
+
+
+
+Start Broker:
+
+```shell
+nohup sh bin/mqbroker -n localhost:9876 &
+tail -f ~/logs/rocketmqlogs/broker.log
+```
+
+The deployment of Event Store has finished, please go to the next step: [Start EventMesh Runtime](./03-runtime.md)
+
+## Reference
+
+For more details about RocketMQ, please refer to https://rocketmq.apache.org/docs/quick-start/.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/instruction/02-store-with-docker.md b/versioned_docs/version-v1.11.0/instruction/02-store-with-docker.md
new file mode 100644
index 000000000..ebcee611b
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/02-store-with-docker.md
@@ -0,0 +1,71 @@
+# Event Store with Docker
+
+## 1. Prerequisites
+
+- 64-bit OS, we recommend Linux/Unix.
+- 4GB+ available disk to deploy Event Store
+
+This document provides an example of deploying it with RocketMQ as Event Store, but you can also choose another [Event Store supported by EventMesh](../roadmap.md#event-store-implementation-status). If you choose default standalone mode, you could skip this file and go to the next step: Deploy EventMesh Runtime; if not, you could choose RocketMQ as the store layer.
+
+In a production environment, you should use an Event Store other than standalone to support greater throughput and higher availability.
+
+## 2. Deploy
+
+### 2.1 Pull Images
+
+Pull RocketMQ image from Docker Hub:
+
+```shell
+#Pull rocketmq image
+sudo docker pull apache/rocketmq:4.9.4
+```
+
+You can list and view existing local mirrors with the following command:
+
+```shell
+sudo docker images
+```
+
+If the terminal displays the image information as shown below, the RocketMQ image has been successfully downloaded locally.
+
+```shell
+REPOSITORY TAG IMAGE ID CREATED SIZE
+apache/rocketmq 4.9.4 a2a50ca263c3 13 months ago 548MB
+```
+
+
+
+### 2.2 Run Docker
+
+Run namesrv container:
+
+```shell
+
+sudo docker run -d -p 9876:9876 \
+ -v `pwd`/data/namesrv/logs:/root/logs \
+ -v `pwd`/data/namesrv/store:/root/store \
+ --name rmqnamesrv \
+ apache/rocketmq:4.9.4 \
+ sh mqnamesrv
+
+```
+
+Run broker container:
+
+```shell
+sudo docker run -d -p 10911:10911 -p 10909:10909 \
+ -v `pwd`/data/broker/logs:/root/logs \
+ -v `pwd`/data/broker/store:/root/store \
+ --name rmqbroker \
+ --link rmqnamesrv:namesrv \
+ -e "NAMESRV_ADDR=namesrv:9876" \
+ apache/rocketmq:4.9.4 \
+ sh mqbroker -c ../conf/broker.conf
+
+```
+
+
+
+Please note that the `rocketmq-broker ip` is `pod ip`. If you want to modify this ip, you can set it your custom value in `broker.conf`。
+
+By now, the deployment of Event Store has finished, please go to the next step: [Start EventMesh Runtime Using Docker](./04-runtime-with-docker.md)
diff --git a/versioned_docs/version-v1.11.0/instruction/03-runtime.md b/versioned_docs/version-v1.11.0/instruction/03-runtime.md
new file mode 100644
index 000000000..64a1f271a
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/03-runtime.md
@@ -0,0 +1,271 @@
+# EventMesh Runtime Quick Start
+
+EventMesh Runtime is a stateful Mesh node in the EventMesh cluster, responsible for event transmission between Source Connectors and Sink Connectors. It uses Event Store as a storage queue for events.
+
+
+
+## 1. Binary Distribution Deployment
+
+### 1.1 Environment
+
+- Recommended to use 64-bit Linux/Unix systems
+- 64-bit JDK 8 or JDK 11
+
+### 1.2 Download
+
+Download the latest version of the Binary Distribution from the [EventMesh Download](https://eventmesh.apache.org/download) page and extract it:
+
+```shell
+wget https://dlcdn.apache.org/eventmesh/1.10.0/apache-eventmesh-1.10.0-bin.tar.gz
+tar -xvzf apache-eventmesh-1.10.0-bin.tar.gz
+cd apache-eventmesh-1.10.0
+```
+
+### 1.3 Configuration
+
+This document provides an example of deploying it with RocketMQ as Event Store, but you can also choose another [Event Store supported by EventMesh](../roadmap.md#event-store-implementation-status). If you choose a non-standalone mode, ensure that [RocketMQ is successfully started](https://rocketmq.apache.org/docs/quick-start/) and accessible via IP address. If you stick to the default standalone mode, RocketMQ doesn't need to be started.
+
+#### 1.3.1 EventMesh Runtime Configuration
+
+This configuration file includes settings for the EventMesh Runtime environment and integrated plugins.
+
+```shell
+vim conf/eventmesh.properties
+```
+
+Specify RocketMQ as Event Store:
+
+```properties
+# storage plugin
+eventMesh.storage.plugin.type=rocketmq
+```
+
+Check if the default ports in the configuration file are occupied. If occupied, modify them to unused ports:
+
+| Property | Default | Remarks |
+| ---------------------------------- | ------- | ------------------- |
+| eventMesh.server.tcp.port | 10000 | TCP listening port |
+| eventMesh.server.http.port | 10105 | HTTP listening port |
+| eventMesh.server.grpc.port | 10205 | gRPC listening port |
+| eventMesh.server.admin.http.port | 10106 | HTTP management port |
+
+#### 1.3.2 Event Store Configuration
+
+In the case of RocketMQ, the configuration file includes parameters required to connect to the RocketMQ namesrv.
+
+Edit `rocketmq-client.properties`:
+
+```shell
+vim conf/rocketmq-client.properties
+```
+
+If the namesrv address you are running is different from the default value in the configuration file, modify it to the actual running namesrv address.
+
+| Property | Default | Remarks |
+| ----------------------------------------- | ------------------------------ | ----------------------------------- |
+| eventMesh.server.rocketmq.namesrvAddr | 127.0.0.1:9876;127.0.0.1:9876 | RocketMQ namesrv address |
+
+### 1.4 Start
+
+Execute the `start.sh` script to start EventMesh Runtime:
+
+```shell
+bash bin/start.sh
+```
+
+If the script only prints the following three lines without any other error messages, it means the script has executed successfully:
+
+```shell
+EventMesh using Java version: 8, path: /usr/local/openjdk-8/bin/java
+EVENTMESH_HOME : /data/app/eventmesh
+EVENTMESH_LOG_HOME : /data/app/eventmesh/logs
+```
+
+Next, view the logs output by EventMesh to check its runtime status:
+
+```shell
+tail -n 50 -f logs/eventmesh.out
+```
+
+When the log output shows `server state:RUNNING`, it means EventMesh Runtime has started successfully.
+
+Stop EventMesh Runtime:
+
+```shell
+bash bin/stop.sh
+```
+
+When the script prints `shutdown server ok!`, it means EventMesh Runtime has stopped.
+
+## 2. Build Binary Distribution
+
+### 2.1 Environment
+
+- Recommended to use 64-bit Linux/Unix systems
+- 64-bit JDK 8 or JDK 11
+- [Gradle](https://docs.gradle.org/current/userguide/installation.html) 7.0+ (optional), the build commands provided in this document use the Gradle Wrapper, and you don't need to configure the Gradle environment yourself. You can also check the recommended Gradle version for your EventMesh version in the `gradle/wrapper/gradle-wrapper.properties` file and use your local Gradle version for compilation.
+
+### 2.2 Download
+
+Download the Source Code from [EventMesh Download](https://eventmesh.apache.org/download) and extract it:
+
+```shell
+wget https://dlcdn.apache.org/eventmesh/1.10.0/apache-eventmesh-1.10.0-source.tar.gz
+tar -xvzf apache-eventmesh-1.10.0-source.tar.gz
+cd apache-eventmesh-1.10.0-src/
+```
+
+You can also choose to clone the code from GitHub:
+
+```shell
+git clone https://github.com/apache/eventmesh.git
+cd eventmesh/
+```
+
+### 2.3 Build
+
+EventMesh is developed based on JDK8, and the binary distribution is also built based on JDK8. It is recommended to run EventMesh Runtime in a JDK8 environment.
+
+#### Run in a JDK8 Environment
+
+Some source code needs to be generated under JDK11:
+
+```shell
+./gradlew clean generateGrammarSource --parallel --daemon
+```
+
+The `generateGrammarSource` task will generate the source code required for `ANTLR` under the `org.apache.eventmesh.connector.jdbc.antlr4.autogeneration` package.
+
+Next, build EventMesh Runtime under JDK8:
+
+```shell
+./gradlew clean dist -x spotlessJava -x generateGrammarSource --parallel --daemon
+```
+
+After the build is complete, proceed to [2.4 Package Plugins](#24-package-plugins).
+
+> You can switch between JDK versions using `update-alternatives` or `JAVA_HOME` and check the current JDK version with `java -version`.
+
+#### Run in a JDK11 Environment
+
+If you want to use JDK11 as the runtime environment for EventMesh, execute:
+
+```shell
+./gradlew clean dist --parallel --daemon
+```
+
+After the build is complete, proceed to [2.4 Package Plugins](#24-package-plugins).
+
+### 2.4 Package Plugins
+
+The `installPlugin` task will copy the built plugins to the `dist` directory:
+
+```shell
+./gradlew installPlugin
+```
+
+EventMesh will load the plugins from the `plugin` directory based on the configuration in `eventmesh.properties`.
+
+After a successful build, the `dist` directory in the project root contains the binary files for EventMesh. For configuration and startup, refer to [Binary Distribution Deployment](#1-binary-distribution-deployment).
+
+## 3. Start from Source Code
+
+### 3.1 Dependencies
+
+- Recommended to use 64-bit Linux/Unix systems
+- 64-bit JDK 8 or JDK 11
+- [Gradle](https://docs.gradle.org/current/userguide/installation.html) 7.0+ (optional), the build commands provided in this document use the Gradle Wrapper, and you don't need to configure the Gradle environment yourself. You can also check the recommended Gradle version for your EventMesh version in the `gradle/wrapper/gradle-wrapper.properties` file and use your local Gradle version for compilation.
+- It is recommended to use an IDE (Integrated Development Environment) to import EventMesh. `Intellij IDEA` is recommended as the IDE.
+
+### 3.2 Download
+
+Clone the code from GitHub:
+
+```shell
+git clone https://github.com/apache/eventmesh.git
+cd eventmesh/
+```
+
+You can also download the Source Code release from [EventMesh Download](https://eventmesh.apache.org/download) and extract it:
+
+```shell
+wget https://dlcdn.apache.org/eventmesh/1.10.0/apache-eventmesh-1.10.0-source.tar.gz
+tar -xvzf apache-eventmesh-1.10.0-source.tar.gz
+cd apache-eventmesh-1.10.0-src/
+```
+
+### 3.3 Project Structure Explanation
+
+| Main Module | Description |
+| ------------------------ | ------------------------------------------------------------ |
+| eventmesh-starter | Entry point for running EventMesh locally |
+| eventmesh-runtime | EventMesh Runtime, the runtime module |
+| eventmesh-connectors | [Connectors](../design-document/03-connect/00-connectors.md) for connecting event sources and sinks, supporting [various services and platforms](../roadmap.md#connector-implementation-status) |
+| eventmesh-storage-plugin | [Event Store](../roadmap.md#event-store-implementation-status) plugin for EventMesh Runtime |
+| eventmesh-sdks | Multi-language client SDKs for EventMesh, including Java, Go, C and Rust |
+| eventmesh-examples | Examples of SDK usage |
+| eventmesh-spi | Module for loading EventMesh SPI |
+| eventmesh-common | Module for common classes and methods |
+
+> Plugin modules follow the SPI specification defined by EventMesh, and custom SPI interfaces need to be annotated with `@EventMeshSPI`.
+>
+> Plugin instances need to be configured in the corresponding module under the `/main/resources/META-INF/eventmesh` directory with a mapping file for interface and implementation classes. The file name is the fully qualified class name of the SPI interface.
+>
+> The content of the file is the mapping from the plugin instance name to the plugin instance. For details, refer to the `eventmesh-storage-rocketmq` plugin module.
+
+### 3.4 Plugin Explanation
+
+#### 3.4.1 Install Plugins
+
+EventMesh has an SPI mechanism that allows EventMesh to discover and load plugins. There are two ways to install plugins:
+
+- Classpath loading: During local development, you can add dependencies in the `build.gradle` of the `eventmesh-starter` module. For example, to add the Kafka Storage Plugin:
+
+```gradle
+dependencies {
+ implementation project(":eventmesh-runtime")
+ // Example: Add the Kafka Storage Plugin
+ implementation project(":eventmesh-storage-plugin:eventmesh-storage-kafka")
+}
+```
+
+- File loading: By installing the plugin to the plugin directory, EventMesh will automatically load the plugins in the plugin directory based on certain conditions during runtime. Please refer to [2.3 Build](#23-build) and [2.4 Package Plugins](#24-package-plugins).
+
+>When you make changes to the source code, it is recommended to add the `build` task to the command provided in [2.3 Build](#23-build) to recompile and run unit tests. For example:
+>
+>```shell
+>./gradlew clean build dist -x spotlessJava -x generateGrammarSource --parallel --daemon
+>```
+
+#### 3.4.2 Use Plugins
+
+EventMesh will load the plugins by default from the `dist/plugin` directory. You can change the plugin directory using `-DeventMeshPluginDir=your_plugin_directory`. The plugin instances needed at runtime can be configured in the `confPath` directory in the `eventmesh.properties` file. For example, by setting the following, you declare the use of the RocketMQ as Event Store:
+
+```properties
+# storage plugin
+eventMesh.storage.plugin.type=rocketmq
+```
+
+### 3.5 Configure VM Options
+
+```properties
+-Dlog4j.configurationFile=eventmesh-runtime/conf/log4j2.xml
+-Deventmesh.log.home=eventmesh-runtime/logs
+-Deventmesh.home=eventmesh-runtime
+-DconfPath=eventmesh-runtime/conf
+```
+
+If the operating system is Windows, replace the forward slash with a backslash `\`.
+
+### 3.6 Start
+
+Run the `main()` method of the `org.apache.eventmesh.starter.StartUp` class in the `eventmesh-starter` module to start EventMesh Runtime.
+
+### 3.7 Stop
+
+When the following logs are printed to the console, EventMesh Runtime has stopped.
+
+```log
+DEBUG StatusConsoleListener Shutdown hook enabled. Registering a new one.
+WARN StatusConsoleListener Unable to register Log4j shutdown hook because JVM is shutting down. Using SimpleLogger
+```
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/instruction/04-runtime-with-docker.md b/versioned_docs/version-v1.11.0/instruction/04-runtime-with-docker.md
new file mode 100644
index 000000000..9a2a87dc5
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/04-runtime-with-docker.md
@@ -0,0 +1,168 @@
+# EventMesh Runtime with Docker
+
+You can deploy EventMesh Runtime using Docker. This document provides an example of deploying it with RocketMQ as Event Store, but you can also choose another [Event Store supported by EventMesh](../roadmap.md#event-store-implementation-status).
+
+## 1. Prerequisites
+
+1. It is recommended to use a 64-bit Linux system.
+2. Ensure Docker Engine is installed. Refer to the [official Docker documentation](https://docs.docker.com/engine/install/) for the installation process.
+3. Familiarity with basic Docker concepts and command-line operations (e.g., registry, mounting) is recommended but not mandatory, as the required commands are provided.
+4. If you choose a non-standalone mode, ensure that [RocketMQ is successfully started](https://rocketmq.apache.org/docs/quick-start/) and accessible via IP address. If you stick to the default standalone mode, RocketMQ doesn't need to be deployed.
+
+## 2. Pull the EventMesh Runtime Image
+
+First, open a command line and use the following `pull` command to download the [latest version of EventMesh](https://eventmesh.apache.org/events/release-notes/) from [Docker Hub](https://hub.docker.com/r/apache/eventmesh/tags).
+
+```shell
+sudo docker pull apache/eventmesh:latest
+```
+
+You can use the following command to list and view the locally available images.
+
+```shell
+sudo docker images
+```
+
+If the terminal displays image information similar to the following, it indicates that the EventMesh image has been successfully downloaded locally.
+
+```shell
+$ sudo docker images
+REPOSITORY TAG IMAGE ID CREATED SIZE
+apache/eventmesh latest f32f9e5e4694 2 days ago 917MB
+```
+
+## 3. Mount Configuration Files
+
+If you are starting EventMesh Runtime in standalone mode and haven't customized the configuration, you can proceed to the next step.
+
+First, create the EventMesh configuration file directory on the host machine. This directory can be freely specified:
+
+```shell
+sudo mkdir -p /data/eventmesh/conf
+cd /data/eventmesh/conf
+```
+
+### 3.1 EventMesh Runtime Configuration
+
+This configuration file includes parameters required for the EventMesh Runtime environment and integration with other plugins.
+
+Download the configuration file (replace `1.10.0` in the download link with the version you are using):
+
+```shell
+sudo wget https://raw.githubusercontent.com/apache/eventmesh/1.10.0-prepare/eventmesh-runtime/conf/eventmesh.properties
+```
+
+Edit `eventmesh.properties`:
+
+```shell
+sudo vim eventmesh.properties
+```
+
+Specify RocketMQ as Event Store:
+
+```properties
+# storage plugin
+eventMesh.storage.plugin.type=rocketmq
+```
+
+Check if the default ports in the configuration file are occupied. If occupied, modify them to unused ports:
+
+| Property | Default | Remarks |
+| ---------------------------------- | ------- | ------------------- |
+| eventMesh.server.tcp.port | 10000 | TCP listening port |
+| eventMesh.server.http.port | 10105 | HTTP listening port |
+| eventMesh.server.grpc.port | 10205 | gRPC listening port |
+| eventMesh.server.admin.http.port | 10106 | HTTP management port |
+
+### 3.2 Event Store Configuration
+
+In the case of RocketMQ, the configuration file includes parameters required to connect to the RocketMQ namesrv.
+
+Download the configuration file (replace `1.10.0` in the download link with the version you are using):
+
+```shell
+sudo wget https://raw.githubusercontent.com/apache/eventmesh/1.10.0-prepare/eventmesh-storage-plugin/eventmesh-storage-rocketmq/src/main/resources/rocketmq-client.properties
+```
+
+Edit `rocketmq-client.properties`:
+
+```shell
+sudo vim rocketmq-client.properties
+```
+
+If the namesrv address you are running is different from the default value in the configuration file, modify it to the actual running namesrv address.
+
+| Property | Default | Remarks |
+| ----------------------------------------- | ------------------------------ | ----------------------------------- |
+| eventMesh.server.rocketmq.namesrvAddr | 127.0.0.1:9876;127.0.0.1:9876 | RocketMQ namesrv address |
+
+>If you are unable to download the configuration files using the provided links, you can find all the configuration files in the `conf` path of the EventMesh binary distribution.
+
+## 4. Run the EventMesh Runtime Container
+
+Use the following command to start the EventMesh container:
+
+```shell
+sudo docker run -d --name eventmesh -p 10000:10000 -p 10105:10105 -p 10205:10205 -p 10106:10106 -v /data/eventmesh/conf/eventmesh.properties:/data/app/eventmesh/conf/eventmesh.properties -v /data/eventmesh/conf/rocketmq-client.properties:/data/app/eventmesh/conf/rocketmq-client.properties -t apache/eventmesh:latest
+```
+
+Explanation of `docker run` command parameters:
+
+- `-p <host port>:<container port>`: Bind the container port to the host port. If you modified the default ports in EventMesh Runtime configuration or if the host's ports are already occupied, modify them accordingly.
+- `-v <host path>:<container path>`: Mount the configuration files from the host to the container. If the path where you store EventMesh configuration files is not `/data/eventmesh/conf`, modify the host path accordingly. If you haven't customized the configuration files, please remove this parameter.
+- `--name eventmesh`: Custom name for the container. This name must be unique.
+- `-t apache/eventmesh:latest`: Image used by the container.
+
+After executing the `docker run` command, the container ID will be returned. Use the following command to view the status of all running containers:
+
+```shell
+sudo docker ps
+```
+
+It will print:
+
+```shell
+CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
+b7a1546ee96a apache/eventmesh:latest "bash bin/start.sh" 10 seconds ago Up 8 seconds 0.0.0.0:10000->10000/tcp, :::10000->10000/tcp, 0.0.0.0:10105-10106->10105-10106/tcp, :::10105-10106->10105-10106/tcp, 0.0.0.0:10205->10205/tcp, :::10205->10205/tcp eventmesh
+```
+
+If the EventMesh Runtime container is not in the list printed by this command, it means the container failed to start. You can use the following command to view the logs at the time of startup (replace `eventmesh` with the container name or ID you specified):
+
+```shell
+sudo docker logs eventmesh
+```
+
+## 5. View EventMesh Logs
+
+After successfully starting the EventMesh container, you can follow these steps to view the logs output by EventMesh and check the runtime status.
+
+Enter the container (replace `eventmesh` with the container name or ID you specified):
+
+```shell
+sudo docker exec -it eventmesh /bin/bash
+```
+
+View the logs:
+
+```shell
+cd logs
+tail -n 50 -f eventmesh.out
+```
+
+When the log output shows `server state:RUNNING`, it means EventMesh Runtime has started successfully.
+
+## 6. Build EventMesh Runtime Image (Optional)
+
+EventMesh is developed based on JDK8. The binary distribution and container image are built based on JDK8 and are also compatible with JDK11.
+
+To run the container in a JDK8 environment, execute the following command in the root directory of the EventMesh source code:
+
+```shell
+sudo docker build -t yourname/eventmesh:yourtag -f docker/Dockerfile_jdk8 .
+```
+
+If you want to use JDK11 as the container's runtime environment, execute:
+
+```shell
+sudo docker build -t yourname/eventmesh:yourtag -f docker/Dockerfile_jdk11 .
+```
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/instruction/05-demo.md b/versioned_docs/version-v1.11.0/instruction/05-demo.md
new file mode 100644
index 000000000..4853d9bc0
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/05-demo.md
@@ -0,0 +1,225 @@
+# Run Java SDK Demo
+
+[](https://maven-badges.herokuapp.com/maven-central/org.apache.eventmesh/eventmesh-sdk-java)
+
+> eventmesh-sdk-java acts as a client of EventMesh Runtime and communicates with it, to publish and subscribe the messages.
+>
+> The eventmesh-sdk-java supports ASYNC messages and BROADCAST messages. ASYNC messages indicate that producers only send messages and do not care about receiving reply messages. BROADCAST messages mean that producers send a message once, and all consumers subscribed to the broadcast topic will receive the message.
+>
+> eventmesh-sdk-java supports HTTP, TCP and gRPC protocols.
+
+The test demos of TCP, HTTP and GRPC are in the module `eventmesh-examples`.
+
+## 1. TCP
+
+### 1.1 ASYNC
+
+- Start consumer to subscribe the topic (we have created the TEST-TOPIC-TCP-ASYNC by default, you can also create other topic to test)
+
+```
+Run the main method of org.apache.eventmesh.tcp.demo.sub.eventmeshmessage.AsyncSubscribe
+```
+
+- Start producer to publish async message
+
+```
+Run the main method of org.apache.eventmesh.tcp.demo.pub.eventmeshmessage.AsyncPublish
+```
+
+### 1.2 BROADCAST
+
+- Start subscriber to subscribe the topic (we have created the TEST-TOPIC-TCP-BROADCAST by default, you can also create other topic to test)
+
+```
+Run the main method of org.apache.eventmesh.tcp.demo.sub.eventmeshmessage.AsyncSubscribeBroadcast
+```
+
+- Start publisher to publish async message
+
+```
+Run the main method of org.apache.eventmesh.tcp.demo.pub.eventmeshmessage.AsyncPublishBroadcast
+```
+
+More information about EventMesh-TCP, please refer to [EventMesh TCP](../sdk-java/03-tcp.md)
+
+## 2 HTTP
+
+>For HTTP, the eventmesh-sdk-java implements sending and subscribing to asynchronous events.
+>
+>In the demo, the `content` field of the Java class `EventMeshMessage` represents a special protocol. Therefore, if you are using the eventmesh-sdk-java's http-client, you only need to design the content of the protocol and provide the consumer's application at the same time.
+
+### 2.1 ASYNC
+
+- The subscriber is a SpringBoot demo, so run this demo to start subscriber (we have created the topic TEST-TOPIC-HTTP-ASYNC by default, you can also create other topic to test)
+
+```
+Run the main method of org.apache.eventmesh.http.demo.sub.SpringBootDemoApplication
+```
+
+- Start publisher to publish message
+
+```
+Run the main method of org.apache.eventmesh.http.demo.pub.eventmeshmessage.AsyncPublishInstance
+```
+More information about EventMesh-HTTP, please refer to [EventMesh HTTP](../sdk-java/02-http.md)
+
+## 3 GRPC
+
+>The eventmesh-sdk-java implements the gRPC protocol. It can asynchronously or synchronously send events to the EventMesh Runtime.
+>
+>It can subscribe to consume events through Webhook and event streaming, and also supports the CNCF CloudEvents protocol.
+
+### 3.1 ASYNC Publish & Webhook Subscribe
+
+>Producers can asynchronously send events to the EventMesh Runtime without waiting for the events to be stored in the Event Store.
+>
+>For Webhook consumers, events will be pushed to the consumer's HTTP Endpoint URL, i.e., the consumer's `subscribeUrl`. This method is similar to the previously mentioned Http EventMesh client.
+
+- Start publisher to publish message (we have created the topic TEST-TOPIC-GRPC-ASYNC by default, you can also create other topic to test)
+
+```
+Run the main method of org.apache.eventmesh.grpc.pub.eventmeshmessage.AsyncPublishInstance
+```
+
+- Start webhook subscriber
+
+```
+Run the main method of org.apache.eventmesh.grpc.sub.app.SpringBootDemoApplication
+```
+
+### 3.2 SYNC Publish & Stream Subscribe
+
+>Producers synchronously send events to the EventMesh Runtime while waiting for the events to be stored in the Event Store.
+>
+>For event stream consumers, events are pushed in a streaming to the `ReceiveMsgHook` client. This method is similar to the EventMesh client.
+
+- Start Request-Reply publisher to publish message (we have created the topic TEST-TOPIC-GRPC-RR by default, you can also create other topic to test)
+
+```
+Run the main method of org.apache.eventmesh.grpc.pub.eventmeshmessage.RequestReplyInstance
+```
+
+- Start stream subscriber
+
+```
+Run the main method of org.apache.eventmesh.grpc.sub.EventmeshAsyncSubscribe
+```
+
+### 3.3 Publish BATCH Message
+
+>Asynchronously batch publish multiple events to the EventMesh Runtime.
+
+- Start publisher to publish batch message (we have created the TEST-TOPIC-GRPC-ASYNC by default, you can also create other topic to test.)
+
+```
+Run the main method of org.apache.eventmesh.grpc.pub.eventmeshmessage.BatchPublishInstance
+```
+
+More information about EventMesh-gRPC, please refer to [EventMesh gRPC](../sdk-java/04-grpc.md).
+
+## 4. Run Demo with shell scripts
+
+Please refer to [Event Store](./01-store.md) and [EventMesh Runtime](./03-runtime.md) to finish the necessary deployment before try our demo.
+
+After finishing the deployment of Store and Runtime, you can run our demos in module `eventmesh-examples`:
+
+gradle：
+
+```shell
+cd apache-eventmesh-1.9.0-src/eventmesh-examples
+gradle clean dist
+
+cd ./dist/bin
+```
+
+
+
+### 4.1 TCP
+#### TCP Sub
+
+```shell
+bash tcp_eventmeshmessage_sub.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_tcp_pub.out
+```
+
+
+#### TCP Pub
+
+```shell
+bash tcp_pub_eventmeshmessage.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_tcp_sub.out
+```
+
+
+
+### 4.2 TCP Broadcast
+
+#### TCP Sub Broadcast
+
+```shell
+sh tcp_sub_eventmeshmessage_broadcast.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_tcp_sub_broadcast.out
+```
+
+
+
+#### TCP Pub Broadcast
+
+```shell
+sh tcp_pub_eventmeshmessage_broadcast.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_tcp_pub_broadcast.out
+```
+
+
+
+### 4.3 HTTP
+
+#### HTTP Sub
+
+```shell
+sh http_sub.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_http_sub.out
+```
+
+
+
+#### HTTP Pub
+
+```shell
+sh http_pub_eventmeshmessage.sh
+```
+
+Open the corresponding log file to view the log:
+```
+cd /root/apache-eventmesh-1.9.0-src/eventmesh-examples/dist/logs
+tail -f demo_http_pub.out
+```
+
+
+
+You can see the run logs for the different modes under the `/logs` directory.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/instruction/06-operator.md b/versioned_docs/version-v1.11.0/instruction/06-operator.md
new file mode 100644
index 000000000..2b98a69af
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/06-operator.md
@@ -0,0 +1,97 @@
+# Integrate EventMesh with K8S
+
+### 1. Dependencies
+
+```
+docker
+golang (version 1.19)
+kubernetes (kubectl)
+There is some compatibility between kubernetes an docker, please check the version compatibility between them and download the corresponding version to ensure that they work properly together.
+```
+
+### 2. Start
+
+Go to the eventmesh-operator directory.
+
+```shell
+cd eventmesh-operator
+```
+
+Install CRD into the specified k8s cluster.
+
+```shell
+make install
+
+# Uninstall CRDs from the K8s cluster
+make uninstall
+```
+
+If you get error `eventmesh-operator/bin/controller-gen: No such file or directory`, Run the following command:
+
+```shell
+# download controller-gen locally if necessary.
+make controller-gen
+# download kustomize locally if necessary.
+make kustomize
+```
+
+View crds information:
+
+```shell
+# run the following command to view crds information:
+kubectl get crds
+NAME CREATED AT
+connectors.eventmesh-operator.eventmesh 2023-11-28T01:35:21Z
+runtimes.eventmesh-operator.eventmesh 2023-11-28T01:35:21Z
+```
+
+Create and delete CRs:
+
+Custom resource objects are located at: /config/samples
+
+When deleting CR, simply replace create with delete.
+
+```shell
+# Create CR for eventmesh-runtime、eventmesh-connector-rocketmq,Creating a clusterIP lets eventmesh-runtime communicate with other components.
+make create
+
+#success:
+configmap/runtime-config created
+runtime.eventmesh-operator.eventmesh/eventmesh-runtime created
+service/runtime-cluster-service created
+configmap/connector-rocketmq-config created
+connectors.eventmesh-operator.eventmesh/connector-rocketmq created
+
+# View the created Service.
+kubectl get service
+NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+runtime-cluster-service ClusterIP 10.109.209.72 <none> 10000/TCP 17s
+
+# Delete CR
+make delete
+```
+
+Run eventmesh-operator create pods.
+
+```shell
+# run controller
+make run
+# log
+go fmt ./...
+go vet ./...
+go run ./main.go
+INFO controller-runtime.metrics Metrics server is starting to listen {"addr": ":9020"}
+INFO setup starting manager
+INFO Starting server {"kind": "health probe", "addr": "[::]:8081"}
+INFO Starting server {"path": "/metrics", "kind": "metrics", "addr": "[::]:9020"}
+INFO runtime Creating a new eventMeshRuntime StatefulSet. {"StatefulSet.Namespace": "default", "StatefulSet.Name": "eventmesh-runtime-0-a"}
+INFO connector Creating a new Connector StatefulSet. {"StatefulSet.Namespace": "default", "StatefulSet.Name": "connector-rocketmq"}
+INFO runtime Successful reconciliation!
+INFO connector Successful reconciliation!
+
+# After the pods are successfully started, run the following command to view pods.
+kubectl get pods
+NAME READY STATUS RESTARTS AGE
+connector-rocketmq-0 1/1 Running 0 12m
+eventmesh-runtime-0-a-0 1/1 Running 0 12m
+```
diff --git a/versioned_docs/version-v1.11.0/instruction/07-faq.md b/versioned_docs/version-v1.11.0/instruction/07-faq.md
new file mode 100644
index 000000000..c5aa89352
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/07-faq.md
@@ -0,0 +1,42 @@
+# Frequently Asked Questions
+
+## Importing into Eclipse
+
+We recommend using `Intellij IDEA` for development. If you prefer to use `Eclipse`, you can follow the steps below to import the project.
+
+### Prerequisites
+
+- 64-bit JDK 1.8+
+- Gradle 7.0+
+- Eclipse with Gradle plugin installed
+
+### Download
+
+```shell
+git clone https://github.com/apache/eventmesh.git
+```
+
+### Project Compilation for Eclipse Environment
+
+Open the command-line terminal and run `./gradlew cleanEclipse eclipse`.
+
+### Configuration Modifications
+
+Modify the project name to match the parameters in the `settings.gradle` configuration file, specifically the `rootProject.name` parameter.
+
+### Modify the `eclipse.init` Configuration File
+
+Configure Lombok, using version 1.18.8 as an example:
+
+```
+-javaagent:lombok-1.18.8.jar
+-XBootclasspath/a:lombok-1.18.8.jar
+```
+
+### Eclipse Configuration for Version 202106
+
+Add the configuration parameter to `eclipse.init`: `--illegal-access=permit`
+
+### Import
+
+Open Eclipse and import the EventMesh project into the IDE.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/instruction/_category_.json b/versioned_docs/version-v1.11.0/instruction/_category_.json
new file mode 100644
index 000000000..690c6eb20
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/instruction/_category_.json
@@ -0,0 +1,5 @@
+{
+ "position": 2,
+ "label": "Installation and Deployment",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/introduction.md b/versioned_docs/version-v1.11.0/introduction.md
new file mode 100644
index 000000000..27503ffa4
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/introduction.md
@@ -0,0 +1,29 @@
+---
+sidebar_position: 0
+---
+
+# Introduction to EventMesh
+
+[](https://github.com/apache/eventmesh/actions/workflows/ci.yml)
+[](https://codecov.io/gh/apache/eventmesh)
+[](https://www.apache.org/licenses/LICENSE-2.0.html)
+[](https://github.com/apache/eventmesh/releases)
+[](https://join.slack.com/t/the-asf/shared_invite/zt-1y375qcox-UW1898e4kZE_pqrNsrBM2g)
+
+**Apache EventMesh** is a fully serverless platform used to build distributed [event-driven](https://en.wikipedia.org/wiki/Event-driven_architecture) applications.
+
+## Features
+
+Apache EventMesh has a vast amount of features to help users achieve their goals. Let us share with you some of the key features EventMesh has to offer:
+
+- Built around the [CloudEvents](https://cloudevents.io) specification.
+- Rapidly extensible language sdk around [gRPC](https://grpc.io) protocols.
+- Rapidly extensible middleware by connectors such as [Apache RocketMQ](https://rocketmq.apache.org), [Apache Kafka](https://kafka.apache.org), [Apache Pulsar](https://pulsar.apache.org), [RabbitMQ](https://rabbitmq.com), [Redis](https://redis.io), [Pravega](https://cncf.pravega.io), and [RDMS](https://en.wikipedia.org/wiki/Relational_database)(in progress) using [JDBC](https://en.wikipedia.org/wiki/Java_Database_Connectivity).
+- Rapidly extensible controller such as [Consul](https://consulproject.org/en/), [Nacos](https://nacos.io), [ETCD](https://etcd.io) and [Zookeeper](https://zookeeper.apache.org/).
+- Guaranteed at-least-once delivery.
+- Deliver events between multiple EventMesh deployments.
+- Event schema management by catalog service.
+- Powerful event orchestration by [Serverless workflow](https://serverlessworkflow.io/) engine.
+- Powerful event filtering and transformation.
+- Rapid, seamless scalability.
+- Easy Function develop and framework integration.
diff --git a/versioned_docs/version-v1.11.0/roadmap.md b/versioned_docs/version-v1.11.0/roadmap.md
new file mode 100644
index 000000000..79187d926
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/roadmap.md
@@ -0,0 +1,96 @@
+---
+sidebar_position: 1
+---
+
+# Development Roadmap
+
+The development roadmap of Apache EventMesh is an overview of the planned features and milestones involved in the next several releases. The recent features and bug fixes are documented in the [Release Notes](https://eventmesh.apache.org/events/release-notes/v1.11.0/). The order of the features listed below doesn't correspond to their priorities.
+
+## List of Features and Milestones
+
+| Status | Description | Reference |
+|-------------------------------------------|---------------------------------| --- |
+| **Implemented in 1.0.0** | Support HTTP | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.0.0** | Support TCP | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.0.0** | Support Pub/Sub Event | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.1.1** | Provide Java SDK | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.1.1** | Support HTTPS | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.2.0** | Support RocketMQ as EventStore | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.2.0** | Support Heartbeat | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenSchema | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenTelemetry | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.3.0** | Support CloudEvents | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.4.0** | Support gRPC | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.5.0** | Provide Golang SDK | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.5.0** | Support Nacos Registry | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.5.0** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.5.0** | Support Federal Government | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.5.0** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.6.0** | Integrate with Consul | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.6.0** | Support Webhook | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.6.0** | Support etcd | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.7.0** | Support Knative Eventing Infrastructure | [GitHub Issue](https://github.com/apache/issues/790), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-463) |
+| **Implemented in 1.7.0** | Support Pravega as EventStore | [GitHub Issue](https://github.com/apache/issues/270) |
+| **Implemented in 1.7.0** | Support Kafka as EventStore | [GitHub Issue](https://github.com/apache/issues/676) |
+| **Implemented in 1.7.0** | Support Pulsar as EventStore | [GitHub Issue](https://github.com/apache/issues/676) |
+| **Implemented in 1.7.0** | Support CNCF Serverless Workflow| [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.7.0** | Support Redis | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.7.0** | Provide Rust SDK | [GitHub Issue](https://github.com/apache/issues/815) |
+| **Implemented in 1.7.0** | Support Zookeeper | [GitHub Issue](https://github.com/apache/issues/417) |
+| **Implemented in 1.7.0** | Support RabbitMQ as EventStore | [GitHub Issue](https://github.com/apache/issues/1553) |
+| **Implemented in 1.8.0** | Provide Dashboard | [GitHub Issue](https://github.com/apache/issues/700), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-465)
+| **In Progress** | Source/Sink Connector | [GitHub Issue](https://github.com/apache/eventmesh/issues/3492) |
+| **In Progress** | K8s integration | [GitHub Issue](https://github.com/apache/eventmesh/issues/3327) |
+| **In Progress** | OpenFunction integration | [GitHub Issue](https://github.com/apache/eventmesh/issues/2040) |
+| **In Progress** | OpenSergo integration | [GitHub Issue](https://github.com/apache/eventmesh/issues/2805) |
+| Planned | Transaction Event | [GitHub Issue](https://github.com/apache/issues/697) |
+| Planned | Provide NodeJS SDK | [GitHub Issue](https://github.com/apache/eventmesh/) |
+| Planned | Provide PHP SDK | [GitHub Issue](https://github.com/apache/eventmesh/3) |
+| Planned | Event Query Language (EQL) | [GitHub Issue](https://github.com/apache/eventmesh/) |
+| Planned | WebAssembly Runtime | [GitHub Issue](https://github.com/apache/eventmesh/) |
+
+## Connector Implementation Status
+
+| Service / Middleware | Source | Sink |
+|:------------------------------------------:|:------:|:------:|
+| [RocketMQ](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-rocketmq) | ✅ | ✅ |
+| [Kafka](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-kafka) | ✅ | ✅ |
+| [Pulsar](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-pulsar) | ✅ | ✅ |
+| [RabbitMQ](./design-document/connect/rabbitmq-connector) | ✅ | ✅ |
+| [HTTP](./design-document/connect/http-connector) | ✅ | ⬜ |
+| [JDBC](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-jdbc) | ⬜ | ✅ |
+| [Spring](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-spring) | ✅ | ✅ |
+| [OpenFunction](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-openfunction) | ✅ | ✅ |
+| [File](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-file) | ✅ | ✅ |
+| Email | ⬜ | ⬜ |
+| [Redis](./design-document/connect/redis-connector) | ✅ | ✅ |
+| [S3 File](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-s3) | ⬜ | ✅ |
+| ClickHouse | ⬜ | ⬜ |
+| [MongoDB](./design-document/connect/mongodb-connector) | ✅ | ✅ |
+| [Prometheus](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-prometheus) | ✅ | ⬜ |
+| [Knative](./design-document/connect/knative-connector) | ✅ | ✅ |
+| [Pravega](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-pravega) | ✅ | ✅ |
+| More connectors will be added... | N/A | N/A |
+
+| Platform / Product | Source | Sink |
+|:------------------------------------------:|:------:|:------:|
+| [Feishu/Lark](./design-document/connect/lark-connector) | ⬜ | ✅ |
+| [DingTalk](./design-document/connect/dingtalk-connector) | ⬜ | ✅ |
+| [WeCom](./design-document/connect/wecom-connector) | ⬜ | ✅ |
+| [WeChat](https://github.com/apache/eventmesh/tree/master/eventmesh-connectors/eventmesh-connector-wechat) | ⬜ | ✅ |
+| GitHub | ⬜ | ⬜ |
+| ChatGPT | ⬜ | ⬜ |
+| [Slack](./design-document/connect/slack-connector) | ⬜ | ✅ |
+| More connectors will be added... | N/A | N/A |
+
+## Event Store Implementation Status
+
+| Service / Middleware | Ingress | Topic Management |
+|:------------------------:|:------:|:------:|
+| RocketMQ | ✅ | ✅ |
+| Kafka | ✅ | ✅ |
+| Standalone | ✅ | ✅ |
+| Pulsar | ✅ | ⬜ |
+| RabbitMQ | ✅ | ⬜ |
+| Redis | ✅ | ⬜ |
+| Support for more Event Stores... | N/A | N/A |
\ No newline at end of file
diff --git a/versioned_docs/version-v1.11.0/sdk-java/01-intro.md b/versioned_docs/version-v1.11.0/sdk-java/01-intro.md
new file mode 100644
index 000000000..aefd8108e
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/sdk-java/01-intro.md
@@ -0,0 +1,39 @@
+# Installation
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+[](https://maven-badges.herokuapp.com/maven-central/org.apache.eventmesh/eventmesh-sdk-java)
+
+EventMesh SDK for Java is a collection of Java libraries to integrate EventMesh in a Java application. The SDK supports sending and receiving synchronous messages, asynchronous messages, and broadcast messages in TCP, HTTP, and gRPC protocols. The SDK implements EventMesh Message, CloudEvents, and OpenMessaging formats. The demo project is available in the [`eventmesh-example`](https://github.com/apache/eventmesh/tree/master/eventmesh-examples) module.
+
+<Tabs>
+ <TabItem value="Gradle" label="Gradle" default>
+
+ To install EventMesh SDK for Java with Gradle, declare `org.apache.eventmesh:eventmesh-sdk-java` as `implementation` in the dependencies block of the module's `build.gradle` file.
+
+```gradle
+dependencies {
+ implementation 'org.apache.eventmesh:eventmesh-sdk-java:1.10.0'
+}
+```
+
+
+
+</TabItem>
+ <TabItem value="Maven" label="Maven">
+
+To install EventMesh SDK for Java with Maven, declare `org.apache.eventmesh:eventmesh-sdk-java` as a dependency in the dependencies block of the project's `pom.xml` file.
+
+```xml
+<dependencies>
+ <dependency>
+ <groupId>org.apache.eventmesh</groupId>
+ <artifactId>eventmesh-sdk-java</artifactId>
+ <version>1.10.0</version>
+ </dependency>
+</dependencies>
+```
+
+</TabItem>
+</Tabs>
diff --git a/versioned_docs/version-v1.11.0/sdk-java/02-http.md b/versioned_docs/version-v1.11.0/sdk-java/02-http.md
new file mode 100644
index 000000000..01866d791
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/sdk-java/02-http.md
@@ -0,0 +1,116 @@
+# HTTP Protocol
+
+EventMesh SDK for Java implements the HTTP producer and consumer of asynchronous messages. Both the producer and consumer require an instance of `EventMeshHttpClientConfig` class that specifies the configuration of EventMesh HTTP client. The `liteEventMeshAddr`, `userName`, and `password` fields should match the `eventmesh.properties` file of EventMesh Runtime.
+
+```java
+import org.apache.eventmesh.client.http.conf.EventMeshHttpClientConfig;
+import org.apache.eventmesh.common.utils.IPUtils;
+import org.apache.eventmesh.common.utils.ThreadUtils;
+
+public class HTTP {
+ public static void main(String[] args) throws Exception {
+ EventMeshHttpClientConfig eventMeshClientConfig = EventMeshHttpClientConfig.builder()
+ .liteEventMeshAddr("localhost:10105")
+ .producerGroup("TEST_PRODUCER_GROUP")
+ .env("env")
+ .idc("idc")
+ .ip(IPUtils.getLocalAddress())
+ .sys("1234")
+ .pid(String.valueOf(ThreadUtils.getPID()))
+ .userName("eventmesh")
+ .password("password")
+ .build();
+ /* ... */
+ }
+}
+```
+
+## HTTP Consumer
+
+The `EventMeshHttpConsumer` class implements the `heartbeat`, `subscribe`, and `unsubscribe` methods. The `subscribe` method accepts a list of `SubscriptionItem` that defines the topics to be subscribed and a callback URL.
+
+```java
+import org.apache.eventmesh.client.http.consumer.EventMeshHttpConsumer;
+import org.apache.eventmesh.common.protocol.SubscriptionItem;
+import org.apache.eventmesh.common.protocol.SubscriptionMode;
+import org.apache.eventmesh.common.protocol.SubscriptionType;
+import com.google.common.collect.Lists;
+
+public class HTTP {
+ final String url = "http://localhost:8080/callback";
+ final List<SubscriptionItem> topicList = Lists.newArrayList(
+ new SubscriptionItem("eventmesh-async-topic", SubscriptionMode.CLUSTERING, SubscriptionType.ASYNC)
+ );
+
+ public static void main(String[] args) throws Exception {
+ /* ... */
+ eventMeshHttpConsumer = new EventMeshHttpConsumer(eventMeshClientConfig);
+ eventMeshHttpConsumer.heartBeat(topicList, url);
+ eventMeshHttpConsumer.subscribe(topicList, url);
+ /* ... */
+ eventMeshHttpConsumer.unsubscribe(topicList, url);
+ }
+}
+```
+
+The EventMesh Runtime will send a POST request that contains the message in the [CloudEvents format](https://github.com/cloudevents/spec) to the callback URL. The [`SubController.java` file](https://github.com/apache/eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/http/demo/sub/controller/SubController.java) implements a Spring Boot controller that receives and parses the callback messages.
+
+## HTTP Producer
+
+The `EventMeshHttpProducer` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value. The message should be an instance of either of these classes:
+
+- `org.apache.eventmesh.common.EventMeshMessage`
+- `io.cloudevents.CloudEvent`
+- `io.openmessaging.api.Message`
+
+```java
+import org.apache.eventmesh.client.http.producer.EventMeshHttpProducer;
+import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
+import org.apache.eventmesh.common.Constants;
+import org.apache.eventmesh.common.utils.JsonUtils;
+
+import io.cloudevents.CloudEvent;
+import io.cloudevents.core.builder.CloudEventBuilder;
+
+public class HTTP {
+ public static void main(String[] args) throws Exception {
+ /* ... */
+ EventMeshHttpProducer eventMeshHttpProducer = new EventMeshHttpProducer(eventMeshClientConfig);
+ Map<String, String> content = new HashMap<>();
+ content.put("content", "testAsyncMessage");
+
+ CloudEvent event = CloudEventBuilder.v1()
+ .withId(UUID.randomUUID().toString())
+ .withSubject("eventmesh-async-topic")
+ .withSource(URI.create("/"))
+ .withDataContentType("application/cloudevents+json")
+ .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
+ .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
+ .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
+ .build();
+ eventMeshHttpProducer.publish(event);
+ }
+}
+```
+
+## Using Curl Command
+
+You can also publish/subscribe event without EventMesh SDK.
+
+### Publish
+
+```shell
+curl -H "Content-Type:application/json" -X POST -d '{"name": "admin", "pass":"12345678"}' http://127.0.0.1:10105/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC
+```
+
+After you start the EventMesh Runtime server, you can use the curl command publish the event to the specific topic with the HTTP POST method and the package body must be in JSON format. The publish url like (http://127.0.0.1:10105/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC), and you will get the publish successful result.
+
+### Subscribe
+
+```shell
+curl -H "Content-Type:application/json" -X POST -d '{"url": "http://127.0.0.1:8088/sub/test", "consumerGroup":"TEST-GROUP", "topic":[{"mode":"CLUSTERING","topic":"TEST-TOPIC-HTTP-ASYNC","type":"ASYNC"}]}' http://127.0.0.1:10105/eventmesh/subscribe/local
+```
+
+After you start the EventMesh Runtime server, you can use the curl command to subscribe the specific topic list with the HTTP POST method, and the package body must be in JSON format. The subscribe url like (http://127.0.0.1:10105/eventmesh/subscribe/local), and you will get the subscribe successful result. You should pay attention to the `url` field in the package body, which means you need to set up an HTTP service at the specified URL.
+
+You can see the example in the `eventmesh-examples` module.
diff --git a/versioned_docs/version-v1.11.0/sdk-java/03-tcp.md b/versioned_docs/version-v1.11.0/sdk-java/03-tcp.md
new file mode 100644
index 000000000..64a3efcf7
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/sdk-java/03-tcp.md
@@ -0,0 +1,118 @@
+# TCP Protocol
+
+EventMesh SDK for Java implements the TCP producer and consumer of synchronous, asynchronous, and broadcast messages. Both the producer and consumer require an instance of `EventMeshTCPClientConfig` class that specifies the configuration of EventMesh TCP client. The `host` and `port` fields should match the `eventmesh.properties` file of EventMesh Runtime.
+
+```java
+import org.apache.eventmesh.client.tcp.conf.EventMeshTCPClientConfig;
+import org.apache.eventmesh.client.tcp.common.ReceiveMsgHook;
+import io.cloudevents.CloudEvent;
+
+public class AsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
+ public static void main(String[] args) throws InterruptedException {
+ EventMeshTCPClientConfig eventMeshTcpClientConfig = EventMeshTCPClientConfig.builder()
+ .host(eventMeshIp)
+ .port(eventMeshTcpPort)
+ .userAgent(userAgent)
+ .build();
+ /* ... */
+ }
+}
+```
+
+## TCP Consumer
+
+The consumer should implement the `ReceiveMsgHook` class, which is defined in [`ReceiveMsgHook.java`](https://github.com/apache/eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/tcp/common/ReceiveMsgHook.java).
+
+```java
+public interface ReceiveMsgHook<ProtocolMessage> {
+ Optional<ProtocolMessage> handle(ProtocolMessage msg);
+}
+```
+
+The `EventMeshTCPClient` class implements the `subscribe` method. The `subscribe` method accepts the topic, the `SubscriptionMode`, and the `SubscriptionType`. The `handle` method will be invoked when the consumer receives a message from the topic it subscribes. If the `SubscriptionType` is `SYNC`, the return value of `handle` will be sent back to the producer.
+
+```java
+import org.apache.eventmesh.client.tcp.EventMeshTCPClient;
+import org.apache.eventmesh.client.tcp.EventMeshTCPClientFactory;
+import org.apache.eventmesh.client.tcp.common.ReceiveMsgHook;
+import org.apache.eventmesh.common.protocol.SubscriptionMode;
+import org.apache.eventmesh.common.protocol.SubscriptionType;
+import io.cloudevents.CloudEvent;
+
+public class TCPConsumer implements ReceiveMsgHook<CloudEvent> {
+ public static TCPConsumer handler = new TCPConsumer();
+ private static EventMeshTCPClient<CloudEvent> client;
+
+ public static void main(String[] args) throws Exception {
+ client = EventMeshTCPClientFactory.createEventMeshTCPClient(
+ eventMeshTcpClientConfig,
+ CloudEvent.class
+ );
+ client.init();
+
+ client.subscribe(
+ "eventmesh-sync-topic",
+ SubscriptionMode.CLUSTERING,
+ SubscriptionType.SYNC
+ );
+
+ client.registerSubBusiHandler(handler);
+ client.listen();
+ }
+
+ @Override
+ public Optional<CloudEvent> handle(CloudEvent message) {
+ log.info("Messaged received: {}", message);
+ return Optional.of(message);
+ }
+}
+```
+
+## TCP Producer
+
+### Asynchronous Producer
+
+The `EventMeshTCPClient` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value and returns the response message from the consumer.
+
+```java
+/* ... */
+client = EventMeshTCPClientFactory.createEventMeshTCPClient(eventMeshTcpClientConfig, CloudEvent.class);
+client.init();
+
+CloudEvent event = CloudEventBuilder.v1()
+ .withId(UUID.randomUUID().toString())
+ .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
+ .withSource(URI.create("/"))
+ .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
+ .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
+ .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
+ .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
+ .build();
+client.publish(event, 1000);
+```
+
+### Synchronous Producer
+
+The `EventMeshTCPClient` class implements the `rr` method. The `rr` method accepts the message to be published and an optional timeout value and returns the response message from the consumer.
+
+```java
+/* ... */
+client = EventMeshTCPClientFactory.createEventMeshTCPClient(eventMeshTcpClientConfig, CloudEvent.class);
+client.init();
+
+CloudEvent event = CloudEventBuilder.v1()
+ .withId(UUID.randomUUID().toString())
+ .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
+ .withSource(URI.create("/"))
+ .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
+ .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
+ .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
+ .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
+ .build();
+
+Package response = client.rr(event, 1000);
+CloudEvent replyEvent = EventFormatProvider
+ .getInstance()
+ .resolveFormat(JsonFormat.CONTENT_TYPE)
+ .deserialize(response.getBody().toString().getBytes(StandardCharsets.UTF_8));
+```
diff --git a/versioned_docs/version-v1.11.0/sdk-java/04-grpc.md b/versioned_docs/version-v1.11.0/sdk-java/04-grpc.md
new file mode 100644
index 000000000..477f243e1
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/sdk-java/04-grpc.md
@@ -0,0 +1,174 @@
+# gRPC Protocol
+
+EventMesh SDK for Java implements the gRPC producer and consumer of synchronous, asynchronous, and broadcast messages. Both the producer and consumer require an instance of `EventMeshGrpcClientConfig` class that specifies the configuration of EventMesh gRPC client. The `liteEventMeshAddr`, `userName`, and `password` fields should match the `eventmesh.properties` file of EventMesh Runtime.
+
+```java
+import org.apache.eventmesh.client.grpc.config.EventMeshGrpcClientConfig;
+import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
+import io.cloudevents.CloudEvent;
+
+public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
+ public static void main(String[] args) throws InterruptedException {
+ EventMeshGrpcClientConfig eventMeshClientConfig = EventMeshGrpcClientConfig.builder()
+ .serverAddr("localhost")
+ .serverPort(10205)
+ .consumerGroup(ExampleConstants.DEFAULT_EVENTMESH_TEST_CONSUMER_GROUP)
+ .env("env").idc("idc")
+ .sys("1234").build();
+ /* ... */
+ }
+}
+```
+
+## gRPC Consumer
+
+### Stream Consumer
+
+The EventMesh Runtime sends the message from producers to the stream consumer as a series of event streams. The consumer should implement the `ReceiveMsgHook` class, which is defined in [`ReceiveMsgHook.java`](https://github.com/apache/eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/consumer/ReceiveMsgHook.java).
+
+```java
+public interface ReceiveMsgHook<T> {
+ Optional<T> handle(T msg) throws Throwable;
+ String getProtocolType();
+}
+```
+
+The `EventMeshGrpcConsumer` class implements the `registerListener`, `subscribe`, and `unsubscribe` methods. The `subscribe` method accepts a list of `SubscriptionItem` that defines the topics to be subscribed to. The `registerListener` accepts an instance of a class that implements the `ReceiveMsgHook`. The `handle` method will be invoked when the consumer receives a message from the topic it subscribes. If the `SubscriptionType` is `SYNC`, the return value of `handle` will be sent back [...]
+
+```java
+import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
+import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
+import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
+import org.apache.eventmesh.common.protocol.SubscriptionItem;
+import org.apache.eventmesh.common.protocol.SubscriptionMode;
+import org.apache.eventmesh.common.protocol.SubscriptionType;
+import io.cloudevents.CloudEvent;
+
+public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
+ public static CloudEventsAsyncSubscribe handler = new CloudEventsAsyncSubscribe();
+ public static void main(String[] args) throws InterruptedException {
+ /* ... */
+ SubscriptionItem subscriptionItem = new SubscriptionItem(
+ "eventmesh-async-topic",
+ SubscriptionMode.CLUSTERING,
+ SubscriptionType.ASYNC
+ );
+ EventMeshGrpcConsumer eventMeshGrpcConsumer = new EventMeshGrpcConsumer(eventMeshClientConfig);
+
+ eventMeshGrpcConsumer.init();
+ eventMeshGrpcConsumer.registerListener(handler);
+ eventMeshGrpcConsumer.subscribe(Collections.singletonList(subscriptionItem));
+ /* ... */
+ eventMeshGrpcConsumer.unsubscribe(Collections.singletonList(subscriptionItem));
+ }
+
+ @Override
+ public Optional<CloudEvent> handle(CloudEvent message) {
+ log.info("Messaged received: {}", message);
+ return Optional.empty();
+ }
+
+ @Override
+ public String getProtocolType() {
+ return EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME;
+ }
+}
+```
+
+### Webhook Consumer
+
+The `subscribe` method of the `EventMeshGrpcConsumer` class accepts a list of `SubscriptionItem` that defines the topics to be subscribed and an optional callback URL. If the callback URL is provided, the EventMesh Runtime will send a POST request that contains the message in the [CloudEvents format](https://github.com/cloudevents/spec) to the callback URL. The [`SubController.java` file](https://github.com/apache/eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmes [...]
+
+```java
+import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
+import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
+import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
+import org.apache.eventmesh.common.protocol.SubscriptionItem;
+import org.apache.eventmesh.common.protocol.SubscriptionMode;
+import org.apache.eventmesh.common.protocol.SubscriptionType;
+
+@Component
+public class SubService implements InitializingBean {
+ final String url = "http://localhost:8080/callback";
+
+ public void afterPropertiesSet() throws Exception {
+ /* ... */
+ eventMeshGrpcConsumer = new EventMeshGrpcConsumer(eventMeshClientConfig);
+ eventMeshGrpcConsumer.init();
+
+ SubscriptionItem subscriptionItem = new SubscriptionItem(
+ "eventmesh-async-topic",
+ SubscriptionMode.CLUSTERING,
+ SubscriptionType.ASYNC
+ );
+
+ eventMeshGrpcConsumer.subscribe(Collections.singletonList(subscriptionItem), url);
+ /* ... */
+ eventMeshGrpcConsumer.unsubscribe(Collections.singletonList(subscriptionItem), url);
+ }
+}
+```
+
+## gRPC Producer
+
+### Asynchronous Producer
+
+The `EventMeshGrpcProducer` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value. The message should be an instance of either of these classes:
+
+- `org.apache.eventmesh.common.EventMeshMessage`
+- `io.cloudevents.CloudEvent`
+
+```java
+/* ... */
+EventMeshGrpcProducer eventMeshGrpcProducer = new EventMeshGrpcProducer(eventMeshClientConfig);
+eventMeshGrpcProducer.init();
+
+Map<String, String> content = new HashMap<>();
+content.put("content", "testAsyncMessage");
+
+CloudEvent event = CloudEventBuilder.v1()
+ .withId(UUID.randomUUID().toString())
+ .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
+ .withSource(URI.create("/"))
+ .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
+ .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
+ .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
+ .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
+ .build();
+eventMeshGrpcProducer.publish(event);
+```
+
+### Synchronous Producer
+
+The `EventMeshGrpcProducer` class implements the `requestReply` method. The `requestReply` method accepts the message to be published and an optional timeout value. The method returns the message returned from the consumer. The message should be an instance of either of these classes:
+
+- `org.apache.eventmesh.common.EventMeshMessage`
+- `io.cloudevents.CloudEvent`
+
+### Batch Producer
+
+The `EventMeshGrpcProducer` class overloads the `publish` method, which accepts a list of messages to be published and an optional timeout value. The messages in the list should be an instance of either of these classes:
+
+- `org.apache.eventmesh.common.EventMeshMessage`
+- `io.cloudevents.CloudEvent`
+
+```java
+/* ... */
+List<CloudEvent> cloudEventList = new ArrayList<>();
+for (int i = 0; i < 5; i++) {
+ CloudEvent event = CloudEventBuilder.v1()
+ .withId(UUID.randomUUID().toString())
+ .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
+ .withSource(URI.create("/"))
+ .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
+ .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
+ .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
+ .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
+ .build();
+
+ cloudEventList.add(event);
+}
+
+eventMeshGrpcProducer.publish(cloudEventList);
+/* ... */
+```
diff --git a/versioned_docs/version-v1.11.0/sdk-java/_category_.json b/versioned_docs/version-v1.11.0/sdk-java/_category_.json
new file mode 100644
index 000000000..e93d4cdd8
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/sdk-java/_category_.json
@@ -0,0 +1,5 @@
+{
+ "position": 3,
+ "label": "EventMesh SDK for Java",
+ "collapsed": false
+}
diff --git a/versioned_docs/version-v1.11.0/upgrade-guide/01-upgrade-guide.md b/versioned_docs/version-v1.11.0/upgrade-guide/01-upgrade-guide.md
new file mode 100644
index 000000000..187a80c2d
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/upgrade-guide/01-upgrade-guide.md
@@ -0,0 +1,15 @@
+# EventMesh Upgrade Guide
+
+> This article briefly introduces the precautions for upgrading EventMesh from version 1.2.0 to the latest version.
+
+## 1. Precautions
+
+**If you are using EventMesh for the first time, you can ignore this chapter.**
+
+## 2. Service upgrade installation
+
+The upgrade and startup of the EventMesh Runtime module can be done in accordance with the [Deployment Guide](https://eventmesh.apache.org/docs/instruction/runtime).
+
+For differences and changes between versions, please refer to the [Release Notes](https://eventmesh.apache.org/events/release-notes) of different versions. Compatibility between versions can be achieved.
+
+If you need to use the latest features, follow the release note to upgrade to the corresponding version That’s it, and different plug-in module components can be packaged and configured separately. You can refer to the corresponding [Feature design documents and Guidelines](https://eventmesh.apache.org/docs/design-document/).
diff --git a/versioned_docs/version-v1.11.0/upgrade-guide/_category_.json b/versioned_docs/version-v1.11.0/upgrade-guide/_category_.json
new file mode 100644
index 000000000..af764643e
--- /dev/null
+++ b/versioned_docs/version-v1.11.0/upgrade-guide/_category_.json
@@ -0,0 +1,5 @@
+{
+ "position": 7,
+ "label": "Upgrade Guide",
+ "collapsed": false
+}
diff --git a/versioned_sidebars/version-v1.11.0-sidebars.json b/versioned_sidebars/version-v1.11.0-sidebars.json
new file mode 100644
index 000000000..fde499425
--- /dev/null
+++ b/versioned_sidebars/version-v1.11.0-sidebars.json
@@ -0,0 +1,89 @@
+{
+ "tutorialSidebar": [
+ "introduction",
+ "roadmap",
+ {
+ "type": "category",
+ "label": "Installation and Deployment",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "instruction"
+ }
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Design Document",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "category",
+ "label": "Event Handling and Integration",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "design-document/01-event-handling-and-integration"
+ }
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Observability",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "design-document/02-observability"
+ }
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Connect",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "design-document/03-connect"
+ }
+ ]
+ },
+ "design-document/schema-registry",
+ "design-document/spi",
+ "design-document/stream"
+ ]
+ },
+ {
+ "type": "category",
+ "label": "EventMesh SDK for Java",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "sdk-java"
+ }
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Upgrade Guide",
+ "collapsible": true,
+ "collapsed": false,
+ "items": [
+ {
+ "type": "autogenerated",
+ "dirName": "upgrade-guide"
+ }
+ ]
+ }
+ ]
+}
diff --git a/versions.json b/versions.json
index ec6a8b582..3dd6f10b5 100644
--- a/versions.json
+++ b/versions.json
@@ -1,4 +1,5 @@
[
+ "v1.11.0",
"v1.10.0",
"v1.9.0",
"v1.8.0",
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@eventmesh.apache.org
For additional commands, e-mail: commits-help@eventmesh.apache.org