You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eventmesh.apache.org by ch...@apache.org on 2023/01/31 09:32:02 UTC
[incubator-eventmesh-site] branch master updated: add zh docs
This is an automated email from the ASF dual-hosted git repository.
chenguangsheng pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-eventmesh-site.git
The following commit(s) were added to refs/heads/master by this push:
new 2fa2b3db add zh docs
2fa2b3db is described below
commit 2fa2b3db78f6221b742ea354e31ef16f103039c6
Author: qqeasonchen <qq...@gmail.com>
AuthorDate: Tue Jan 31 17:29:15 2023 +0800
add zh docs
---
zh/docs/contribute/01-release.md | 731 +++++++++++++++++++++
zh/docs/contribute/02-write-unit-test.md | 78 +++
.../contribute/03-new-contributor-guidelines.md | 262 ++++++++
zh/docs/contribute/_category_.json | 5 +
zh/docs/desing-document/01-workflow.md | 258 ++++++++
zh/docs/desing-document/02-runtime-protocol.md | 420 ++++++++++++
zh/docs/desing-document/03-stream.md | 115 ++++
zh/docs/desing-document/05-metrics-export.md | 47 ++
zh/docs/desing-document/06-cloudevents.md | 102 +++
zh/docs/desing-document/08-spi.md | 111 ++++
zh/docs/desing-document/09-event-bridge.md | 156 +++++
zh/docs/desing-document/10-knative-connector.md | 91 +++
zh/docs/desing-document/11-prometheus.md | 46 ++
zh/docs/desing-document/12-zipkin.md | 49 ++
zh/docs/desing-document/13-jaeger.md | 44 ++
zh/docs/desing-document/_category_.json | 4 +
zh/docs/desing-document/https.md | 32 +
zh/docs/desing-document/webhook.md | 268 ++++++++
zh/docs/instruction/00-eclipse.md | 33 +
zh/docs/instruction/01-store-with-docker.md | 40 ++
zh/docs/instruction/01-store.md | 51 ++
zh/docs/instruction/02-runtime-with-docker.md | 149 +++++
zh/docs/instruction/02-runtime.md | 114 ++++
zh/docs/instruction/03-demo.md | 178 +++++
zh/docs/instruction/_category_.json | 4 +
zh/docs/introduction.md | 49 ++
zh/docs/roadmap.md | 47 ++
zh/docs/sdk-java/01-intro.md | 29 +
zh/docs/sdk-java/02-http.md | 118 ++++
zh/docs/sdk-java/03-tcp.md | 118 ++++
zh/docs/sdk-java/04-grpc.md | 174 +++++
zh/docs/sdk-java/_category_.json | 4 +
32 files changed, 3927 insertions(+)
diff --git a/zh/docs/contribute/01-release.md b/zh/docs/contribute/01-release.md
new file mode 100644
index 00000000..0810a757
--- /dev/null
+++ b/zh/docs/contribute/01-release.md
@@ -0,0 +1,731 @@
+# Release Creation Process
+
+:::caution
+The documentation of Release Creation Process is WIP (Work-in-Progress).
+:::
+
+## 理解 Apache 发布的内容和流程
+
+Source Release 是 Apache 关注的重点，也是发布的必须内容；而 Binary Release 是可选项，
+
+请参考以下链接，找到更多关于 ASF 的发布指南:
+
+- [Apache Release Guide](http://www.apache.org/dev/release-publishing)
+- [Apache Release Policy](http://www.apache.org/dev/release.html)
+- [Maven Release Info](http://www.apache.org/dev/publishing-maven-artifacts.html)
+
+
+## 本地构建环境准备
+
+主要包括签名工具、Maven 仓库认证相关准备
+
+### 1.安装GPG
+
+在[GnuPG官网](https://www.gnupg.org/download/index.html)下载安装包。GnuPG的1.x版本和2.x版本的命令有细微差别，下列说明以**GnuPG-2.x**版本为例
+
+```sh
+$ gpg --version #检查版本，应该为2.x
+```
+
+### 2.用gpg生成key
+
+根据提示，生成 key
+
+> 注意：请使用Apache邮箱生成GPG的Key
+
+```shell
+$ gpg --full-gen-key
+gpg (GnuPG) 2.0.12; Copyright (C) 2009 Free Software Foundation, Inc.
+This is free software: you are free to change and redistribute it.
+There is NO WARRANTY, to the extent permitted by law.
+
+Please select what kind of key you want:
+ (1) RSA and RSA (default)
+ (2) DSA and Elgamal
+ (3) DSA (sign only)
+ (4) RSA (sign only)
+Your selection? 1
+RSA keys may be between 1024 and 4096 bits long.
+What keysize do you want? (2048) 4096
+Requested keysize is 4096 bits
+Please specify how long the key should be valid.
+ 0 = key does not expire
+ <n> = key expires in n days
+ <n>w = key expires in n weeks
+ <n>m = key expires in n months
+ <n>y = key expires in n years
+Key is valid for? (0)
+Key does not expire at all
+Is this correct? (y/N) y
+
+GnuPG needs to construct a user ID to identify your key.
+
+Real name: ${输入用户名}
+Email address: ${邮箱地址}
+Comment: CODE SIGNING KEY
+You selected this USER-ID:
+ "${输入用户名} (CODE SIGNING KEY) <${邮箱地址}>"
+
+Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
+You need a Passphrase to protect your secret key. # 填入密码，以后打包过程中会经常用到
+```
+
+### 3.查看 key
+
+```shell
+$ gpg --list-keys
+pub rsa4096/579C25F5 2021-04-26 # 579C25F5就是key id
+uid [ultimate] ${输入用户名} <${邮箱地址}>
+sub rsa4096 2021-04-26
+
+# 通过key id发送public key到keyserver
+$ gpg --keyserver pgpkeys.mit.edu --send-key 579C25F5
+# 其中，pgpkeys.mit.edu为随意挑选的keyserver，keyserver列表为：https://sks-keyservers.net/status/，相互之间是自动同步的，选任意一个都可以。
+$ gpg --keyserver hkp://pgpkeys.mit.edu --recv-keys 579C25F5 # 验证是否同步到公网，网络不好可能需多试几次
+```
+
+**注：如果有多个 public key，设置默认 key。**修改`~/.gnupg/gpg.conf`
+
+```sh
+# If you have more than 1 secret key in your keyring, you may want to
+# uncomment the following option and set your preferred keyid.
+default-key 28681CB1
+```
+
+**如果有多个 public key, 也可以删除无用的 key：**
+
+```shell
+$ gpg --delete-secret-keys 29BBC3CB # 先删除私钥，指明key id
+gpg (GnuPG) 2.2.27; Copyright (C) 2021 g10 Code GmbH
+This is free software: you are free to change and redistribute it.
+There is NO WARRANTY, to the extent permitted by law.
+
+sec rsa4096/EE8DAE7D29BBC3CB 2021-04-27 mikexue <mi...@apache.org>
+
+Delete this key from the keyring? (y/N) y
+This is a secret key! - really delete? (y/N) y
+```
+
+```shell
+$ gpg --delete-keys 29BBC3CB # 删除公钥，指明key id
+gpg (GnuPG) 2.2.27; Copyright (C) 2021 g10 Code GmbH
+This is free software: you are free to change and redistribute it.
+There is NO WARRANTY, to the extent permitted by law.
+
+
+pub rsa4096/EE8DAE7D29BBC3CB 2021-04-27 mikexue <mi...@apache.org>
+
+Delete this key from the keyring? (y/N) y
+```
+
+由于公钥服务器没有检查机制，任何人都可以用你的名义上传公钥，所以没有办法保证服务器上的公钥的可靠性。 通常，你可以在网站上公布一个公钥指纹，让其他人核对下载到的公钥是否为真。
+
+```shell
+# fingerprint参数生成公钥指纹：
+$gpg --fingerprint mikexue
+pub rsa4096 2021-04-26 [SCA]
+ F84A 0041 D70B 37AF 9C7B F0B3 39F4 29D7 579C 25F5
+uid [ultimate] mikexue <mi...@apache.org>
+sub rsa4096 2021-04-26 [E]
+```
+
+登录 [https://id.apache.org](https://id.apache.org/), 将上面的 fingerprint （即 F84A 0041 D70B 37AF 9C7B F0B3 39F4 29D7 579C 25F5） 粘贴到自己的用户信息中 OpenPGP Public Key Primary Fingerprint
+
+
+
+## 发布Apache Maven仓库
+
+> 注：EventMesh使用Gradle构建，需修改gradle相关配置
+
+### 1.导出私钥文件
+
+```shell
+$ gpg --export-secret-keys -o secring.gpg #私钥文件妥善保管，后面配置需要
+```
+
+### 2.准备分支
+
+从主干分支拉取新分支作为发布分支，如现在要发布$`{release_version}`版本，则从develop分支拉出新分支`${release_version}-release`，此后`${release_version}` Release Candidates涉及的修改及打标签等都在`${release_version}-release`分支进行，最终发布完成后合入主干分支。
+
+### 3.更新版本说明
+
+更新官网项目的如下文件，并提交至master分支：
+
+https://github.com/apache/incubator-eventmesh-site/tree/master/events/release-notes
+
+### 4.配置根项目下gradle.properties文件
+
+```shell
+group=org.apache.eventmesh
+version=1.2.0-release
+#40位公钥的最后8位
+signing.keyId=579C25F5
+#生成密钥时填的passphrase
+signing.password=
+#导出的私钥文件secring.gpg路径
+signing.secretKeyRingFile=../secring.gpg
+#apache 账号
+apacheUserName=
+#apache 密码
+apachePassWord=
+```
+
+### 5.检查子模块下gradle.properties文件
+
+```shell
+group=org.apache.eventmesh
+version=${release_version}
+```
+
+### 6.检查并配置根项目下build.gradle文件
+
+```shell
+publishing {
+ publications {
+ mavenJava(MavenPublication) {
+ from components.java
+ artifact packageSources
+ artifact packageJavadoc
+ versionMapping {
+ usage('java-api') {
+ fromResolutionOf('runtimeClasspath')
+ }
+ usage('java-runtime') {
+ fromResolutionResult()
+ }
+ }
+ pom {
+ name = 'EventMesh'
+ description = 'Apache EventMesh'
+ url = 'https://github.com/apache/incubator-eventmesh'
+ licenses {
+ license {
+ name = 'The Apache License, Version 2.0'
+ url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+ }
+ }
+ developers {
+ developer {
+ id = 'Apache EventMesh(incubating)'
+ name = 'Apache EventMesh(incubating) of ASF'
+ url = 'https://eventmesh.apache.org/'
+ }
+ }
+ scm {
+ connection = 'scm:git:git@github.com:apache/incubator-eventmesh.git'
+ developerConnection = 'scm:git:git@github.com:apache/incubator-eventmesh.git'
+ url = 'https://github.com/apache/incubator-eventmesh'
+ }
+ }
+ }
+ }
+ repositories {
+ maven {
+ def releasesRepoUrl = 'https://repository.apache.org/service/local/staging/deploy/maven2/'
+ def snapshotsRepoUrl = 'https://repository.apache.org/content/repositories/snapshots/'
+ url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+ credentials {
+ username apacheUserName
+ password apachePassWord
+ }
+
+ }
+ }
+}
+
+signing {
+ sign publishing.publications.mavenJava
+}
+```
+
+### 7.上传发布包
+
+执行如下命令，需要对jar、源码包、doc和pom等文件签名加密
+
+```shell
+$ gradle signMavenJavaPublication publish
+```
+
+上述命令执行成功后，待发布版本会自动上传到Apache的临时筹备仓库(staging repository)。所有被deploy到远程[maven仓库](http://repository.apache.org/)的Artifacts都会处于staging状态，访问https://repository.apache.org/#stagingRepositories, 使用Apache的LDAP账户登录后，就会看到上传的版本，`Repository`列的内容即为${STAGING.REPOSITORY}。 点击`Close`来告诉Nexus这个构建已经完成，只有这样该版本才是可用的。 如果电子签名等出现问题，`Close`会失败，可以通过`Activity`查看失败信息。
+
+
+
+## 发布Apache SVN仓库
+
+### 1.准备svn本机环境（Apache使用svn托管项目的发布内容）
+
+### 2.checkout到本地目录
+
+```shell
+$ svn checkout https://dist.apache.org/repos/dist/dev/incubator/eventmesh/
+# 假定本地目录为 ~/apache/eventmesh
+```
+
+### 3.添加gpg公钥
+
+添加public key到[KEYS](https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS)文件并提交到SVN仓库（第一次做发布的人需要做这个操作，具体操作参考KEYS文件里的说明）。KEYS主要是让参与投票的人在本地导入，用来校验sign的正确性
+
+Windows
+
+```sh
+$ gpg --list-sigs <your name> | out-file -append KEYS -encoding utf8
+$ gpg --armor --export <your name> | out-file -append KEYS -encoding utf8
+```
+
+> Mac OS/Linux
+
+```sh
+$ (gpg --list-sigs <your name> && gpg --armor --export <your name>) >> KEYS
+```
+
+### 4.添加待发布内容到SVN目录
+
+```shell
+$ cd ~/apache/eventmesh # eventmesh svn根目录
+$ mkdir ${release_version}-${rc_version}
+```
+
+#### 4.1 创建tag
+
+在`${release_version}-release`分支上创建tag，需带有rc版本，为预发布版本
+
+```shell
+$ git tag -a v{$release_version}-{$rc_version} -m "Tagging the ${release_version} first Release Candidate (Candidates start at zero)"
+$ git push origin --tags
+```
+
+#### 4.2 打包源码
+
+检查项目源码命名，将源码命名为`apache-eventmesh-${release_version}-incubating-src`，将源码打包为tar.gz格式
+
+```shell
+$ tar -czvf apache-eventmesh-${release_version}-incubating-source.tar.gz apache-eventmesh-${release_version}-incubating-src
+```
+
+#### 4.3 打包二进制
+
+> 编译上一步打包的源码
+
+检查编译后的文件命名，将二进制文件命名为`apache-eventmesh-${release_version}-incubating`
+
+> 注：需将源码根目录下的`NOTICE`文件，`DISCLAIMER-WIP`文件以及`tools/third-party-licenses`目录下的`LICENSE`文件拷贝到二进制的包中
+
+```shell
+$ gradle clean jar dist && gradle installPlugin && gradle tar -x test
+$ tar -czvf apache-eventmesh-${release_version}-incubating-bin.tar.gz apache-eventmesh-${release_version}-incubating
+```
+
+压缩source包、bin包，并将相关的压缩包拷贝到svn本地仓库下`/apache/eventmesh/${release_version}-${rc_version}`
+
+### 5.生成签名/sha512文件
+
+> 针对源码包与二进制包生成签名/sha512文件
+
+```shell
+$ for i in *.tar.gz; do echo $i; gpg --print-md SHA512 $i > $i.sha512 ; done #计算sha512
+$ for i in *.tar.gz; do echo $i; gpg --armor --output $i.asc --detach-sig $i ; done #计算签名
+```
+
+### 6.提交到Apache svn
+
+```shell
+$ cd ~/apache/eventmesh # eventmesh svn根目录
+$ svn status
+$ svn commit -m 'prepare for ${release_version}-${rc_version}'
+```
+
+
+
+## 验证Release Candidates
+
+详细检查列表请参考官方的[check list](https://cwiki.apache.org/confluence/display/INCUBATOR/Incubator+Release+Checklist)
+
+从以下地址下载要发布的Release Candidates到本地环境：
+
+```shell
+https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
+```
+
+然后开始验证环节，验证包含但不限于以下内容和形式
+
+### 1.检查签名和hash等信息
+
+> 由于操作系统不同，检查的命令或有差异，具体可参考[官方检查步骤](https://www.apache.org/info/verification.html)
+
+#### 1.1检查sha512哈希
+
+> Mac OS/Linux
+
+```shell
+$ shasum -a apache-eventmesh-${release_version}-incubating-source.tar.gz
+#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-source.tar.gz.sha512文件内容作对比
+$ shasum -a apache-eventmesh-${release_version}-incubating-bin.tar.gz
+#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-bin.tar.gz.sha512文件内容作对比
+```
+
+> Windows
+
+```shell
+$ certUtil -hashfile apache-eventmesh-${release_version}-incubating-source.tar.gz SHA512
+#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-source.tar.gz.sha512文件内容作对比
+$ certUtil -hashfile apache-eventmesh-${release_version}-incubating-bin.tar.gz SHA512
+#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-bin.tar.gz.sha512文件内容作对比
+```
+
+#### 1.2检查gpg签名
+
+首先导入发布人公钥。从svn仓库导入KEYS到本地环境。（发布版本的人不需要再导入，帮助做验证的人需要导入，用户名填发版人的即可）
+
+```shell
+$ curl https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS >> KEYS
+$ gpg --import KEYS
+$ gpg --edit-key "${发布人的gpg用户名}"
+ > trust
+
+Please decide how far you trust this user to correctly verify other users' keys
+(by looking at passports, checking fingerprints from different sources, etc.)
+
+ 1 = I don't know or won't say
+ 2 = I do NOT trust
+ 3 = I trust marginally
+ 4 = I trust fully
+ 5 = I trust ultimately
+ m = back to the main menu
+
+Your decision? 5
+
+ > save
+```
+
+然后使用如下命令检查签名
+
+```shell
+$ gpg --verify apache-eventmesh-${release_version}-incubating-source.tar.gz.asc apache-eventmesh-${release_version}-incubating-source-tar.gz
+$ gpg --verify apache-eventmesh-${release_version}-incubating-bin.tar.gz.asc apache-eventmesh-${release_version}-incubating-bin.tar.gz
+```
+
+### 2.检查源码包的文件内容
+
+解压缩`apache-eventmesh-${release_version}-incubating-source-tar.gz`，进行如下检查:
+
+- 检查源码包是否包含由于包含不必要文件，致使tar包过于庞大
+- 文件夹包含单词`incubating`
+- 存在`LICENSE`和`NOTICE`文件
+- 存在`DISCLAIMER`文件
+- `NOTICE`文件中的年份正确
+- 只存在文本文件，不存在二进制文件
+- 所有文件的开头都有ASF许可证
+- 能够正确编译，单元测试可以通过 (./gradle build) (目前支持JAVA 8/gradle 7.0/idea 2021.1.1及以上)
+- 检查是否有多余文件或文件夹，例如空文件夹等
+
+### 3.检查二进制包的文件内容
+
+- 文件夹包含单词`incubating`
+- 存在`LICENSE`和`NOTICE`文件
+- 存在`DISCLAIMER`文件
+- `NOTICE`文件中的年份正确
+- 所有文本文件开头都有ASF许可证
+- 检查第三方依赖许可证：
+ - 第三方依赖的许可证兼容
+ - 所有第三方依赖的许可证都在`LICENSE`文件中声名
+ - 依赖许可证的完整版全部在`license`目录
+ - 如果依赖的是Apache许可证并且存在`NOTICE`文件，那么这些`NOTICE`文件也需要加入到版本的`NOTICE`文件中
+
+你可以参考此文章：[ASF第三方许可证策](https://apache.org/legal/resolved.html)
+
+## 发起投票
+
+> EventMesh 仍在孵化阶段，需要进行两次投票
+
+- EventMesh社区投票，发送邮件至：`dev@eventmesh.apache.org`
+- incubator社区投票，发送邮件至：`general@incubator.apache.org` EventMesh毕业后，只需要在EventMesh社区投票
+
+### 1.EventMesh社区投票阶段
+
+1. EventMesh社区投票，发起投票邮件到`dev@eventmesh.apache.org`。PMC需要先按照文档检查版本的正确性，然后再进行投票。 经过至少72小时并统计到3个`+1 PMC member`票后，即可进入下一阶段的投票。
+2. 宣布投票结果,发起投票结果邮件到`dev@eventmesh.apache.org`。
+
+### 2.EventMesh社区投票模板
+
+标题：
+
+```
+[VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
+```
+
+正文：
+
+```
+Hello EventMesh Community,
+
+ This is a call for vote to release Apache EventMesh (incubating) version ${release_version}-${rc_version}.
+
+ Release notes:
+ https://github.com/apache/incubator-eventmesh/releases/tag/v${release_version}-${rc_version}
+
+ The release candidates:
+ https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
+
+ Maven artifacts are available in a staging repository at:
+ https://repository.apache.org/content/repositories/orgapacheeventmesh-{staging-id}
+
+ Git tag for the release:
+ https://github.com/apache/incubator-eventmesh/tree/v${release_version}-${rc_version}
+
+ Keys to verify the Release Candidate:
+ https://downloads.apache.org/incubator/eventmesh/KEYS
+
+ Hash for the release tag:
+ #hashCode of this release tag
+
+ GPG user ID:
+ ${YOUR.GPG.USER.ID}
+
+ The vote will be open for at least 72 hours or until necessary number of votes are reached.
+
+ Please vote accordingly:
+
+ [ ] +1 approve
+
+ [ ] +0 no opinion
+
+ [ ] -1 disapprove with the reason
+
+ Checklist for reference:
+
+ [ ] Download links are valid.
+
+ [ ] Checksums and PGP signatures are valid.
+
+ [ ] Source code distributions have correct names matching the current release.
+
+ [ ] LICENSE and NOTICE files are correct for each EventMesh repo.
+
+ [ ] All files have license headers if necessary.
+
+ [ ] No compiled archives bundled in source archive.
+
+ More detail checklist please refer:
+ https://cwiki.apache.org/confluence/display/INCUBATOR/Incubator+Release+Checklist
+
+Thanks,
+Your EventMesh Release Manager
+```
+
+### 3.宣布投票结果模板
+
+标题：
+
+```
+[RESULT][VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
+```
+
+正文：
+
+```
+Hello Apache EventMesh PPMC and Community,
+
+ The vote closes now as 72hr have passed. The vote PASSES with
+
+ xx (+1 non-binding) votes from the PPMC,
+ xx (+1 binding) votes from the IPMC,
+ xx (+1 non-binding) votes from the rest of the developer community,
+ and no further 0 or -1 votes.
+
+ The vote thread: {vote_mail_address}
+
+ I will now bring the vote to general@incubator.apache.org to get approval by the IPMC.
+ If this vote passes also, the release is accepted and will be published.
+
+Thank you for your support.
+Your EventMesh Release Manager
+```
+
+### 4.Incubator社区投票阶段
+
+1. Incubator社区投票，发起投票邮件到`general@incubator.apache.org`，需3个 `+1 IPMC Member`投票，方可进入下一阶段。
+2. 宣布投票结果,发起投票结果邮件到`general@incubator.apache.org` 并抄送至`dev@eventmesh.apache.org`。
+
+### 5.Incubator社区投票模板
+
+标题：
+
+```
+[VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
+```
+
+内容：
+
+```
+Hello Incubator Community,
+
+ This is a call for a vote to release Apache EventMesh(Incubating) version ${release_version} ${rc_version}
+
+ The Apache EventMesh community has voted on and approved a proposal to release
+ Apache EventMesh(Incubating) version ${release_version} ${rc_version}
+
+ We now kindly request the Incubator PMC members review and vote on this
+ incubator release.
+
+ EventMesh community vote thread:
+ • [投票链接]
+
+ Vote result thread:
+ • [投票结果链接]
+
+ The release candidate:
+ •https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
+
+ Git tag for the release:
+ • https://github.com/apache/incubator-eventmesh/tree/${release_version}-${rc_version}
+ Release notes:
+ • https://github.com/apache/incubator-eventmesh/releases/tag/${release_version}-${rc_version}
+
+ The artifacts signed with PGP key [填写你个人的KEY], corresponding to [填写你个人的邮箱], that can be found in keys file:
+ • https://downloads.apache.org/incubator/eventmesh/KEYS
+
+ The vote will be open for at least 72 hours or until necessary number of votes are reached.
+
+ Please vote accordingly:
+
+ [ ] +1 approve
+ [ ] +0 no opinion
+ [ ] -1 disapprove with the reason
+
+Thanks,
+On behalf of Apache EventMesh(Incubating) community
+```
+
+### 6.宣布投票结果模板
+
+标题：
+
+```
+[RESULT][VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
+```
+
+内容：
+
+```
+Hi all,
+
+ Thanks for reviewing and voting for Apache EventMesh(Incubating) version ${release_version} ${rc_version} release, I am happy to announce the release voting has passed with [投票结果数] binding votes, no +0 or -1 votes.
+
+ Binding votes are from IPMC
+ - xxx
+ - xxx
+ - xxx
+
+ Non-binding votes:
+ +1 xxx
+ +0 xxx
+ -1 xxx
+
+ The voting thread is:
+ • [投票结果链接]
+
+ Many thanks for all our mentors helping us with the release procedure, and all IPMC helped us to review and vote for Apache EventMesh(Incubating) release. I will be working on publishing the artifacts soon.
+
+Thanks,
+On behalf of Apache EventMesh(Incubating) community
+```
+
+## 正式发布
+
+### 1.合并分支
+
+合并`${release_version}-release`分支的改动到`master`分支，合并完成后删除`release`分支
+
+```shell
+$ git checkout master
+$ git merge origin/${release_version}-release
+$ git pull
+$ git push origin master
+$ git push --delete origin ${release_version}-release
+$ git branch -d ${release_version}-release
+```
+
+### 2.迁移源码与二进制包
+
+将源码和二进制包从svn的`dev`目录移动到`release`目录
+
+```shell
+$ svn mv https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version} https://dist.apache.org/repos/dist/release/incubator/eventmesh/ -m "transfer packages for ${release_version}-${rc_version}" #移动源码包与二进制包
+$ svn delete https://dist.apache.org/repos/dist/release/incubator/eventmesh/KEYS -m "delete KEYS" #清除原有release目录下的KEYS
+$ svn cp https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS https://dist.apache.org/repos/dist/release/incubator/eventmesh/ -m "transfer KEYS for ${release_version}-${rc_version}" #拷贝dev目录KEYS到release目录
+```
+
+### 3.确认dev和release下的包是否正确
+
+- 确认[dev](https://dist.apache.org/repos/dist/dev/incubator/eventmesh/)下的`${release_version}-${rc_version}`已被删除
+- 删除[release](https://dist.apache.org/repos/dist/release/incubator/eventmesh/)目录下上一个版本的发布包，这些包会被自动保存在[这里](https://archive.apache.org/dist/incubator/eventmesh/)
+
+```shell
+$ svn delete https://dist.apache.org/repos/dist/release/incubator/eventmesh/${last_release_version} -m "Delete ${last_release_version}"
+```
+
+### 4.在Apache Staging仓库发布版本
+
+- 登录http://repository.apache.org , 使用Apache账号登录
+- 点击左侧的Staging repositories，
+- 搜索EventMesh关键字，选择你最近上传的仓库，投票邮件中指定的仓库
+- 点击上方的`Release`按钮，这个过程会进行一系列检查
+
+> 等仓库同步到其他数据源，一般需要24小时
+
+### 5.GitHub版本发布
+
+1.Tag the commit (on which the vote happened) with the release version without `-${RELEASE_CANDIDATE}`. 例如：after a successful vote on `v1.2-rc5`, the hash will be tagged again with `v1.2` only.
+
+2.在 [GitHub Releases](https://github.com/apache/incubator-eventmesh/releases) 页面的 `${release_version}` 版本上点击 `Edit`
+
+编辑版本号及版本说明，并点击 `Publish release`
+
+### 6.更新下载页面
+
+等待并确认新的发布版本同步至 Apache 镜像后，更新如下页面：
+
+https://eventmesh.apache.org/download/
+
+https://eventmesh.apache.org/zh/download/
+
+GPG签名文件和哈希校验文件的下载连接应该使用这个前缀：`https://downloads.apache.org/incubator/eventmesh/`
+
+> 注意：项目下载链接应该使用 https://www.apache.org/dyn/closer.lua 而不是 closer.cgi 或者 mirrors.cgi
+
+### 7.邮件通知版本发布完成
+
+> 请确保Apache Staging仓库已发布成功，一般是在该步骤的24小时后发布邮件
+
+发邮件到 `dev@eventmesh.apache.org` 、 `announce@apache.org`和`general@incubator.apache.org`
+
+标题：
+
+```
+[ANNOUNCE] Apache EventMesh (incubating) ${release_version} available
+```
+
+正文：
+
+```
+Hi all,
+
+Apache EventMesh (incubating) Team is glad to announce the new release of Apache EventMesh (incubating) ${release_version}.
+
+Apache EventMesh (incubating) is a dynamic cloud-native eventing infrastructure used to decouple the application and backend middleware layer, which supports a wide range of use cases that encompass complex multi-cloud, widely distributed topologies using diverse technology stacks.
+
+Download Links: https://eventmesh.apache.org/projects/eventmesh/download/
+
+Release Notes: https://eventmesh.apache.org/events/release-notes/v${release_version}/
+
+Website: https://eventmesh.apache.org/
+
+EventMesh Resources:
+- Issue: https://github.com/apache/incubator-eventmesh/issues
+- Mailing list: dev@eventmesh.apache.org
+
+
+
+Apache EventMesh (incubating) Team
+```
+
diff --git a/zh/docs/contribute/02-write-unit-test.md b/zh/docs/contribute/02-write-unit-test.md
new file mode 100644
index 00000000..055cdce3
--- /dev/null
+++ b/zh/docs/contribute/02-write-unit-test.md
@@ -0,0 +1,78 @@
+# 单元测试要求
+
+- 每个单元测试都应该使用断言`assertions` 而不是 `System.out` 打印或者`if`语句
+- 每个单元测试都不应该调用其他用例，或者依赖于执行顺序
+- 每个单元测试都应该是可以循环执行的，并且单元测试不可以依赖外部环境，因为单元测试可能在持续集成环境中运行。
+- 每个单元测试的测试范围应该足够小且精准，以便于定位方法级别的问题。
+
+## 路径和命名规则
+
+- 单元测试应该写在`src/test/java`目录下。
+- 单元测试的配置文件应该放在`src/test/resources`目录下，如下示例：
+ - 将被测试的类：`src/main/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBody.java`
+ - 单元测试类：`src/test/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBodyTest.java`
+ - 单元测试配置文件：`src/test/resources/configuration.properties`
+- 单元测试类的包名应该和被测试的类的包名相同
+- 单元测试的类的名字应该是`{被测试的类名+}Test`。 比如：
+ - 将被测试的类是：`EventMeshUtil`
+ - 单元测试类的类名就是： `EventMeshUtilTest`
+- 每个单元测试的名字必须是 `test{+方法名}`，比如：
+ - 将被测试的方法：`addProp(String key, String val)`
+ - 单元测试的名字就是：`testAddProp`
+
+## 断言的用法
+
+
+### 常见的断言
+
+| Methods | Instructions |
+| :-------------- | :-------------- |
+| `assertEquals` | 确定两个对象或原语类型是否相等 |
+| `assertNotEquals` | 确定两个对象或原语类型是否不相等 |
+| `assertTrue` | 确定给定的布尔值是否是 `true` |
+| `assertFalse` | 确定给定的布尔值是否是 `false` |
+| `assertNull` | 确定给定的对象是否是 `null` |
+| `assertNotNull` | 确定给定的对象是否不是 `null` |
+| `assertAll` | 如果同时处理多个逻辑，如果只有一个逻辑断言失败，整个测试将会失败|
+
+### 示例
+
+#### `assertEquals()`
+
+```java
+configuration.init();
+Assert.assertEquals("value1", configuration.eventMeshEnv);
+```
+
+#### `assertTrue()`
+
+```java
+BaseResponseHeader header = BaseResponseHeader.buildHeader("200");
+Assert.assertTrue(header.toMap().containsKey(ProtocolKey.REQUEST_CODE));
+```
+
+#### `assertFalse()`
+
+```java
+Class<NacosRegistryService> nacosRegistryServiceClass = NacosRegistryService.class;
+Field initStatus = nacosRegistryServiceClass.getDeclaredField("INIT_STATUS");
+initStatus.setAccessible(true);
+Object initStatusField = initStatus.get(nacosRegistryService);
+Assert.assertFalse((Boolean.parseBoolean(initStatusField.toString())));
+```
+
+#### `assertNull()`
+
+```java
+DefaultFullHttpResponse response = httpCommand.httpResponse();
+Assert.assertNull(response);
+```
+
+#### `assertNotNull()`
+
+```java
+Codec.Decoder cd = new Codec.Decoder();
+ArrayList<Object> result = new ArrayList<>();
+cd.decode(null, buf, result);
+Assert.assertNotNull(result.get(0));
+```
diff --git a/zh/docs/contribute/03-new-contributor-guidelines.md b/zh/docs/contribute/03-new-contributor-guidelines.md
new file mode 100644
index 00000000..5a8e4299
--- /dev/null
+++ b/zh/docs/contribute/03-new-contributor-guidelines.md
@@ -0,0 +1,262 @@
+
+# 如何成为EventMesh的贡献者(Contributor)
+
+如果您想向 eventmesh 社区提交代码，成为的新贡献者(Contributor)，请阅读本文档.
+
+本文档描述了如何向社区提交代码的一般流程。如果您在文档中发现任何问题，欢迎留下评论或建议。
+
+## 准备工作
+
+### 开发环境
+
+- 您应该在您的开发环境中安装JDK，建议 JDK 8 及以上版本。
+- 您应该在您的开发环境中安装Gradle，建议 Gradle 7 及以上版本。
+
+### 代码风格
+
+将[EventMesh CheckStyle](https://github.com/apache/incubator-eventmesh/blob/master/style/checkStyle.xml) 文件导入到您的IDEA。
+
+对于IDEA，您可以通过以下方式导入检查样式文件:
+```shell
+ Editor -> Code Style -> Java -> Scheme -> Import Scheme -> CheckStyle Configuration
+```
+
+如果您在导入方案下看不到CheckStyle配置部分，您可以先安装CheckStyle-IDEA插件，就可以看到它。
+
+您也可以使用`./gradlew check`来检查代码风格。
+(注意：这个命令将检查项目中的所有文件，当您提交一个项目时，CI将只检查这个项目中被修改的文件）。
+
+CheckStyle-IDEA插件导入演示：
+
+a.如图安装CheckStyle-IDEA插件
+
+
+
+b.下载完成后需要导入EventMesh的检查样式文件，如下步骤：
+
+1.如图：
+
+
+
+2.当点击+号之后会出现以下界面
+
+
+
+标号1的地方简单取个名字即可，标号2的地方是EventMesh CheckStyle文件的位置，在项目的style文件夹下。
+
+3.点击finish之后就会出现下图界面
+
+
+
+将添加的样式检查文件勾选上并Apply
+
+c.当完成以上步骤之后就可以在您完成代码编写后进行样式检查了，步骤如下：
+
+1.选择添加的EM-checks文件。
+
+
+
+2.点击这两个地方都可检查文件样式
+
+
+
+这两个标号都只检测当前页的文件样式，标号2在当前页鼠标右键即可出现。
+
+### 工作流程
+
+以下是贡献者提交代码的工作流程:
+
+0. 在提交PR之前需要先创建一个ISSUE，它是用来表达你的想法的，比如你发现了代码中的bug，想修复这个bug，那么需要告知社区管理者或贡献者你的想法，就要创建一个ISSUE用于交流讨论。在EventMesh社区有ISSUE模板，可根据您提出的ISSUE中讨论的内容使用相应的模板。
+
+ISSUE创建示例:
+ a.进入到项目仓库的主页，切换到issue标签，点击New issue
+ 
+
+ b.就会出现下图界面
+ 
+ 根据你的需要选择不同的ISSUE模板，如果你觉得没有模板合适，你可以选择打开一个空白模板。
+ 当前EventMesh提供了六种ISSUE模板
+ Bug report: 发现代码bug，请使用此模板
+ Documentation Related: 文档相关的，请使用此模板
+ Enhancement Request: 代码优化，增强代码实现的，请使用此模板
+ Feature Request: 为EventMesh提供新的特性功能的使用此模板
+ Question: 对于EventMesh有疑问的，或者有什么不明白的想要提问的，请使用此模板
+ Unit Test: 想为EventMesh做一些单元测试的，请使用此模板
+
+ c.根据模板的提示，完成issue内容填写。主要是描述清楚问题所在和解决方案就可以了
+
+ [ISSUE实例](https://github.com/apache/incubator-eventmesh/issues/2148)
+ 如图：
+ 
+
+ISSUE与PR关联：
+ 后续提交PR的时候，PR的标题和内容应该跟ISSUE完成关联，这样才符合开源的规范，如下图所示
+
+ 
+
+ 上图ISSUE编号为2148，那么你的PR标题前就是 [ISSUE #2148]，这样就关联上了。
+
+
+1. 在issue创建完成后，将源仓库的项目eventmesh fork到自己仓库当中
+例：
+ a.点击eventmesh右上角的fork
+ 
+ b.就会出现下图，点击Create fork即可将eventmesh fork到自己的仓库
+ 
+
+
+2. fork完成后，克隆自己仓库的代码到本地
+```git
+git clone git@github.com:yourgithub/incubator-eventmesh.git
+```
+
+3. 创建一个新的分支进行工作
+```git
+git checkout -b fix_patch_xx
+```
+
+4. 让您的分支保持同步
+```git
+git remote add upstream git@github.com:apache/incubator-eventmesh.git
+git fetch upstream master:upstream_master
+git rebase upstream_master
+```
+
+5. 提交您的修改（确保您的提交信息简洁明了）
+
+**特别注意：在提交代码之前要确保你提交代码的邮箱要与GitHub邮箱一致，不然在统计contributor数量时会发生无法正常计入的情况**
+
+- 在IDEA中打开Terminal(终端)，输入以下命令查看本地使用的邮箱信息
+```git
+git config --global --list
+```
+如图：
+
+如果你在提交之前还未登陆邮箱，使用注册GitHub账号时的邮箱
+
+- 如果你发现你的邮箱与GitHub邮箱不一致可通过以下git命令进行修改
+```git
+git config --global user.name 你的目标用户名
+git config --global user.email 你的目标邮箱名
+```
+如图：
+
+修改邮箱同理(也可以用这个命令来登陆邮箱)
+
+例：用IDEA提交代码为例，如果您在IDEA本地修改完毕
+ a.点击Commit，点击图片中两个地方中任意一个即可
+ 
+ b.就会出现以下图中界面
+ 
+ （注：如果是新添加的文件需要Add一下，再Commit，一般IDEA都会提示，如果没有提示，按下图操作即可，文件由红色变为绿色Add成功）
+ 
+
+6. 将您的提交推送到自己的fork仓库
+ a.需要push到远程仓库中，注意是您自己的仓库，您需要点击
+ 
+ 或者是
+ 
+ b.就会出现以下界面，确认无误后点击右下角push，就push到自己的仓库了
+ 
+ c.当您成功push到自己仓库就会出现下图的提示（在IDEA界面的右下角）
+ 
+
+7. 创建一个Pull Request (PR)
+例：
+ a.当您成功push到自己的仓库当中后，进入自己的仓库主页，会出现下图界面
+ 
+ b.点击Compare & pull request，就会出现以下界面，按照图中操作即可创建pull request
+ 
+
+
+## 解释
+
+原始仓库：https://github.com/apache/incubator-eventmesh Eventmesh的apache仓库在文中被称为原始仓库。
+
+fork库: 从 https://github.com/apache/eventmesh fork到你自己的个人仓库，成为一个fork库。
+
+因此，首先需要将原EventMesh仓库fork到你自己的仓库中。
+
+## 开发分支
+
+**EventMesh 当前的开发分支是 master。请向该分支提交 PR。**
+
+- 我们建议您在本地master分支的基础上创建一个新的开发分支，在该开发分支上提交代码，并基于该分支向原始仓库的master分支提交PR。
+
+## 贡献类别
+
+### 错误反馈或错误修复
+
+- 无论是bug反馈还是修复，都需要先创建一个ISSUE，对bug进行详细描述，这样社区就可以通过问题记录轻松找到并查看问题和代码。bug反馈问题通常需要包含完整的bug信息描述和可重现的场景。
+
+### 功能的实现，重构
+
+- 如果你计划实现一个新功能（或重构），一定要通过 ISSUE 或其他方式与 eventmesh 核心开发团队沟通，并在沟通过程中详细描述新功能（或重构）、机制和场景。
+
+### 文档改进
+
+- 您可以在 [eventmesh-docs](https://github.com/apache/incubator-eventmesh/tree/master/docs) 找到 eventmesh 文档。文档的补充或改进对 eventmesh 是必不可少的。
+
+## 贡献方式
+
+新的贡献者有两种方式来为 eventmesh 社区作出贡献:
+
+- 如果您在 eventmesh 代码中发现了一个你想修复的 bug，或者你为 eventmesh 提供了一个新功能，请在 eventmesh 中提交一个Issue，并向 eventmesh 提交一份 PR。
+
+- eventmesh 社区有其他贡献者提出的ISSUE，这里是社区整理的 [`issue for first-time contributors`](https://github.com/apache/incubator-eventmesh/issues/888) 是相对简单的 PR，可以帮助你熟悉向 eventmesh 社区做贡献的过程。
+
+## 提交ISSUE指南
+
+- 如果您不知道如何在 eventmesh 上提Issue，请阅读前文，或阅读 [about the issue](https://docs.github.com/cn/issues/tracking-your-work-with-issues/quickstart) 。
+
+- 在 eventmesh 社区，有Issue模板可以参考，如果类型匹配请使用该模板，如果Issue模板不符合你的要求，你可以开一个空的Issue模板，对于问题请带上其匹配的功能标签。
+
+- 对于Issue的名称，请用一句话简要描述你的Issue或目的，为了更好的全球交流，请用英文书写。
+
+## Pull Request（PR）提交指南
+
+- 如果你不知道如何为 eventmesh 发起一个 PR，请阅读前文，或参见 [about pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) 。
+
+- 无论是 bug 修复，还是新功能开发（如果这个 pr 是新功能开发，那么关于新功能的文档更新应该包括在这个 pr 中），请向当前开发分支 master 提交 PR。
+
+- 提交的pr应该遵循eventmesh提供的模板以及需要写的提交信息，简单描述你提交的pr是做什么的就可以了，请阅读 [模板详情](https://github.com/apache/incubator-eventmesh/blob/master/.github/PULL_REQUEST_TEMPLATE.md) 。
+
+- 你提交的PR需要与你要修复的问题，或你要提出的问题相关联，所以你的PR标题应该以[ISSUE #xx]开头。
+
+- 如果你的修改是关于一个错别字或小的优化，你不需要创建一个问题，只要提交一个PR和标题为[MINOR]。
+
+**注意：**
+
+- 一个拉动请求不应该太大。如果需要大量的修改，最好将这些修改分成几个单独的 PR。
+
+- 在创建PR后，一个或多个提交人将帮助审查该拉动请求，在批准后，该PR将被合并到eventmesh主源库中，相关的Issue将被关闭。
+
+## 审查
+
+### PR审查
+
+所有的代码都应该由一个或多个提交者进行良好的审查。一些原则。
+
+- 可读性。重要的代码应该有良好的文档。遵守我们的 [代码风格](https://github.com/apache/incubator-eventmesh/blob/master/style/checkStyle.xml) 。
+
+- 优雅性。新的函数、类或组件应该是精心设计的。
+
+- 可测试性。重要的代码应该经过良好的测试（高单元测试覆盖率）。
+
+### 许可证审查
+
+EventMesh遵循 [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0.html) 政策。所有源文件应
+在文件头中添加Apache许可证头。EventMesh 使用 [apache/skywalking-eyes](https://github.com/apache/skywalking-eyes) 来检查
+源文件的头。
+
+### PR合并
+
+当一个PR被至少一个提交者批准后，它就可以被合并了。合并前，提交者可以对提交信息进行修改，要求提交的
+消息要清楚，不能有重复，并使用 Squash 和 Merge 来确保一个 PR 只应包含一个提交。
+对于大型的多人PR，使用Merge合并，在合并前通过rebase修复提交。
+
+## 社区
+
+### 联系我们
+
+Mail: dev@eventmesh.apache.org
diff --git a/zh/docs/contribute/_category_.json b/zh/docs/contribute/_category_.json
new file mode 100644
index 00000000..56d36f91
--- /dev/null
+++ b/zh/docs/contribute/_category_.json
@@ -0,0 +1,5 @@
+{
+ "position": 5,
+ "label": "Contribute",
+ "collapsed": false
+}
diff --git a/zh/docs/desing-document/01-workflow.md b/zh/docs/desing-document/01-workflow.md
new file mode 100644
index 00000000..444c0945
--- /dev/null
+++ b/zh/docs/desing-document/01-workflow.md
@@ -0,0 +1,258 @@
+# EventMesh工作流
+
+## 业务场景
+
+图中你正在构建一个简单的电商订单管理系统，系统能够接收和调配新的订单，调配流程需要处理所有的订单创建，付款处理以及发货处理。
+
+为了实现高可用和高性能，你可以使用事件驱动架构（EDA）构建微服务应用去处理商店前端，订单管理，支付处理和发货管理。你可以在云上部署整个系统。要处理高并发，你可以利用消息系统缓冲，并扩展多个微服务实例。架构类似于：
+
+
+
+当每个微服务都在自己的事件通道上运行时，EventMesh在执行事件编排方面发挥着至关重要的作用。
+
+我们使用 [CNCF Serverless工作流](https://serverlessworkflow.io/) 来描述此事件工作流编排。
+
+## CNCF Serverless工作流
+
+CNCF Serverless工作流定义了一个厂商中立、开源和完全社区驱动的生态系统，用于定义和运行针对Serverless技术领域的基于DSL的工作流。
+
+Serverless工作流定义了一种领域特定语言（DSL）来描述有状态和无状态的基于工作流的serverless函数和微服务编排。
+
+详见[官方github](https://github.com/serverlessworkflow/specification)
+
+## EventMesh工作流
+
+我们利用Serverless工作流DSL来描述EventMesh工作流。根据其规范，工作流由一系列用于描述控制流逻辑的工作流状态组成。目前，我们仅支持与事件相关的工作流状态。请参见[工作流DSL设计](#workflow-dsl-design-wip)中支持的状态。
+
+`工作流状态`可以包含通用的`操作`，或在工作流执行期间应调用的服务/函数。这些`操作`可以引用可复用的`函数`定义（应如何调用这些函数/服务），还可以引用触发基于事件的服务调用的事件，以及要等待的事件，这些事件表示这种基于事件的服务调用完成。
+
+在EDA解决方案中，我们通常使用AsyncAPI定义事件驱动的微服务。Serverless工作流“函数”定义支持使用AsyncAPI定义调用语义。有关详细信息，请参见[Using Funtions for AsyncAPI Service](https://github.com/serverlessworkflow/specification/blob/main/specification.md#using-functions-for-async-api-service-invocations)。
+
+### AsyncAPI
+
+AsyncAPI是一项开源计划，旨在改善事件驱动体系结构（EDA）的当前状态。我们的长期目标是让使用EDA和使用REST API一样容易。包括从文档到代码生成、发现到事件管理。现在应用于REST API的大多数流程也适用于事件驱动/异步API。
+
+详见[AsyncAPI官网](https://www.asyncapi.com/docs/getting-started)
+
+### 工作流示例
+
+在本示例中，我们构建了上面订单管理系统的事件驱动工作流。
+
+首先，我们需要为我们的微服务应用定义AsyncAPI。
+
+- 在线商店应用程序
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Online Store application
+ version: '0.1.0'
+channels:
+ store/order:
+ subscribe:
+ operationId: newStoreOrder
+ message:
+ $ref : '#/components/NewOrder'
+
+```
+
+- 订单服务
+
+```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'
+```
+
+- 支付服务
+
+```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'
+```
+
+- 物流服务
+
+```yaml
+asyncapi: 2.2.0
+info:
+ title: Shipment Service
+ version: '0.1.0'
+channels:
+ shipment/inbound:
+ publish:
+ operationId: sendShipment
+ message:
+ $ref : '#/components/OrderShipment'
+```
+
+接下来，定义描述订单管理业务逻辑的订单工作流。
+
+```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
+```
+
+对应的工作流图如下：
+
+
+
+## EventMesh工作流引擎
+
+在下面的体系结构图中, EventMesh目录, EventMesh工作流引擎 和 EventMesh Runtime在三个不同的处理器中运行。
+
+
+
+运行工作流的步骤如下：
+
+1. 在环境中部署发布者和订阅者应用程序。
+ 使用AsyncAPI描述应用程序API，生成asyncAPI yaml。
+ 使用AsyncAPI在EventMesh目录中注册发布者和订阅者应用程序。
+
+2. 在EventMesh工作流引擎中注册Serverless工作流DSL。
+
+3. 工作流引擎从EventMesh目录查询发布服务器和订阅服务器的需要的工作流DSL`函数`。
+
+4. 事件驱动App将事件发布到EventMesh Runtime触发工作流。EventMesh工作流引擎发布和订阅事件、编排事件。
+
+### EventMesh Catalog 设计
+
+EventMesh目录存储发布者、订阅者和通道元数据。由以下模块组成：
+
+- AsyncAPI解析器
+
+ 使用AsyncAPI社区提供的SDK ([tool list](https://www.asyncapi.com/docs/community/tooling)),
+ 解析并验证AsyncAPI yaml输入，并生成AsyncAPI定义。
+
+- 发布者, 通道, 订阅者模块
+
+ 从AsyncAPI定义存储发布者、订阅者和通道信息。
+
+### EventMesh工作流引擎设计
+
+工作流引擎由以下模块组成：
+
+- 工作流解析器
+
+ 使用Serverless Workflow社区提供的SDK([SDKs](https://github.com/serverlessworkflow/specification#sdks)),
+ 解析和验证工作流DSL输入，并生成工作流定义。
+
+- 工作流模块
+
+ 管理工作流实例的生命周期，从创建、启动、停止到销毁。
+
+- 状态模块
+
+ 管理工作流状态生命周期。支持与事件相关的状态，and the supported state list below is Work-in-Progress.
+
+ | 工作流状态 | 描述 |
+ | --- | --- |
+ | Operation | 执行Actions中定义的AsyncAPI函数 |
+ | Event | 检查定义的事件是否匹配，如果匹配，执行定义的AsyncAPI函数 |
+ | Switch | 检查事件是否与事件条件匹配，并执行定义的AsyncAPI函数 |
+ | Parallel | 并行执行定义的AsyncAPI函数 |
+ | ForEach | 迭代输入集合并执行定义的AsyncAPI函数 |
+
+- 行为模块
+
+ 管理函数中的行为。
+
+- 函数模块
+
+ 通过在EventMesh Runtime中创建发布者和/或订阅者来管理AsyncAPI函数，并管理发布者/订阅者生命周期。
+
+ | AsyncAPI 操作 | EventMesh Runtime |
+ | --- | --- |
+ | Publish | Publisher |
+ | Subscribe | Subscriber |
+
+- 事件模块
+
+ 使用工作流DSL中定义的规则管理CloudEvent数据模型，包括事件过滤器、关联和转换。
+
+- 重试模块
+
+ 管理事件发布到EventMesh Runtime的重试逻辑。
diff --git a/zh/docs/desing-document/02-runtime-protocol.md b/zh/docs/desing-document/02-runtime-protocol.md
new file mode 100644
index 00000000..d5f15560
--- /dev/null
+++ b/zh/docs/desing-document/02-runtime-protocol.md
@@ -0,0 +1,420 @@
+# TCP协议文档
+
+#### 1. 协议格式
+
+
+
+**消息组成详解：**
+
+```
+魔术字：9位，当前值为“EventMesh”
+
+通信协议版本号：4位，当前值为“0000”
+
+消息总长度值(length)：4位，int类型
+
+消息头长度值(headerLength)：4位，int类型
+
+消息头(header)：长度 = headerLength
+
+消息体(body)：长度 = length - headerLength - 4 - 4
+```
+
+#### 2. 业务逻辑层
+
++ 消息组成
+
+消息头（header）+ 消息体（body）
+
+```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;
+}
+```
+
++ 详解
+
+消息头(header)：类型为Header，Header中有Command字段，用于区分不同的消息类型
+
+消息体(body)：对于不同的消息类型，body的类型不同
+
+| 消息命令字 | 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 | 无 |
+| 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 |
+
+#### 3. Client 与 Eventmesh-Runtime(Server)交互场景详解
+
+```java
+public enum Command {
+
+ //心跳
+ HEARTBEAT_REQUEST(0), //client发给server的心跳包
+ HEARTBEAT_RESPONSE(1), //server回复client的心跳包
+
+ //握手
+ HELLO_REQUEST(2), //client发给server的握手请求
+ HELLO_RESPONSE(3), //server回复client的握手请求
+
+ //断连
+ CLIENT_GOODBYE_REQUEST(4), //client主动断连时通知server
+ CLIENT_GOODBYE_RESPONSE(5), //server回复client的主动断连通知
+ SERVER_GOODBYE_REQUEST(6), //server主动断连时通知client
+ SERVER_GOODBYE_RESPONSE(7), //client回复server的主动断连通知
+
+ //订阅管理
+ SUBSCRIBE_REQUEST(8), //client发给server的订阅请求
+ SUBSCRIBE_RESPONSE(9), //server回复client的订阅请求
+ UNSUBSCRIBE_REQUEST(10), //client发给server的取消订阅请求
+ UNSUBSCRIBE_RESPONSE(11), //server回复client的取消订阅请求
+
+ //监听
+ LISTEN_REQUEST(12), //client发给server的启动监听请求
+ LISTEN_RESPONSE(13), //server回复client的监听请求
+
+ //RR
+ REQUEST_TO_SERVER(14), //client将RR请求发送给server
+ REQUEST_TO_CLIENT(15), //server将RR请求推送给client
+ REQUEST_TO_CLIENT_ACK(16), //client收到RR请求后ACK给server
+ RESPONSE_TO_SERVER(17), //client将RR回包发送给server
+ RESPONSE_TO_CLIENT(18), //server将RR回包推送给client
+ RESPONSE_TO_CLIENT_ACK(19), //client收到回包后ACK给server
+
+ //异步事件
+ ASYNC_MESSAGE_TO_SERVER(20), //client将异步事件发送给server
+ ASYNC_MESSAGE_TO_SERVER_ACK(21), //server收到异步事件后ACK给client
+ ASYNC_MESSAGE_TO_CLIENT(22), //server将异步事件推送给client
+ ASYNC_MESSAGE_TO_CLIENT_ACK(23), //client收到异步事件后ACK给server
+
+ //广播
+ BROADCAST_MESSAGE_TO_SERVER(24), //client将广播消息发送给server
+ BROADCAST_MESSAGE_TO_SERVER_ACK(25), //server收到广播消息后ACK给client
+ BROADCAST_MESSAGE_TO_CLIENT(26), //server将广播消息推送给client
+ BROADCAST_MESSAGE_TO_CLIENT_ACK(27), //client收到广播消息后ACK给server
+
+ //重定向指令
+ REDIRECT_TO_CLIENT(30), //server将重定向指令推动给client
+}
+```
+
+#### 4. Client发起交互
+
+| 场景 | Client向Server发送消息命令字 | Server回复Client消息的命令字 | 说明 |
+| -------------- | ---------------------------- | ------------------------------- | ---- |
+| 握手 | HELLO_REQUEST | HELLO_RESPONSE | |
+| 心跳 | HEARTBEAT_REQUEST | HEARTBEAT_RESPONSE | |
+| 订阅 | SUBSCRIBE_REQUEST | SUBSCRIBE_RESPONSE | |
+| 取消订阅 | UNSUBSCRIBE_REQUEST | UNSUBSCRIBE_RESPONSE | |
+| 开始监听消息 | LISTEN_REQUEST | LISTEN_RESPONSE | |
+| 发送RR请求 | REQUEST_TO_SERVER | RESPONSE_TO_CLIENT | |
+| 发送RR回包 | RESPONSE_TO_SERVER | 无 | |
+| 发送异步事件 | ASYNC_MESSAGE_TO_SERVER | ASYNC_MESSAGE_TO_SERVER_ACK | |
+| 发送广播事件 | BROADCAST_MESSAGE_TO_SERVER | BROADCAST_MESSAGE_TO_SERVER_ACK | |
+| 客户端主动断连 | CLIENT_GOODBYE_REQUEST | CLIENT_GOODBYE_RESPONSE | |
+
+#### 5. Server发起交互
+
+| 场景 | Server向Client发送消息命令字 | Client回复Server消息命令字 | 说明 |
+| ------------------ | ---------------------------- | ------------------------------- | ---- |
+| 客户端接收RR请求 | REQUEST_TO_CLIENT | REQUEST_TO_CLIENT_ACK | |
+| 客户端接收RR回包 | RESPONSE_TO_CLIENT | RESPONSE_TO_CLIENT_ACK | |
+| 客户端接收异步事件 | ASYNC_MESSAGE_TO_CLIENT | ASYNC_MESSAGE_TO_CLIENT_ACK | |
+| 客户端接收广播事件 | BROADCAST_MESSAGE_TO_CLIENT | BROADCAST_MESSAGE_TO_CLIENT_ACK | |
+| 服务端主动断连 | SERVER_GOODBYE_REQUEST | 无 | |
+| 服务端进行重定向 | REDIRECT_TO_CLIENT | 无 | |
+| | | | |
+
+#### 6. 消息类型
+
++ 发送RR消息
+
+
+
++ 发送异步单播消息
+
+
+
++ 发送广播消息
+
+
+
+## HTTP协议文档
+
+Java类`LiteMessage`的`content`字段表示一个特殊的协议，因此，如果您要使用eventmesh-sdk-java的http-client，则只需设计协议的`content`即可。`LiteMessage`组成如下：
+
+```java
+public class LiteMessage {
+
+ private String bizSeqNo;
+
+ private String uniqueId;
+
+ private String topic;
+
+ private String content;
+
+ private Map<String, String> prop;
+
+ private long createTime = System.currentTimeMillis();
+}
+```
+
+#### 1. 消息发送方式与组成
+
+**消息发送方式**：POST方式
+
+**消息组成**：请求头(RequestHeader) + 请求体(RequestBody)
+
++ 心跳消息
+
+**RequestHeader**
+
+| Key | 说明 |
+| -------- | ---------------- |
+| Env | client所属环境 |
+| Region | client所属区域 |
+| Idc | client所属IDC |
+| Dcn | client所在DCN |
+| Sys | client所属子系统 |
+| Pid | client进程号 |
+| Ip | client Ip |
+| Username | client 用户名 |
+| Passwd | client 密码 |
+| Version | 协议版本 |
+| Language | 语言描述 |
+| Code | 请求码 |
+
+**RequestBody**
+
+| Key | 说明 |
+| ----------------- | ------------------------------ |
+| clientType | 客户端类型 |
+| heartbeatEntities | 心跳实体，包含topic、url等信息 |
+
++ 订阅消息：
+
+**RequestHeader**
+
+与心跳消息一致
+
+**RequestBody**
+
+| Key | 说明 |
+| ----- | ----------------- |
+| topic | 客户端订阅的topic |
+| url | topic对应的url |
+
++ 取消订阅消息：
+
+**RequestHeader**
+
+与心跳消息一致
+
+**RequestBody**
+
+与订阅消息一致
+
++ 发送异步事件：
+
+**RequestHeader**
+
+与心跳消息一致
+
+**RequestBody**
+
+| Key | 说明 |
+| -------- | ----------------------- |
+| topic | 客户端请求的topic |
+| content | 客户端发送的topic的内容 |
+| ttl | 客户端请求超时时间 |
+| bizSeqNo | 客户端请求业务流水号 |
+| uniqueId | 客户端请求消息唯一标识 |
+
+#### 2. Client发起交互
+
+| 场景 | Client向Server发送消息请求码 | Server回复Client消息的响应码 | 说明 |
+| ------------ | ---------------------------- | --------------------------------------- | ---- |
+| 心跳 | HEARTBEAT(203) | SUCCESS(0)/EVENTMESH_HEARTBEAT_ERROR(19) | |
+| 订阅 | SUBSCRIBE(206) | SUCCESS(0)/EVENTMESH_SUBSCRIBE_ERROR(17) | |
+| 取消订阅 | UNSUBSCRIBE(207) | SUCCESS(0)/EVENTMESH_UNSUBSCRIBE_ERROR(18) | |
+| 发送异步事件 | MSG_SEND_ASYNC(104) | SUCCESS(0)/EVENTMESH_SEND_ASYNC_MSG_ERR(14) | |
+
+#### 3. Server发起交互
+
+| 场景 | Server向Client发送消息请求码 | Client回复Server消息响应码 | 说明 |
+| ------------------ | ---------------------------- | -------------------------- | ---------------------- |
+| 客户端接收异步事件 | HTTP_PUSH_CLIENT_ASYNC(105) | retCode | retCode值为0时代表成功 |
+
+## gRPC 协议文档
+
+#### 1. protobuf
+
+在 `eventmesh-protocol-gprc` 模块有 Eventmesh gRPC 客户端的 protobuf 文件. the protobuf 文件路径是 `/src/main/proto/eventmesh-client.proto`.
+
+用gradle build 生成 gRPC 代码在 `/build/generated/source/proto/main`. 生成代码用于 `eventmesh-sdk-java` 模块.
+
+#### 2. gRPC 数据模型
+
++ 消息
+
+以下消息数据模型用于 `publish()`, `requestReply()` 和 `broadcast()` APIs.
+
+```
+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;
+}
+```
+
++ 订阅
+
+以下订阅数据模型用于 `subscribe()` 和 `unsubscribe()` APIs.
+
+```
+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()` API.
+
+```
+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;
+}
+```
+
+#### 3. gRPC 服务接口
+
++ 事件生产端服务 APIs
+
+```
+service PublisherService {
+ # 异步事件生产
+ rpc publish(SimpleMessage) returns (Response);
+
+ # 同步事件生产
+ rpc requestReply(SimpleMessage) returns (Response);
+
+ # 批量事件生产
+ rpc batchPublish(BatchMessage) returns (Response);
+}
+```
+
++ 事件消费端服务 APIs
+
+```
+service ConsumerService {
+ # 所消费事件通过 HTTP Webhook推送事件
+ rpc subscribe(Subscription) returns (Response);
+
+ # 所消费事件通过 TCP stream推送事件
+ rpc subscribeStream(Subscription) returns (stream SimpleMessage);
+
+ rpc unsubscribe(Subscription) returns (Response);
+}
+```
+
++ 客户端心跳服务 API
+
+```
+service HeartbeatService {
+ rpc heartbeat(Heartbeat) returns (Response);
+}
+```
diff --git a/zh/docs/desing-document/03-stream.md b/zh/docs/desing-document/03-stream.md
new file mode 100644
index 00000000..9f733d82
--- /dev/null
+++ b/zh/docs/desing-document/03-stream.md
@@ -0,0 +1,115 @@
+# EventMesh Stream
+
+## 事件流概述
+
+事件流是发布/订阅架构模式的一种实现，它包括以下几个部分
+
+- 消息或事件：状态变化。
+
+- 主题：消息中间件代理中的分区。
+
+- 消费者：可以从代理主题订阅读取事件。
+
+- 生产者：生成事件
+
+事件流是事件的连续流动，为了维持事件之间的秩序，事件流应该以特定的方式从生产者流向消费者。
+
+## 要求
+
+### 功能要求
+
+| 需求编号 | 需求描述 | 注释 |
+| -------------- | ----------------------- | -------- |
+| F-1 | EventMesh用户应该能够在 EventMesh 中实现事件流功能 | 功能性 |
+| F-2 | EventMesh用户可以为路由、过滤、转换等应用动态用户特定逻辑 | 功能性 |
+
+## 设计细节
+
+我们引入了 EventMesh Stream 组件，允许我们在 Apache Camel 中本地使用来自 Spring Cloud Stream 的编程模型和绑定器抽象。
+
+[Spring-Cloud-Stream](https://spring.io/projects/spring-cloud-stream) Spring Cloud Stream是一个用于构建
+与共享消息传递系统连接的、高度可扩展的事件驱动微服务框架。
+
+[Apache Camel](https://camel.apache.org/) Camel 是一个开源集成框架，使您能够快速轻松地集成各种消费或生产数据的系统。
+
+## 架构
+
+
+
+## 设计
+
+### EventMesh-Stream 组件
+
+- Event（事件）
+- Event Channel（事件通道）
+- Event EndPoint（事件端点）
+- Event Pipes & Filters（事件管道和过滤器）
+- Event Routes（事件路由器）
+- Event Converter（事件转换器）
+
+#### Event（事件）
+
+> 事件是系统中传输数据的最小单位。它的结构分为标题、正文和附件。
+
+#### Event Channel（事件通道）
+
+> 事件通道是系统中的逻辑通道，我们是通过 Spring Cloud Stream 编程模型实现的，它具有围绕消息通道的抽象功能（截至目前用的是 Spring `MessageChannel`）。
+
+#### Event EndPoint（事件端点）
+
+> 事件端点是应用程序和消息传递系统之间的接口。我们可以定义两种类型的端点
+
+- 消费者端点 - 出现在路由开始并从传入通道读取传入事件。
+- 生产者端点 - 出现在路由的末尾并将传入事件写入传出通道。
+
+#### Event Pipes & Filters（事件管道和过滤器）
+
+> 我们可以通过创建过滤器链（Apache Camel `Processor`）来构建路由，其中一个过滤器的输出被用于管道中下一个过滤器的输入。管道的主要优点是可以创建复杂的事件处理逻辑。
+
+#### Event Routes（事件路由器）
+
+> 事件路由器是消费者的一种过滤器，并根据决策标准将它们重定向到适当的目标端点。
+
+#### Event Converter（事件转换器）
+
+> 事件转换器用于修改事件内容，将其转换为不同的格式（换而言之 cloudevents -> Event (Camel) -> Binder Message(Spring Message)，反之亦然）。
+
+## EventMesh-Stream 组件接口
+
+### Component（组件）
+
+Component 接口是主要的入口点，您可以使用 Component 对象作为工厂来创建 EndPoint 对象。
+
+
+
+### EndPoint（端点）
+
+EndPoint 作为创建消费者、生产者和事件对象的工厂。
+
+- `createConsumer()` — 创建消费者端点，该端点表示路由开始的源端点。
+- `createProducer()` — 创建生产者端点，该端点表示路由末端的目标端点。
+
+
+
+#### Producer（生产者）
+
+用户可以创建以下类型的生产者
+> 同步生产者：处理线程阻塞，直到生产者完成事件处理。
+
+
+
+未来将会实现的生产者类型：
+
+- 异步生产者 - 生产者在子线程中处理事件。
+
+#### Consumer（消费者）
+
+用户可以创建以下类型的消费者
+> 事件驱动的消费者：当消息绑定器调用消费者中的方法时，开始处理传入请求。
+
+
+
+未来将会实现的消费者类型：
+
+- 定时轮训消费者
+- 自定义轮询消费者
diff --git a/zh/docs/desing-document/05-metrics-export.md b/zh/docs/desing-document/05-metrics-export.md
new file mode 100644
index 00000000..38be6e07
--- /dev/null
+++ b/zh/docs/desing-document/05-metrics-export.md
@@ -0,0 +1,47 @@
+# EventMesh 指标（OpenTelemetry 和 Prometheus
+
+## 介绍
+
+[EventMesh(incubating)](https://github.com/apache/incubator-eventmesh) 是一个动态的云原生事件基础设施.
+
+## OpenTelemetry 概述
+
+OpenTelemetry 是工具、API 和 SDK 的集合。您可以使用它来检测、生成、收集和导出遥测数据（指标、日志和跟踪）以进行分析，以便了解您的软件的性能和行为。
+
+## 概述 Prometheus
+
+使用领先的开源监控解决方案为您的指标和警报提供支持。
+
+- 尺寸数据
+- 强大的查询
+- 伟大的可视化
+- 高效存储
+- 操作简单
+- 精准预警
+- 许多客户端库
+- 许多集成
+
+## 要求
+
+### 功能要求
+
+| 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 |
+
+## 设计 细节
+
+使用由提供的儀表儀器 OpenTelemetry 觀察指標存在於 EventMesh 然後導出到 Prometheus.
+
+1、初始化儀表儀器
+
+2、設置 Prometheus 服務器
+
+3、创建了不同的指标观察者
+
+## 附录
+
+### 参考资料
+
+<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/zh/docs/desing-document/06-cloudevents.md b/zh/docs/desing-document/06-cloudevents.md
new file mode 100644
index 00000000..2d53e607
--- /dev/null
+++ b/zh/docs/desing-document/06-cloudevents.md
@@ -0,0 +1,102 @@
+# CloudEvents 集成
+
+## 介绍
+
+[CloudEvents](https://github.com/cloudevents/spec) 是一种描述事件数据的格式规范，它提供了跨服务、平台与系统的互操作性。
+
+截止至 2021 年 5 月，EventMesh 包含了以下主要组件：`eventmesh-runtime`, `eventmesh-sdk-java` 和 `eventmesh-connector-rocketmq`。
+
+对于使用 EventMesh 的用户，`eventmesh-runtime` 可以被部署为微服务来在生产者和消费者间传输用户的事件。
+用户的应用程序可以通过 `eventmesh-sdk-java` 来与 `eventmesh-runtime` 进行交互，即发布或订阅指定主题的事件。
+
+EventMesh 的用户非常渴望能得到对 CloudEvents 的支持。有许多理由使得用户倾向于使用集成了 CloudEvents 支持的 SDK：
+
+- CloudEvents 是一种更为广泛接受和支持的描述事件的方式。目前，`eventmesh-sdk-java` 使用的是 `LiteMessage` 结构
+ 来描述事件，其标准化程度较低。
+- CloudEvents 的 Java SDK 有更广泛的分发方式。比如，目前 EventMesh 的用户需要使用 SDK 的 tar 包，或对每个 EventMesh 的
+ 发布版本从源码编译。有了 CloudEvents 的支持，用户可以更方便地通过 CloudEvents 的公开分发（比如，配置 Maven）来添加
+ EventMesh SDK 依赖项。
+- CloudEvents 的 SDK 支持多种语言。尽管目前 EventMesh 只提供了 Java SDK，但在未来，如果要为更多语言提供支持，将 Java SDK
+ 与 CloudEvents 绑定的经验将使工作变得容易。
+
+## 需求
+
+### 功能需求
+
+| 需求 ID | 需求描述 | 备注 |
+| ------ | ------- | --- |
+| F-1 | EventMesh 用户应能使用公共 SDK 依赖项来发布或订阅 CloudEvents 格式的事件 | 功能性 |
+| F-2 | EventMesh 用户应能在提供了 CloudEvents 支持的 SDK 中继续使用现有的 EventMesh 客户端功能（如负载均衡） | 功能等价 |
+| F-3 | EventMesh 的开发者应不需要付出特别多努力/痛苦来在 `eventmesh-sdk-java` 和提供了 CloudEvents 支持的 SDK 之间同步 | 可维护性 |
+| F-4 | EventMesh 支持可插拔的协议，以便开发者整合其他协议（例如：CloudEvents / EventMesh MessageOpenMessage / MQTT...） | 功能性 |
+| F-5 | EventMesh 支持统一的 API 以供从/向事件库发布或订阅事件 | 功能性 |
+
+### 性能需求
+
+| 需求 ID | 需求描述 | 备注 |
+| ------ | ------- | --- |
+| P-1 | 提供了 CloudEvents 支持的 SDK 应具有与目前的 SDK 相近的客户端延迟 | |
+
+## 设计细节
+
+与 CloudEvents 的 Java SDK 绑定（这与 Kafka 已经完成的工作类似，请在附录中的参考资料了解更多细节）是达成上述需求的一种简单方法。
+
+### 可插拔协议
+
+
+
+### EventMesh 集成 CloudEvents 进度表
+
+#### TCP
+
+##### SDK 端发布
+
+- 在 `package` 首部中添加 CloudEvents 标识符
+- 使用 `CloudEventBuilder` 构造 CloudEvent，并将其放入 `package` 体中
+
+##### SDK 端订阅
+
+- 在 `ReceiveMsgHook` 接口下添加 `convert` 函数，其用于将 `package` 体转换为具有 `package` 首部标识符的特定协议
+- 不同协议应实现 `ReceiveMsgHook` 接口
+
+##### 服务端发布
+
+- 设计包含 `decodeMessage` 接口的协议转换 API，其可以把包体转换为 CloudEvent
+- 更新 `MessageTransferTask` 下的 `Session.upstreamMsg()`，将入参 `Message` 改为 `CloudEvent`，这使用了
+ 上一步的 `decodeMessage` API 来进行对 CloudEvent 的转换
+- 更新 `SessionSender.send()`，将入参 `Message` 改为 `CloudEvent`
+- 更新 `MeshMQProducer` API，支持在运行时发送 `CloudEvents`
+- 在 `connector-plugin` 中实现支持向 EventStore 中发送 `CloudEvents`
+
+##### 服务端订阅
+
+- 支持将连接器插件中的 `RocketMessage` 改为 `CloudEvent
+- 重写 `AsyncMessageListener.consume()` 函数，将入参 `Message` 改为 `CloudEvent`
+- 更新 `MeshMQPushConsumer.updateOffset()`，将入参 `Message` 改为 `CloudEvent`
+- 更新 `DownStreamMsgContext`，将入参 `Message` 改为 `CloudEvent`，更新 `DownStreamMsgContext.ackMsg`
+
+#### HTTP
+
+##### SDK 端发布
+
+- 支持 `LiteProducer.publish(cloudEvent)`
+- 在 http 请求头中添加 CloudEvents 标识符
+
+##### SDK 端订阅
+
+##### 服务端发布
+
+- 支持根据 `HttpCommand` 首部中的协议类型，通过可插拔的协议插件构造 `HttpCommand.body`
+- 支持在消息处理器中发布 CloudEvent
+
+##### 服务端订阅
+
+- 更新 `EventMeshConsumer.subscribe()`
+- 更新 `HandleMsgContext`， 将入参 `Message` 改为 `CloudEvent`
+- 更新 `AsyncHttpPushRequest.tryHTTPRequest()`
+
+## 附录
+
+### 参考资料
+
+- <https://cloudevents.github.io/sdk-java/kafka>
diff --git a/zh/docs/desing-document/08-spi.md b/zh/docs/desing-document/08-spi.md
new file mode 100644
index 00000000..5fb301f4
--- /dev/null
+++ b/zh/docs/desing-document/08-spi.md
@@ -0,0 +1,111 @@
+# EventMesh SPI
+
+## 介绍
+
+为了提高扩展性，EventMesh通过引入SPI（Service Provider Interface）机制，能够在运行时自动寻找扩展接口的具体实现类，动态加载。
+在EventMesh中，一切扩展点都利用SPI采用插件的实现方式，用户可以通过实现扩展接口，开发自定义的插件，在运行时通过简单的配置，声明式的选择所需要运行的插件。
+
+## eventmesh-spi模块
+
+SPI相关的代码位于eventmesh-spi模块下，其中主要包括EventMeshExtensionFactory, EventMeshSPI, ExtensionClassLoader这三个类。
+
+### EventMeshSPI
+
+EventMeshSPI是SPI注解，所有需要采用SPI实现扩展的接口都需要使用@EventMeshSPI注解标记。
+
+```java
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface EventMeshSPI {
+
+ /**
+ * If true, the spi instance is singleton
+ */
+ boolean isSingleton() default false;
+
+}
+```
+
+这么做的原因是可以通过注解的方式声明接口为SPI扩展接口，提高代码的可读性。同时，@EventMeshSPI注解中包含一个isSingleton属性，
+用来声明该扩展接口是否采用单例的实现方式，如果为true，那么该接口的实现类将会使用单例的实现方式，在一个JVM进程中全局唯一。
+
+### EventMeshExtensionFactory
+
+EventMeshExtensionFactory是SPI实现类的获取工厂，包含一个静态方法`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) {
+ }
+}
+```
+
+所有需要获取扩展实现的地方都应该通过EventMeshExtensionFactory获取。
+
+### ExtensionClassLoader
+
+ExtensionClassLoader是扩展接口实现类的加载接口，包含两个实现子类MetaInfExtensionClassLoader和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用于从classPath直接加载实现类，JarExtensionClassLoader用于从配置目录下通过加载Jar包的方式加载实现类，未来可能还会提供通过从Maven仓库下加载实现类。
+
+## SPI使用示例
+
+下面以eventmesh-connector-plugin为例，介绍SPI具体的使用过程。
+
+首先定义一个eventmesh-connector-api模块，并且定义扩展接口MeshMQProducer。在MeshMQProducer接口上使用@EventMeshSPI注解进行声明，表明该接口是一个SPI扩展接口
+
+```java
+@EventMeshSPI(isSingleton = false)
+public interface MeshMQProducer extends Producer {
+...
+}
+```
+
+eventmesh-connector-rocketmq模块中包含采用rocketmq的具体实现方式RocketMQProducerImpl。
+
+```java
+public class RocketMQProducerImpl implements MeshMQProducer {
+...
+}
+```
+
+同时，还需要在eventmesh-connector-rocketmq模块中resource/META-INF/eventmesh目录下创建文件名为SPI接口全限定名的文件
+org.apache.eventmesh.api.producer.Producer
+
+文件内容为扩展实例名和对应的实例全类名
+
+```properties
+rocketmq=org.apache.eventmesh.connector.rocketmq.producer.RocketMQProducerImpl
+```
+
+至此，一个SPI扩展模块就完成了。在使用的时候只需要通过EventMeshExtensionFactory.getExtension(MeshMQProducer.class, “rocketmq”)就可以获取RocketMQProducerImpl实现类。
diff --git a/zh/docs/desing-document/09-event-bridge.md b/zh/docs/desing-document/09-event-bridge.md
new file mode 100644
index 00000000..b74b78e0
--- /dev/null
+++ b/zh/docs/desing-document/09-event-bridge.md
@@ -0,0 +1,156 @@
+# Event Bridge
+
+
+
+Event Bridge 可以支持跨mesh集群的消息投递，下面展示这一功能的详细设计与体验步骤
+
+
+
+> 注：在本地体验这一功能时需要启动两台eventmesh实例，同时要修改`eventmesh-runtime`目录下的`eventmesh.properties`文件中的端口配置，避免端口冲突。便于下文描述，event-bridge特性按照上图信息进行表述。
+
+## 01 远程订阅
+
+**描述**：向cluster2 eventmesh发起远程订阅指令，cluster2 eventmesh收到指令后会携带订阅信息调用cluster1 eventmesh的本地订阅接口
+
+**URL**: http://{cluster2 address}/eventmesh/subscribe/remote
+
+**请求方式**：POST
+
+**请求参数：**application/json 格式
+
+| 参数名 | 类型 | 是否必填 | 说明 |
+| ------------- | ------ | -------- | ------------------------------------------------------------ |
+| url | String | 是 | 标识订阅url信息，暂时无用，后续可移除，目前仅为强校验，实际会被（/eventmesh/bridge/publish）替换 |
+| consumerGroup | String | 是 | 标识消费组信息，实际会被cluster2的eventmesh配置信息替换 |
+| topic | List | 是 | 标识订阅信息列表 |
+| mode | String | 是 | 标识消费模式，分为集群模式和广播模式 |
+| topic | String | 是 | 标识订阅的topic |
+| type | String | 是 | 标识消费类型，分为同步和异步 |
+| remoteMesh | String | 否 | 标识远程mesh地址，优先根据topic从注册中心获取，获取不到使用该字段替换 |
+
+**请求样例：**
+
+```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 本地订阅
+
+**描述**：向cluster2的EventMesh实例发起本地订阅指令，cluster2的EventMesh收到订阅指令后会启动本地监听从event store收下来的消息，并推送给订阅信息中的url。
+
+**URL**: http://{cluster2 address}/eventmesh/subscribe/local
+
+**请求方式**：POST
+
+**请求参数：**application/json 格式
+
+| 参数名 | 类型 | 是否必填 | 说明 |
+| ------------- | ------ | -------- | ------------------------------------ |
+| url | String | 是 | 标识订阅url信息 |
+| consumerGroup | String | 是 | 标识消费组信息 |
+| topic | List | 是 | 标识订阅信息列表 |
+| mode | String | 是 | 标识消费模式，分为集群模式和广播模式 |
+| topic | String | 是 | 标识订阅的topic |
+| type | String | 是 | 标识消费类型，分为同步和异步 |
+
+**请求样例：**
+
+```JSON
+{
+ "url": "http://127.0.0.1:8088/sub/test",
+ "consumerGroup": "TEST-GROUP",
+ "topic": [
+ {
+ "mode": "CLUSTERING",
+ "topic": "TEST-TOPIC-HTTP-ASYNC",
+ "type": "ASYNC"
+ }
+ ]
+}
+```
+
+## 03 发送消息
+
+**描述**：向cluster1的EventMesh实例发送消息，cluster1的EventMesh收到消息后会发送到event store，再从event store收下来消息推送给cluster2的EventMesh url `/eventmesh/bridge/publish`。
+
+**URL**: http://{cluster1 address}/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC
+
+**请求方式**：POST
+
+**请求参数：**application/json 格式
+
+**请求样例：**
+
+```json
+{
+ "name":"test",
+ "age":"19"
+}
+```
+
+## 04远程去订阅
+
+**描述**：向cluster2的EventMesh实例发送去除订阅指令，cluster2的EventMesh收到指令后会发送cluster1的EventMesh，cluster1的EventMesh会本地执行去除订阅
+
+**URL**: http://{cluster2 address}/eventmesh/unsubscribe/remote
+
+**请求方式**：POST
+
+**请求参数：**application/json 格式
+
+| 参数名 | 类型 | 是否必填 | 说明 |
+| ------------- | ------ | -------- | ------------------------------------------------------------ |
+| url | String | 是 | 标识要去除订阅url信息，暂时无用，后续可移除，目前仅为强校验，实际会被（/eventmesh/bridge/publish）替换 |
+| consumerGroup | String | 是 | 标识要去除的消费组信息，实际会使用EventMesh cluster2的group信息替换 |
+| topic | List | 是 | 标识订阅topic信息列表 |
+
+**请求样例：**
+
+```json
+{
+ "consumerGroup": "EventMeshTest-consumerGroup",
+ "url": "http://127.0.0.1:8088/sub/test",
+ "topic": [
+ "TEST-TOPIC-HTTP-ASYNC"
+ ]
+}
+```
+
+## 05本地去订阅
+
+**描述**：向cluster2的EventMesh实例发送去除订阅指令，cluster2的EventMesh收到指令后会本地执行去除订阅
+
+**URL**: http://{cluster2 address}/eventmesh/unsubscribe/local
+
+**请求方式**：POST
+
+**请求参数：**application/json 格式
+
+| 参数名 | 类型 | 是否必填 | 说明 |
+| ------------- | ------ | -------- | ---------------------- |
+| url | String | 是 | 标识要去除订阅url信息 |
+| consumerGroup | String | 是 | 标识要去除的消费组信息 |
+| topic | List | 是 | 标识订阅topic信息列表 |
+
+**请求样例：**
+
+```json
+{
+ "consumerGroup": "EventMeshTest-consumerGroup",
+ "url": "http://127.0.0.1:8088/sub/test",
+ "topic": [
+ "TEST-TOPIC-HTTP-ASYNC"
+ ]
+}
+```
\ No newline at end of file
diff --git a/zh/docs/desing-document/10-knative-connector.md b/zh/docs/desing-document/10-knative-connector.md
new file mode 100644
index 00000000..ce7d4c52
--- /dev/null
+++ b/zh/docs/desing-document/10-knative-connector.md
@@ -0,0 +1,91 @@
+# Knative Connector插件
+
+## 准备
+### 创建Knative Source和Sink
+我们使用 *cloudevents-player* [Knative服务](https://knative.dev/docs/serving/)作为例子。如果您不知道如何创建 *cloudevents-player* Knative服务作为source和sink，请按照这个[链接](https://knative.dev/docs/getting-started/first-source/#creating-your-first-source)的步骤进行创建。
+
+### EventMesh配置文件
+- 将以下配置加入 [eventmesh-starter/build.gradle](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-starter/build.gradle) 文件
+```bash
+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")
+}
+```
+- 将以下配置加入 [eventmesh-examples/build.gradle](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/build.gradle)文件
+```bash
+plugins {
+ id 'application'
+}
+
+application {
+ mainClass = project.hasProperty("mainClass") ? project.getProperty("mainClass") : 'NULL'
+}
+```
+- 在 [eventmesh-runtime/conf/eventmesh.properties](https://github.com/pchengma/incubator-eventmesh/blob/master/eventmesh-runtime/conf/eventmesh.properties) 文件中设置```eventMesh.connector.plugin.type=knative```变量
+
+## 演示
+### Knative发布事件消息/EventMesh订阅
+#### 步骤1：启动一台EventMesh服务器
+```bash
+$ cd eventmesh-starter
+$ ../gradlew -PmainClass=org.apache.eventmesh.starter.StartUp run
+```
+
+#### 步骤2：从Knative Source发布一条消息
+```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!"}'
+```
+
+#### 步骤3：从EventMesh订阅
+- 在 [ExampleConstants.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/common/ExampleConstants.java) 文件中设置 ```public static final String EVENTMESH_HTTP_ASYNC_TEST_TOPIC = "messages";```变量
+```bash
+$ cd eventmesh-examples
+$ ../gradlew -PmainClass=org.apache.eventmesh.http.demo.sub.SpringBootDemoApplication run
+```
+#### 预期结果
+以下```data```为```Hello CloudEvents!```的消息将会打印在EventMesh服务器的控制台上。
+```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"}]
+```
+
+### EventMessh发布事件消息/Knative订阅
+#### 步骤1：启动一台EventMesh服务器
+```bash
+$ cd eventmesh-starter
+$ ../gradlew -PmainClass=org.apache.eventmesh.starter.StartUp run
+```
+
+#### 步骤2：从EventMesh发布一条消息
+我们用Knative Connector的测试程序来演示这个功能。
+```bash
+$ cd eventmesh-connector-plugin/eventmesh-connector-knative
+$ ../../gradlew clean test --tests KnativeProducerImplTest.testPublish
+```
+
+#### 步骤3：从Knative订阅
+```bash
+$ curl http://cloudevents-player.default.127.0.0.1.sslip.io/messages
+```
+
+#### 预期结果
+以下```data```为```Hello Knative from EventMesh!```的消息将会打印在EventMesh服务器的控制台上。
+```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/zh/docs/desing-document/11-prometheus.md b/zh/docs/desing-document/11-prometheus.md
new file mode 100644
index 00000000..067cd00a
--- /dev/null
+++ b/zh/docs/desing-document/11-prometheus.md
@@ -0,0 +1,46 @@
+# 通过 Prometheus 观察 Metrics
+
+## 下载 Prometheus
+
+官网：https://prometheus.io/
+
+本地下载Prometheus：https://prometheus.io/download/
+
+选择自己电脑对应的版本下载并解压缩
+
+
+
+### 2、在prometheus.yml中添加配置
+
+如果你是Prometheus的新手，可以直接复制eventmesh-runtime/conf/prometheus.yml替换
+
+例如：这是win-64的下载后的样子：
+
+
+
+替换红框中的文件
+
+如果你十分了解Prometheus，可以自行配置，eventmesh默认的导出的端口为19090。
+
+ps：如果需要更换端口的话，请修改eventmesh-runtime/conf/eventmesh.properties中的
+
+```properties
+#prometheusPort
+eventMesh.metrics.prometheus.port=19090
+```
+
+## 运行 Prometheus 和 EventMesh
+
+双击Prometheus.exe运行
+
+运行eventmesh-starter(参考[eventmesh-runtime-quickstart](eventmesh-runtime-quickstart.md))
+
+运行eventmesh-example(参考[eventmesh-sdk-java-quickstart](eventmesh-sdk-java-quickstart.md))
+
+打开浏览器访问：http://localhost:9090/
+
+### 输入想观察的 Metrics
+
+输入’**eventmesh_**‘ 就会出现相关的指标的提示
+
+
diff --git a/zh/docs/desing-document/12-zipkin.md b/zh/docs/desing-document/12-zipkin.md
new file mode 100644
index 00000000..913ee056
--- /dev/null
+++ b/zh/docs/desing-document/12-zipkin.md
@@ -0,0 +1,49 @@
+# 通过 Zipkin 观察 Trace
+
+### 1、下载和运行Zipkin
+
+请参考https://zipkin.io/pages/quickstart.html
+
+
+
+### 2、运行eventmesh
+
+运行eventmesh-starter(参考[eventmesh-runtime-quickstart](eventmesh-runtime-quickstart.md))
+
+运行eventmesh-example(参考[eventmesh-sdk-java-quickstart](eventmesh-sdk-java-quickstart.md))
+
+
+
+### 3、相关的设置
+
+eventmesh-runtime/conf/eventmesh.properties中：
+
+默认的exporter是log，需要手动改成Zipkin
+
+```properties
+#trace exporter
+eventmesh.trace.exporter.type=Zipkin
+```
+下面是关于Zipkin的各种配置
+```properties
+#set the maximum batch size to use
+eventmesh.trace.exporter.max.export.size=512
+#set the queue size. This must be >= the export batch size
+eventmesh.trace.exporter.max.queue.size=2048
+#set the max amount of time an export can run before getting(TimeUnit=SECONDS)
+eventmesh.trace.exporter.export.timeout=30
+#set time between two different exports(TimeUnit=SECONDS)
+eventmesh.trace.exporter.export.interval=5
+
+#zipkin
+eventmesh.trace.export.zipkin.ip=localhost
+eventmesh.trace.export.zipkin.port=9411
+```
+
+以上都是相关的配置，如果你十分熟悉Zipkin的话可以自行修改。
+
+
+
+### 4、观察
+
+浏览器打开： **localhost:9411**
diff --git a/zh/docs/desing-document/13-jaeger.md b/zh/docs/desing-document/13-jaeger.md
new file mode 100644
index 00000000..9ac02693
--- /dev/null
+++ b/zh/docs/desing-document/13-jaeger.md
@@ -0,0 +1,44 @@
+# 通过 Jaeger 观察 Trace
+
+## Jaeger
+
+[Jaeger](https://www.jaegertracing.io/) 是 [Uber](https://uber.github.io/) 开发的分布式跟踪系统，现已成为 [CNCF](https://cncf.io/) 开源项目，其灵感来源于 Google 的 [Dapper](https://research.google.com/pubs/pub36356.html) 和 Twitter 的 [Zipkin](https://zipkin.io/)，用于监控基于微服务的分布式系统。
+
+Jaeger 的安装可以参考[官方文档](https://www.jaegertracing.io/docs/latest/getting-started/)，推荐使用官方的 Docker 镜像 `jaegertracing/all-in-one` 来快速搭建环境进行测试。
+
+## 配置
+
+为了启用 EventMesh Runtime 的 trace exporter，请将 `conf/eventmesh.properties` 文件中的 `eventMesh.server.trace.enabled` 字段设置为 true。
+
+```conf
+# Trace plugin
+eventMesh.server.trace.enabled=true
+eventMesh.trace.plugin=jaeger
+```
+
+为了定义 trace exporter 的行为，如超时时间或导出间隔，请编辑 `exporter.properties` 文件。
+
+```conf
+# 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
+```
+
+为了将导出的 trace 数据发送到 Jaeger，请编辑 `conf/jaeger.properties` 文件中的 `eventmesh.trace.jaeger.ip` 和 `eventmesh.trace.jaeger.port` 字段，来匹配 Jaeger 服务器的配置。
+
+```conf
+# Jaeger's IP and Port
+eventmesh.trace.jaeger.ip=localhost
+eventmesh.trace.jaeger.port=14250
+```
+
+## 从 Zipkin 迁移
+
+Jaeger 采集器服务暴露了与 Zipkin 兼容的 REST API，`/api/v1/spans` 可以接收 Thrift 和 JSON，`/api/v2/spans` 可以接收 JSON 和 Proto。
+
+因此你也可以使用 `eventmesh-trace-zipkin` 插件来通过 Jaeger 观察 trace，具体配置细节请参考 `eventmesh-trace-zipkin` 的文档。默认情况下这个特性在 Jaeger 中是关闭的，可以通过 `--collector.zipkin.host-port=:9411` 启用。
\ No newline at end of file
diff --git a/zh/docs/desing-document/_category_.json b/zh/docs/desing-document/_category_.json
new file mode 100644
index 00000000..95b7eed0
--- /dev/null
+++ b/zh/docs/desing-document/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Documentation",
+ "collapsed": false
+}
diff --git a/zh/docs/desing-document/https.md b/zh/docs/desing-document/https.md
new file mode 100644
index 00000000..a100ba39
--- /dev/null
+++ b/zh/docs/desing-document/https.md
@@ -0,0 +1,32 @@
+# HTTPS
+
+1.在eventmesh-runtime 中配置
+
+```
+eventMesh.properties(添加如下配置)
+eventMesh.server.useTls.enabled=true //默认值 false
+
+
+config env varible
+-Dssl.server.protocol=TLSv1.1 //默认值 TLSv1.1
+-Dssl.server.cer=sChat2.jks //把文件放到启动脚本start.sh 指定的conPath目录下
+-Dssl.server.pass=sNetty
+```
+
+2.在eventmesh-sdk-java 中配置
+
+```
+//创建producer
+LiteClientConfig eventMeshHttpClientConfig = new eventMeshHttpClientConfig();
+...
+
+//设置开启TLS
+eventMeshHttpClientConfig.setUseTls(true);
+LiteProducer producer = new LiteProducer(eventMeshHttpClientConfig);
+
+
+//配置环境变量
+-Dssl.client.protocol=TLSv1.1 //默认值 TLSv1.1
+-Dssl.client.cer=sChat2.jks //把文件放到应用指定的conPath目录下
+-Dssl.client.pass=sNetty
+```
diff --git a/zh/docs/desing-document/webhook.md b/zh/docs/desing-document/webhook.md
new file mode 100644
index 00000000..aa4d497f
--- /dev/null
+++ b/zh/docs/desing-document/webhook.md
@@ -0,0 +1,268 @@
+
+
+## webhook使用流程
+#### 第一步：在eventmesh配置webhook相关信息并且启动
+
+##### 配置说明
+```
+# 是否启动webhook admin服务
+eventMesh.webHook.admin.start=true
+
+# webhook事件配置存储模式。目前只支持file与nacos
+eventMesh.webHook.operationMode=file
+# 文件存储模式的文件存放路径，如果写上#{eventMeshHome}，在eventMesh根目录
+eventMesh.webHook.fileMode.filePath= #{eventMeshHome}/webhook
+
+# nacos存储模式，配置命名规则是eventMesh.webHook.nacosMode.{nacos 原生配置key} 具体的配置请看 [nacos github api](https://github.com/alibaba/nacos/blob/develop/api/src/main/java/com/alibaba/nacos/api/SystemPropertyKeyConst.java)
+## nacos的地址
+eventMesh.webHook.nacosMode.serverAddr=127.0.0.1:8848
+
+# webhook eventcloud 发送模式。与eventMesh.connector.plugin.type 配置一样
+eventMesh.webHook.producer.connector=standalone
+```
+
+#### 第二步：添加webhook配置信息
+配置信息说明
+```java
+ /**
+ * 厂商调用的path。厂商事件调用地址、 [http or https ]://[域名 or IP 【厂商可以被调用】]:[端口]/webhook/[callbackPath]
+ * 比如：http://127.0.0.1:10504/webhook/test/event 需要把全完url填入厂商调用输入中
+ * callbackPath 是唯一
+ * manufacturer callback path
+ */
+ private String callbackPath;
+
+ /**
+ * 厂商的名字
+ * manufacturer name ,like github
+ */
+ private String manufacturerName;
+
+ /**
+ * 厂商的事件名
+ * 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;
+
+
+
+ /**
+ * 事件发送到那个topic
+ * 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";;
+
+ /**
+ * source of event
+ */
+ private String cloudEventSource;
+
+ /**
+ * cloudEvent事件对象唯一标识符识别方式，uuid或者manufacturerEventId(厂商id)
+ * id of cloudEvent ,like uuid/manufacturerEventId
+ */
+ private String cloudEventIdGenerateMode;
+
+```
+
+##### 添加接口
+路径： /webhook/insertWebHookConfig
+方法： POST
+contentType： application/json
+
+输入参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| callbackPath | 调用地址，唯一地址 | string | 是 | null |
+| manufacturerName | 厂商名 | string | 是 | null |
+| manufacturerEventName | 厂商事件名 | string | 是 | null |
+| contentType | http connettype | string | 否 | application/json |
+| description | 配置说明 | string | 否 | null |
+| secret | 验签密钥 | string | 否 | null |
+| userName | 用户名 | string | 否 | null |
+| password | 用户密码 | string | 否 | null |
+| cloudEventName | 事件名（） | string | 是 | null |
+| cloudEventSource | 事件来源可以填写 | string | 是 | null |
+| cloudEventIdGenerateMode | cloudEvent事件对象唯一标识符识别方式，uuid或者manufacturerEventId(厂商id) | string | 否 | manufacturerEventId |
+
+列子：
+```json
+
+{
+ "callbackPath":"/webhook/github/eventmesh/all",
+ "manufacturerName":"github",
+ "manufacturerEventName":"all",
+ "secret":"eventmesh",
+ "cloudEventName":"github-eventmesh",
+ "cloudEventSource":"github"
+}
+
+```
+输出参数：１ 成功，０失败
+
+##### 删除接口
+路径： /webhook/deleteWebHookConfig
+方法： POST
+contentType： application/json
+
+输入参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| callbackPath | 调用地址，唯一地址 | string | 是 | null |
+
+
+列子：
+
+```json
+
+{
+ "callbackPath":"/webhook/github/eventmesh/all"
+}
+
+```
+
+
+输出参数：１ 成功，０失败
+
+##### 通过callbackPath查询WebHookConfig
+路径： /webhook/queryWebHookConfigById
+方法： POST
+contentType： application/json
+
+输入参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| callbackPath | 调用地址，唯一地址 | string | 是 | null |
+
+
+列子：
+
+```json
+
+{
+ "callbackPath":"/webhook/github/eventmesh/all"
+}
+
+```
+
+
+输出参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| callbackPath | 调用地址，唯一地址 | string | 是 | null |
+| manufacturerName | 厂商名 | string | 是 | null |
+| manufacturerEventName | 厂商事件名 | string | 是 | null |
+| contentType | http connettype | string | 否 | application/json |
+| description | 配置说明 | string | 否 | null |
+| secret | 验签密钥 | string | 否 | null |
+| userName | 用户名 | string | 否 | null |
+| password | 用户密码 | string | 否 | null |
+| cloudEventName | 事件名（） | string | 是 | null |
+| cloudEventSource | 事件来源可以填写 | string | 是 | null |
+| cloudEventIdGenerateMode | cloudEvent事件对象唯一标识符识别方式，uuid或者manufacturerEventId(厂商id) | string | 否 | manufacturerEventId |
+
+
+##### 通过manufacturer查询WebHookConfig列表
+路径： /webhook/queryWebHookConfigByManufacturer
+方法： POST
+contentType： application/json
+
+输入参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| manufacturerName | 厂商名 | string | 是 | null |
+
+
+列子：
+
+```json
+
+{
+ "manufacturerName":"github"
+}
+
+```
+
+
+输出参数：
+| 字段 | 说明 | 类型 | 必须 | 默认值 |
+| -- | -- | -- | -- | -- |
+| callbackPath | 调用地址，唯一地址 | string | 是 | null |
+| manufacturerName | 厂商名 | string | 是 | null |
+| manufacturerEventName | 厂商事件名 | string | 是 | null |
+| contentType | http connettype | string | 否 | application/json |
+| description | 配置说明 | string | 否 | null |
+| secret | 验签密钥 | string | 否 | null |
+| userName | 用户名 | string | 否 | null |
+| password | 用户密码 | string | 否 | null |
+| cloudEventName | 事件名（） | string | 是 | null |
+| cloudEventSource | 事件来源可以填写 | string | 是 | null |
+| cloudEventIdGenerateMode | cloudEvent事件对象唯一标识符识别方式，uuid或者manufacturerEventId(厂商id) | string | 否 | manufacturerEventId |
+
+
+#### 第三步：查看配置是否成功
+1. file存储模式。请到eventMesh.webHook.fileMode.filePath 目录下查看。文件名为callbackPath转移后的
+2. nacos存储模式。请到eventMesh.webHook.nacosMode.serverAddr 配置的nacos服务去看
+
+#### 第四步：配置cloudevent的消费者
+
+
+#### 第五步：在厂商配置webhook相关信息
+> 厂商操作请看【厂商webhook操作说明】
+
+
+## 厂商webhook操作说明
+### github 注册
+#### 第一步：进入对应的项目
+#### 第二步：点击setting
+
+#### 第三步：点击Webhooks
+
+#### 第四步：点击 Add webhook
+
+#### 第五步: 填写webhook信息
+
+
+Payload URL: 服务地址以及pahts。[http or https ]://[域名 or IP 【厂商可以被调用】]:[端口]/webhook/[callbackPath]
+Content type：http header content type
+secret: 验签字符串
+
+
+
+
diff --git a/zh/docs/instruction/00-eclipse.md b/zh/docs/instruction/00-eclipse.md
new file mode 100644
index 00000000..27ded495
--- /dev/null
+++ b/zh/docs/instruction/00-eclipse.md
@@ -0,0 +1,33 @@
+# eventMesh 导入Eclipse 快速入门说明
+
+### 依赖
+
+```
+64位JDK 1.8+;
+Gradle至少为7.0, 推荐 7.0.*
+eclipse 已安装gradle插件或者eclipse自带gradle插件
+```
+
+### 下载源码
+git init
+
+git clone https://github.com/apache/incubator-eventmesh.git
+
+### 项目编译eclipse环境
+
+打开命令行终端，运行gradlew cleanEclipse eclipse
+
+### 配置修改
+修改工程名称和settings.gradle 配置文件参数rootProject.name 参数一致
+
+### 修改eclipse.init配置文件,配置lombok以1.18.8版本为例
+-javaagent:lombok-1.18.8.jar
+-XBootclasspath/a:lombok-1.18.8.jar
+
+### 202106版本eclipse,eclipse.init增加配置参数
+--illegal-access=permit
+
+
+### 导入gradle
+打开eclipse,导入gradle项目到IDE里
+
diff --git a/zh/docs/instruction/01-store-with-docker.md b/zh/docs/instruction/01-store-with-docker.md
new file mode 100644
index 00000000..539c81cd
--- /dev/null
+++ b/zh/docs/instruction/01-store-with-docker.md
@@ -0,0 +1,40 @@
+# eventmesh-store 快速入门说明
+
+## 依赖
+
+```
+建议使用64位操作系统，建议使用Linux/Unix；
+64位JDK 1.8+;
+Gradle至少为7.0, 推荐7.0.*
+4g+可用磁盘用于eventmesh-store服务器
+eventmesh在非standalone模式下，依赖RocketMQ作为存储层；若采用standalone模式，则可跳过该步，直接进行runtime的部署
+```
+
+## 部署
+在命令行输入如下命令直接从 docker hub 上获取 RocketMQ 镜像：
+
+```shell
+#获取 namesrv 镜像
+sudo docker pull rocketmqinc/rocketmq-namesrv:4.5.0-alpine
+#获取 broker 镜像
+sudo docker pull rocketmqinc/rocketmq-broker:4.5.0-alpine
+```
+
+在命令行输入以下命令运行namerv容器和broker容器
+
+```shell
+#运行 namerv 容器
+sudo docker run -d -p 9876:9876 -v `pwd`/data/namesrv/logs:/root/logs -v `pwd`/data/namesrv/store:/root/store --name rmqnamesrv rocketmqinc/rocketmq-namesrv:4.5.0-alpine sh mqnamesrv
+
+#运行 broker 容器
+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" rocketmqinc/rocketmq-broker:4.5.0-alpine sh mqbroker -c ../conf/broker.conf
+```
+
+请注意 **rocketmq-broker ip** 是 **pod ip**, 如果你想修改这个ip, 可以通过挂载容器中 **broker.conf** 文件的方式并修改文件中的 **brokerIP1** 配置项为自定义值
+
+
+至此eventmesh-store的部署已完成，请转至下一步完成 [eventmesh-runtime](https://github.com/apache/incubator-eventmesh/blob/master/docs/zh/instruction/02-runtime-with-docker.md) 的部署
+
+
+## 参考
+关于RocketMQ的其他更多资料，请参考 <https://rocketmq.apache.org/docs/quick-start/>
diff --git a/zh/docs/instruction/01-store.md b/zh/docs/instruction/01-store.md
new file mode 100644
index 00000000..7317e3ad
--- /dev/null
+++ b/zh/docs/instruction/01-store.md
@@ -0,0 +1,51 @@
+# eventmesh-store 快速入门说明
+
+## 依赖
+
+```
+建议使用64位操作系统，建议使用Linux/Unix；
+64位JDK 1.8+;
+Gradle至少为7.0, 推荐7.0.*
+4g+可用磁盘用于eventmesh-store服务器
+eventmesh在非standalone模式下，依赖RocketMQ作为存储层；若采用standalone模式，则可跳过该步，直接进行runtime的部署
+```
+
+
+## 下载
+
+从[RocketMQ官方网站](https://rocketmq.apache.org/dowloading/releases/) 下载Binary代码（推荐使用4.9.*版本），这里以4.9.2为例
+
+```
+unzip rocketmq-all-4.9.2-bin-release.zip
+cd rocketmq-4.9.2/
+```
+
+
+## 部署
+
+- #### 启动Name Server
+
+```
+nohup sh bin/mqnamesrv &
+tail -f ~/logs/rocketmqlogs/namesrv.log
+```
+
+如果在看到The Name Server boot success...，则说明Name Server启动成功
+
+- #### 启动Broker
+
+```
+nohup sh bin/mqbroker -n localhost:9876 &
+tail -f ~/logs/rocketmqlogs/broker.log
+```
+
+如果在看到The broker boot success...，则说明Broker启动成功
+
+至此eventmesh-store的部署已完成，请转至下一步完成 [eventmesh-runtime](https://github.com/apache/incubator-eventmesh/blob/master/docs/zh/instruction/02-runtime.md) 的部署
+
+
+## 参考
+关于RocketMQ的其他更多资料，请参考 <https://rocketmq.apache.org/docs/quick-start/>
+
+
+
diff --git a/zh/docs/instruction/02-runtime-with-docker.md b/zh/docs/instruction/02-runtime-with-docker.md
new file mode 100644
index 00000000..640bd593
--- /dev/null
+++ b/zh/docs/instruction/02-runtime-with-docker.md
@@ -0,0 +1,149 @@
+# 使用 Docker 快速入门 EventMesh（暂时只支持到1.4.0版本）
+
+本篇快速入门将详细介绍使用 docker 部署 EventMesh，以 RocketMQ 作为对接的中间件。
+
+可选语言: [英文版本](../../en/instructions/eventmesh-runtime-quickstart-with-docker.md)，[中文版本](02-runtime-with-docker.md)。
+
+## 前提
+
+1. 建议使用64位的 linux 系统；
+2. 请预先安装 Docker Engine。 Docker 的安装过程可以参考 [docker 官方文档](https://docs.docker.com/engine/install/)；
+3. 建议掌握基础的 docker 概念和命令行，例如注册中心、挂载等等。不过这不是必须的，因为本次操作所需的命令都已为您列出；
+4. 若您选择非standalone模式，请确保 [RocketMQ 已成功启动](https://rocketmq.apache.org/docs/quick-start/) 并且可以使用 ip 地址访问到；若您选择standalone模式，则无需启动 RocketMQ 。
+
+## 获取 EventMesh 镜像
+
+首先，你可以打开一个命令行，并且使用下面的 ```pull``` 命令从 [Docker Hub](https://registry.hub.docker.com/r/eventmesh/eventmesh/tags) 中下载[最新发布的 EventMesh](https://eventmesh.apache.org/events/release-notes/v1.3.0/) 。
+
+```shell
+sudo docker pull eventmesh/eventmesh:v1.4.0
+```
+
+您可以使用以下命令列出并查看本地已有的镜像。
+
+```shell
+sudo docker images
+```
+
+如果终端显示如下所示的镜像信息，则说明 EventMesh 镜像已经成功下载到本地。
+
+```shell
+REPOSITORY TAG IMAGE ID CREATED SIZE
+eventmesh/eventmesh v1.4.0 6e2964599c78 3 months ago 936.73 MB
+```
+
+## 创建配置文件
+
+在根据 EventMesh 镜像运行对应容器之前，你需要创建两个配置文件，分别是：```eventMesh.properties``` 和 ```rocketmq-client.properties```。
+
+首先，你需要使用下面的命令创建这两个文件。
+
+```shell
+sudo mkdir -p /data/eventmesh/rocketmq/conf
+cd /data/eventmesh/rocketmq/conf
+sudo touch eventmesh.properties
+sudo touch rocketmq-client.properties
+```
+
+### 配置 eventMesh.properties
+
+这个配置文件中包含 EventMesh 运行时环境和集成进来的其他插件所需的参数。
+
+使用下面的 ```vim``` 命令编辑 ```eventmesh.properties```。
+
+```shell
+sudo vim eventmesh.properties
+```
+
+你可以直接将 GitHub 仓库中的对应配置文件中的内容复制过来，链接为：<https://github.com/apache/incubator-eventmesh/blob/1.3.0/eventmesh-runtime/conf/eventmesh.properties> 。
+
+请检查配置文件里的默认端口是否已被占用，如果被占用请修改成未被占用的端口：
+
+| 属性 | 默认值 | 备注 |
+|----------------------------|-------|----------------------------|
+| eventMesh.server.http.port | 10105 | EventMesh http server port |
+| eventMesh.server.tcp.port | 10000 | EventMesh tcp server port |
+| eventMesh.server.grpc.port | 10205 | EventMesh grpc server port |
+
+### 配置 rocketmq-client.properties
+
+这个配置文件中包含 RocketMQ nameserver 的信息。
+
+使用下面的 ```vim``` 命令编辑 ```rocketmq-client.properties```。
+
+```shell
+sudo vim rocketmq-client.properties
+```
+
+你可以直接将 GitHub 仓库中的对应配置文件中的内容复制过来，链接为：<https://github.com/apache/incubator-eventmesh/blob/1.3.0/eventmesh-runtime/conf/rocketmq-client.properties> 。请注意，如果您正在运行的 namesetver 地址不是配置文件中的默认值，请将其修改为实际正在运行的nameserver地址。
+
+请检查配置文件里的默认namesrvAddr是否已被占用，如果被占用请修改成未被占用的地址：
+
+| 属性 | 默认值 | 备注 |
+|---------------------------------------|-------------------------------|----------------------------------|
+| eventMesh.server.rocketmq.namesrvAddr | 127.0.0.1:9876;127.0.0.1:9876 | RocketMQ namesrv default address |
+
+## 运行 EventMesh
+
+现在你就可以开始根据下载好的 EventMesh 镜像运行容器了。
+
+使用到的命令是 ```docker run```，有以下两点内容需要格外注意。
+
+1. 绑定容器端口和宿主机端口：使用 ```docker run``` 的 ```-p``` 选项。
+2. 将宿主机中的两份配置文件挂在到容器中：使用 ```docker run``` 的 ```-v``` 选项。
+
+综合一下，对应的启动命令为：
+
+```shell
+sudo docker run -d \
+ -p 10000:10000 -p 10105:10105 \
+ -v /data/eventmesh/rocketmq/conf/eventMesh.properties:/data/app/eventmesh/conf/eventMesh.properties \
+ -v /data/eventmesh/rocketmq/conf/rocketmq-client.properties:/data/app/eventmesh/conf/rocketmq-client.properties \
+ eventmesh/eventmesh:v1.4.0
+```
+
+如果运行命令之后看到新输出一行字符串，那么运行 EventMesh 镜像的容器就启动成功了。
+
+接下来，你可以使用下面的命令查看容器的状态。
+
+```shell
+sudo docker ps
+```
+
+如果成功的话，你会看到终端打印出了如下所示容器的信息，其中就有运行 EventMesh 镜像的容器。
+
+```shell
+CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
+d1e1a335d4a9 eventmesh/eventmesh:v1.4.0 "/bin/sh -c 'sh star…" About a minute ago Up About a minute 0.0.0.0:10000->10000/tcp, :::10000->10000/tcp, 0.0.0.0:10105->10105/tcp, :::10105->10105/tcp focused_bartik
+```
+
+从这个信息中可以看出，```container id``` 是 ```d1e1a335d4a9```，```name``` 是 ```focused_bartik```，它们都可以用来唯一标识这个容器。**注意**：在你的电脑中，它们的值可能跟这里的不同。
+
+## 管理 EventMesh 容器
+
+在成功的运行了 EventMesh 容器后，你可以通过进入容器、查看日志、删除容器等方式管理容器。
+
+**进入容器** 命令示例：
+
+```shell
+sudo docker exec -it [your container id or name] /bin/bash
+```
+
+在容器中 **查看日志** 命令示例：
+
+```shell
+cd ../logs
+tail -f eventmesh.out
+```
+
+**删除容器** 命令示例:
+
+```shell
+sudo docker rm -f [your container id or name]
+```
+
+## 探索更多
+
+现在 EventMesh 已经通过容器运行了，你可以参考 [```eventmesh-examples``` 模块](https://github.com/apache/incubator-eventmesh/tree/master/eventmesh-examples) 编写并测试自己的代码了。
+
+希望你享受这个过程并获得更多收获！
diff --git a/zh/docs/instruction/02-runtime.md b/zh/docs/instruction/02-runtime.md
new file mode 100644
index 00000000..845f1ccf
--- /dev/null
+++ b/zh/docs/instruction/02-runtime.md
@@ -0,0 +1,114 @@
+# Eventmesh-runtime 快速入门说明
+
+
+## 1 本地构建运行
+
+### 1.1 依赖
+
+```
+建议使用64位操作系统，建议使用Linux / Unix；
+64位JDK 1.8+;
+Gradle至少为7.0, 推荐 7.0.*
+```
+
+### 1.2 下载源码
+
+在 [EventMesh download](https://eventmesh.apache.org/download) 页面选择1.5.0版本的 Source Code 进行下载并解压, 您将获得**apache-eventmesh-1.5.0-incubating-src**
+
+
+### 1.3 本地启动
+
+**1.3.1 项目结构说明：**
+
+- eventmesh-common : eventmesh公共类与方法模块
+- eventmesh-connector-api : eventmesh connector插件接口定义模块
+- eventmesh-connector-plugin : eventmesh connector插件模块
+- eventmesh-runtime : eventmesh运行时模块
+- eventmesh-sdk-java : eventmesh java客户端sdk
+- eventmesh-starter : eventmesh本地启动运行项目入口
+- eventmesh-spi : eventmesh SPI加载模块
+
+> 注：插件模块遵循 eventmesh 定义的SPI规范, 自定义的SPI接口需要使用注解 @EventMeshSPI 标识.
+> 插件实例需要在对应模块中的 /main/resources/META-INF/eventmesh 下配置相关接口与实现类的映射文件,文件名为SPI接口全类名.
+> 文件内容为插件实例名到插件实例的映射, 具体可以参考 eventmesh-connector-rocketmq 插件模块
+
+**1.3.2 插件说明**
+
+***1.3.2.1 安装插件***
+
+有两种方式安装插件
+
+- classpath加载：本地开发可以通过在 eventmesh-starter 模块 build.gradle 中进行声明，例如声明使用 rocketmq 插件
+
+```gradle
+ implementation project(":eventmesh-connector-plugin:eventmesh-connector-rocketmq")
+```
+
+- 文件加载：通过将插件安装到插件目录，EventMesh 在运行时会根据条件自动加载插件目录下的插件，可以通过执行以下命令安装插件
+
+```shell
+./gradlew clean jar dist && ./gradlew installPlugin
+```
+
+***1.3.2.2 使用插件***
+
+EventMesh 会默认加载 dist/plugin 目录下的插件，可以通过`-DeventMeshPluginDir=your_plugin_directory`来改变插件目录。运行时需要使用的插件实例可以在
+`confPath`目录下面的`eventmesh.properties`中进行配置。例如通过以下设置声明在运行时使用rocketmq插件。
+
+```properties
+#connector plugin
+eventMesh.connector.plugin.type=rocketmq
+```
+
+**1.3.3 配置VM启动参数**
+
+```properties
+-Dlog4j.configurationFile=eventmesh-runtime/conf/log4j2.xml
+-Deventmesh.log.home=eventmesh-runtime/logs
+-Deventmesh.home=eventmesh-runtime
+-DconfPath=eventmesh-runtime/conf
+```
+
+> 注：如果操作系统为Windows, 可能需要将文件分隔符换成\
+
+**1.3.4 启动运行**
+
+```
+运行org.apache.eventmesh.starter.StartUp的主要方法
+```
+
+## 2 远程部署
+
+### 2.1 依赖
+
+```
+建议使用64位操作系统，建议使用Linux / Unix；
+64位JDK 1.8+;
+Gradle至少为7.0, 推荐 7.0.*
+```
+
+### 2.2 下载
+
+在 [EventMesh download](https://eventmesh.apache.org/download) 页面选择1.5.0版本的 Binary Distribution 进行下载, 您将获得**apache-eventmesh-1.5.0-incubating-bin.tar.gz**
+
+
+### 2.3 部署
+
+- 部署eventmesh-runtime
+
+```$ xslt
+# 解压 apache-eventmesh-1.5.0-incubating-bin.tar.gz
+tar -zxvf apache-eventmesh-1.5.0-incubating-bin.tar.gz
+cd apache-eventmesh-1.5.0-incubating
+
+# 配置 eventMesh.properties
+vim conf/eventMesh.properties
+
+# 启动EventMesh
+cd bin
+sh start.sh
+```
+
+如果看到"EventMeshTCPServer[port=10000] started...."，则说明设置成功。
+
+
diff --git a/zh/docs/instruction/03-demo.md b/zh/docs/instruction/03-demo.md
new file mode 100644
index 00000000..5c3f77ae
--- /dev/null
+++ b/zh/docs/instruction/03-demo.md
@@ -0,0 +1,178 @@
+# 运行 eventmesh-sdk-java demo
+
+[](https://maven-badges.herokuapp.com/maven-central/org.apache.eventmesh/eventmesh-sdk-java)
+
+> EventMesh-sdk-java作为客户端，与eventmesh-runtime通信，用于完成消息的发送和接收。
+>
+> EventMesh-sdk-java支持异步消息和广播消息。异步消息表示生产者只发送消息，不关心回复消息。广播消息表示生产者发送一次消息，所有订阅广播主题的消费者都将收到消息
+>
+> EventMesh-sdk-java支持HTTP，TCP 和 GRPC 协议。
+
+TCP, HTTP 和 GRPC 示例都在**eventmesh-examples**模块下
+
+### 1. TCP DEMO
+
+<h4>异步消息</h4>
+
+- 创建主题TEST-TOPIC-TCP-ASYNC，可以通过 rocketmq-console 或者 rocketmq tools 命令
+
+- 启动消费者，订阅上一步骤已经创建的Topic
+
+```
+运行 org.apache.eventmesh.tcp.demo.sub.eventmeshmessage.AsyncSubscribe 的main方法
+```
+
+- 启动发送端，发送消息
+
+```
+运行 org.apache.eventmesh.tcp.demo.pub.eventmeshmessage.AsyncPublish 的main方法
+```
+
+<h4>广播消息</h4>
+
+- 创建主题TEST-TOPIC-TCP-BROADCAST，可以通过 rocketmq-console 或者 rocketmq tools 命令
+
+- 启动消费端，订阅上一步骤已经创建的Topic
+
+```
+运行 org.apache.eventmesh.tcp.demo.sub.eventmeshmessage.AsyncSubscribeBroadcast 的main方法
+```
+
+- 启动发送端，发送广播消息
+
+```
+运行 org.apache.eventmesh.tcp.demo.pub.eventmeshmessage.AsyncPublishBroadcast 的main方法
+```
+
+更多关于TCP部分的内容，请参考 [EventMesh TCP](/docs/zh/sdk-java/03-tcp.md)
+
+### 2. HTTP演示
+
+> 对于HTTP，eventmesh-sdk-java对对于异步事件实现了发送与订阅
+>
+>在演示中，Java类`LiteMessage`的`content`字段表示一个特殊的协议，因此，如果您要使用eventmesh-sdk-java的http-client，则只需设计协议的内容并在同一时间提供消费者的应用程序。
+
+<h4>异步事件</h4>
+
+> 生产者将事件发送给下游即可，无需等待响应
+
+- 创建主题TEST-TOPIC-HTTP-ASYNC，可以通过rocketmq-console或者rocketmq tools 命令
+
+- 启动消费端，订阅Topic
+
+ 异步事件消费端为spring boot demo，运行demo即可启动服务并完成Topic订阅
+
+```
+运行 org.apache.eventmesh.http.demo.sub.SpringBootDemoApplication 的main方法
+```
+
+- 启动发送端，发送消息
+
+```
+运行 org.apache.eventmesh.http.demo.pub.eventmeshmessage.AsyncPublishInstance 的main方法
+```
+更多关于HTTP部分的内容，请参考 [EventMesh HTTP](/docs/zh/sdk-java/02-http.md)
+
+### 3. GRPC 演示
+
+> eventmesh-sdk-java 实现了 gRPC 协议. 它能异步和同步发送事件到 eventmesh-runtime.
+> 它可以通过webhook和事件流方式订阅消费事件， 同时也支持 CNCF CloudEvents 协议.
+
+<h4> 异步事件发送 和 webhook订阅 </h4>
+
+> Async生产者 异步发送事件到 eventmesh-runtime, 不需要等待事件储存到 `event-store`
+> 在webhook 消费者, 事件推送到消费者的http endpoint url。这个URL在消费者的 `Subscription` 模型定于. 这方法跟前面的Http eventmsh client类似。
+
+- 在rocketmq 创建主题 TEST-TOPIC-GRPC-ASYNC
+- 启动 publisher 发送事件
+
+```
+运行 org.apache.eventmesh.grpc.pub.eventmeshmessage.AsyncPublishInstance 的main方法
+```
+
+- 启动 webhook 消费者
+
+```
+运行 org.apache.eventmesh.grpc.sub.app.SpringBootDemoApplication 的main方法
+```
+
+<h4> 同步事件发送和事件流订阅 </h4>
+
+> 同步生产者 发送事件到 eventmesh-runtime, 同时等待事件储存到 `event-store`
+> 在事件流消费者，事件以流的形式推送到 `ReceiveMsgHook` 客户端。 这方法类似 eventmesh client.
+
+- 在rocketmq 创建主题 TEST-TOPIC-GRPC-RR
+- 启动 Request-Reply publisher 发送事件
+
+```
+运行 org.apache.eventmesh.grpc.pub.eventmeshmessage.RequestReplyInstance 的main方法
+```
+
+- 启动 stream subscriber
+
+```
+运行 org.apache.eventmesh.grpc.sub.EventmeshAsyncSubscribe 的main方法
+```
+
+<h4> 批量事件发布 </h4>
+
+> 批量发布多个事件到 eventmesh-runtime. 这是异步操作
+
+- 在rocketmq 创建主题 TEST-TOPIC-GRPC-ASYNC
+- 启动 publisher 来批量发布事件
+
+```
+运行 org.apache.eventmesh.grpc.pub.eventmeshmessage.BatchPublishInstance 的main方法
+```
+
+更多关于 gRPC 部分的内容，请参考 [EventMesh gRPC](/docs/zh/sdk-java/04-grpc.md)
+
+### 3.4 测试
+
+请参考[EventMesh Store](/docs/zh/instruction/01-store.md) 和 [EventMesh Runtime](/docs/zh/instruction/02-runtime.md) 完成运行环境的部署
+
+完成 store 和 runtime 的部署后，就可以在 eventmesh-examples 模块下运行我们的 demo 来体验 eventmesh 了：
+
+ TCP Sub
+
+ ```shell
+ cd bin
+ sh tcp_eventmeshmessage_sub.sh
+ ```
+
+ TCP Pub
+
+ ```shell
+ cd bin
+ sh tcp_pub_eventmeshmessage.sh
+ ```
+
+ TCP Sub Broadcast
+
+ ```shell
+ cd bin
+ sh tcp_sub_eventmeshmessage_broadcast.sh
+ ```
+
+ TCP Pub Broadcast
+
+ ```shell
+ cd bin
+ sh tcp_pub_eventmeshmessage_broadcast.sh
+ ```
+
+ HTTP Sub
+
+ ```shell
+ cd bin
+ sh http_sub.sh
+ ```
+
+ HTTP Pub
+
+ ```shell
+ cd bin
+ sh http_pub_eventmeshmessage.sh
+ ```
+
+ 之后, 你可以在 `/logs` 目录下面看到不同模式的运行日志
diff --git a/zh/docs/instruction/_category_.json b/zh/docs/instruction/_category_.json
new file mode 100644
index 00000000..06fd721f
--- /dev/null
+++ b/zh/docs/instruction/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Instructions",
+ "collapsed": false
+}
diff --git a/zh/docs/introduction.md b/zh/docs/introduction.md
new file mode 100644
index 00000000..43c821dd
--- /dev/null
+++ b/zh/docs/introduction.md
@@ -0,0 +1,49 @@
+# Apache EventMesh (Incubating)
+
+[](https://github.com/apache/incubator-eventmesh/actions/workflows/ci.yml)
+[](https://codecov.io/gh/apache/incubator-eventmesh)
+[](https://lgtm.com/projects/g/apache/incubator-eventmesh/context:java)
+[](https://lgtm.com/projects/g/apache/incubator-eventmesh/alerts/)
+[](https://github.com/apache/incubator-eventmesh/releases)
+[](https://www.apache.org/licenses/LICENSE-2.0.html)
+
+## 什么是Event Mesh？
+
+EventMesh是一个动态的云原生事件驱动架构基础设施，用于分离应用程序和后端中间件层，它支持广泛的用例，包括复杂的混合云、使用了不同技术栈的分布式架构。
+
+
+
+**EventMesh架构：**
+
+
+
+**EventMesh云原生结构：**
+
+
+
+Event Mesh允许将来自一个应用程序的事件动态路由到任何其他应用程序. Event Mesh的一般功能:
+
+* 事件驱动;
+* 事件治理;
+* 动态路由;
+* 云原生
+
+部件：
+
+* eventmesh-runtime：一种中间件，用于在事件生产者和消费者之间传输事件，支持云原生应用程序和微服务
+* eventmesh-sdk-java：当前支持HTTP、HHTTP、TCP和 [gRPC](https://grpc.io) 协议
+
+
+## 快速开始
+
+1. 构建并部署 event-store(RocketMQ), 请参见[说明](instruction/01-store.md)
+2. 构建并部署 eventmesh-runtime，请参见[说明](instruction/02-runtime.md)
+3. 运行 eventmesh-sdk-java 演示，请参见[说明](instruction/03-demo.md)
+
+## 贡献
+
+永远欢迎参与共建, 请参阅[贡献](../../03-new-contributor-guidelines.md)了解详细指南
+
+您可以从发现和解决问题开始～
+[GitHub Issues](https://github.com/apache/incubator-eventmesh/issues)
+
diff --git a/zh/docs/roadmap.md b/zh/docs/roadmap.md
new file mode 100644
index 00000000..a3d7695c
--- /dev/null
+++ b/zh/docs/roadmap.md
@@ -0,0 +1,47 @@
+---
+sidebar_position: 1
+---
+
+# EventMesh产品路线图
+
+下表列出了EventMesh的新特性和bug修复情况，详情请参考 [release notes](https://eventmesh.apache.org/events/release-notes/v1.4.0).
+
+## List of Features and Milestones
+
+| Status | Description | Reference |
+|-------------------------------------------|---------------------------------| --- |
+| **Implemented in 1.0.0** | Support HTTP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.0.0** | Support TCP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.0.0** | Support Pub/Sub Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.1.1** | Provide Java SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.1.1** | Support HTTPS | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.2.0** | Support RocketMQ as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.2.0** | Support Heartbeat | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenSchema | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenTelemetry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Support CloudEvents | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.4.0** | Support gRPC | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Provide Golang SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Nacos Registry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Federal Government | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Integrate with Consul | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Support Webhook | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Support etcd | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Knative Eventing Infrastructure | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/790), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-463) |
+| **In Progress** | Dashboard | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/700), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-465) |
+| **In Progress** | Support Kafka as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
+| **In Progress** | Support Pulsar as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
+| **In Progress** | Support Dledger | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Workflow | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Redis | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Zookeeper | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| Planned | Provide NodeJS SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| Planned | Transaction Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/697) |
+| Planned | Event Query Language (EQL) | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/778) |
+| Planned | Metadata consistency persistent | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/817) |
+| Planned | Rust SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/815) |
+| Planned | WebAssembly Runtime | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/576) |
+| Planned | Filter Chain | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/664) |
+
diff --git a/zh/docs/sdk-java/01-intro.md b/zh/docs/sdk-java/01-intro.md
new file mode 100644
index 00000000..cb4b8764
--- /dev/null
+++ b/zh/docs/sdk-java/01-intro.md
@@ -0,0 +1,29 @@
+# 安装
+
+[](https://maven-badges.herokuapp.com/maven-central/org.apache.eventmesh/eventmesh-sdk-java)
+
+EventMesh Java SDK 是在一个 Java 应用中集成 Eventmesh 所需的 Java 组件集合。SDK 支持使用 TCP、HTTP 和 gRPC 协议来发送和接收同步消息、异步消息和广播消息。SDK 实现了 EventMesh 消息、CloudEvents 和 OpenMessaging 形式。您可以在 [`eventmesh-example`](https://github.com/apache/incubator-eventmesh/tree/master/eventmesh-examples) 模块中查看示例项目。
+
+## Gradle
+
+使用 Gradle 安装 EventMesh Java SDK，您需要在模块的 `build.gradle` 文件的依赖块中将 `org.apache.eventmesh:eventmesh-sdk-java` 声明为 `implementation`。
+
+```groovy
+dependencies {
+ implementation 'org.apache.eventmesh:eventmesh-sdk-java:1.4.0'
+}
+```
+
+## Maven
+
+使用 Maven 安装 EventMesh Java SDK，您需要在项目 `pom.xml` 文件的依赖块中声明 `org.apache.eventmesh:eventmesh-sdk-java`。
+
+```xml
+<dependencies>
+ <dependency>
+ <groupId>org.apache.eventmesh</groupId>
+ <artifactId>eventmesh-sdk-java</artifactId>
+ <version>1.4.0</version>
+ </dependency>
+</dependencies>
+```
\ No newline at end of file
diff --git a/zh/docs/sdk-java/02-http.md b/zh/docs/sdk-java/02-http.md
new file mode 100644
index 00000000..9a8acd0d
--- /dev/null
+++ b/zh/docs/sdk-java/02-http.md
@@ -0,0 +1,118 @@
+# HTTP 协议
+
+EventMesh Java SDK 实现了 HTTP 异步消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh HTTP 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
+
+```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 消费者
+
+类 `EventMeshHttpConsumer` 实现了 `heartbeat`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题和回调的 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);
+ }
+}
+```
+
+EventMesh runtime 将发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 信息的 POST 请求到这个回调的 URL 地址。类 [SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/http/demo/sub/controller/SubController.java) 实现了 Spring Boot controller，它将接收并解析回调信息。
+
+## HTTP 生产者
+
+类 `EventMeshHttpProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
+
+- `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);
+ }
+}
+```
+
+## 使用Curl 命令
+
+本段落介绍通过Curl命令体验事件的收发功能
+
+### 事件发送
+
+启动EventMesh Runtime服务后，可以使用Curl命令将事件用HTTP POST方法发布到指定的主题，Body内容必须是JSON格式，执行命令示例如下:
+
+```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
+```
+
+
+
+### 事件订阅
+
+启动EventMesh Runtime服务后，可以使用Curl命令用HTTP POST方法订阅指定的主题列表，Body内容必须是JSON格式，执行命令示例如下:
+
+```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
+```
+
+你可以在项目`eventmesh-examples`模块中看到这个例子。
\ No newline at end of file
diff --git a/zh/docs/sdk-java/03-tcp.md b/zh/docs/sdk-java/03-tcp.md
new file mode 100644
index 00000000..54f5eca5
--- /dev/null
+++ b/zh/docs/sdk-java/03-tcp.md
@@ -0,0 +1,118 @@
+# TCP 协议
+
+EventMesh Java SDK 实现了同步、异步和广播 TCP 消息的生产者和消费者。 二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh TCP 客户端的配置信息。其中的 `host` 和 `port` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
+
+```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 消费者
+
+消费者应该实现 `ReceiveMsgHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-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);
+}
+```
+
+类 `EventMeshTCPClient` 实现了 `subscribe` 方法。该方法接收话题、`SubscriptionMode` 和 `SubscriptionType`。`handle` 方法将会在消费者从订阅的话题中收到消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
+
+```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 生产者
+
+### 异步生产者
+
+类 `EventMeshTCPClient` 实现了 `public` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
+
+```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);
+```
+
+### 同步生产者
+
+类 `EventMeshTCPClient` 实现了 `rr` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
+
+```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));
+```
\ No newline at end of file
diff --git a/zh/docs/sdk-java/04-grpc.md b/zh/docs/sdk-java/04-grpc.md
new file mode 100644
index 00000000..b0781870
--- /dev/null
+++ b/zh/docs/sdk-java/04-grpc.md
@@ -0,0 +1,174 @@
+# gRPC 协议
+
+EventMesh Java SDK 实现了 gRPC 同步、异步和广播消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh gRPC 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
+
+```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 消费者
+
+### 流消费者
+
+EventMesh runtime 会将来自生产者的信息作为一系列事件流向流消费者发送。消费者应实现 `ReceiveHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-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();
+}
+```
+
+类 `EventMeshGrpcConsumer` 实现了 `registerListener`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题。`registerListener` 接收一个实现了 `ReceiveMsgHook` 的实例。`handle` 方法将会在消费者收到订阅的主题消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
+
+```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 消费者
+
+类 `EventMeshGrpcConsumer` 的 `subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的主题和一个可选的 timeout 值。如果提供了回调 URL，EventMesh runtime 将向回调 URL 地址发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 消息的 POST 请求。[SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/grpc/sub/app/controller/SubController.java) 实现了一个接收并解析回调信息的 Spring Boot controller。
+
+```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 生产者
+
+### 异步生产者
+
+类 `EventMeshGrpcProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
+
+- `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);
+```
+
+### 同步生产者
+
+类 `EventMeshGrpcProducer` 实现了 `requestReply` 方法。`requestReply` 方法接收将被发布的消息和一个可选的 timeout 值。方法会返回消费者返回的消息。消息应是下列类的一个实例：
+
+- `org.apache.eventmesh.common.EventMeshMessage`
+- `io.cloudevents.CloudEvent`
+
+### 批量生产者
+
+类 `EventMeshGrpcProducer` 重写了 `publish` 方法，该方法接收一个将被发布的消息列表和一个可选的 timeout 值。列表中的消息应是下列类的一个实例：
+
+- `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);
+/* ... */
+```
\ No newline at end of file
diff --git a/zh/docs/sdk-java/_category_.json b/zh/docs/sdk-java/_category_.json
new file mode 100644
index 00000000..9d0a27c5
--- /dev/null
+++ b/zh/docs/sdk-java/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "EventMesh SDK for Java",
+ "collapsed": false
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@eventmesh.apache.org
For additional commands, e-mail: commits-help@eventmesh.apache.org