doc: reconstruct cn

Signed-off-by: Jiyong Huang <huangjy@emqx.io>

docs/directory.json

@@ -1,19 +1,19 @@
 {
 	"cn": [
 		{
-			"title": "概要",
+			"title": "概览",
 			"path": "./"
 		},
 		{
 			"title": "快速开始",
 			"children": [
 				{
-					"title": "本地运行",
-					"path": "getting_started"
+					"title": "快速开始",
+					"path": "getting_started/getting_started"
 				},
 				{
-					"title": "Docker 容器运行",
-					"path": "quick_start_docker"
+					"title": "5分钟快速运行",
+					"path": "getting_started/quick_start_docker"
 				},
 				{
 					"title": "作为 EdgeX Foundry 规则引擎运行",
@@ -22,199 +22,118 @@
 			]
 		},
 		{
-			"title": "概念",
+			"title": "安装与部署",
 			"children": [
 				{
-					"title": "eKuiper 基本概念",
-					"path": "concepts/ekuiper"
-				},
-				{
-					"title": "规则",
-					"path": "concepts/rules"
-				},
-				{
-					"title": "Sources 源",
-					"children": [
-						{
-							"title": "概览",
-							"path": "concepts/sources/overview"
-						},
-						{
-							"title": "流",
-							"path": "concepts/sources/stream"
-						},
-						{
-							"title": "表",
-							"path": "concepts/sources/table"
-						}
-					]
-				},
-				{
-					"title": "Sinks 动作",
-					"path": "concepts/sinks"
-				},
-				{
-					"title": "SQL 查询",
-					"path": "concepts/sql"
-				},
+					"title": "安装与部署",
+					"path": "installation"
+				}
+			]
+		},
+		{
+			"title": "配置",
+			"children": [
 				{
-					"title": "流式处理",
-					"children": [
-						{
-							"title": "概览",
-							"path": "concepts/streaming/overview"
-						},
-						{
-							"title": "时间属性",
-							"path": "concepts/streaming/time"
-						},
-						{
-							"title": "窗口",
-							"path": "concepts/streaming/windowing"
-						},
-						{
-							"title": "连接",
-							"path": "concepts/streaming/join"
-						}
-					]
+					"title": "配置",
+					"path": "configuration/configuration"
 				},
 				{
-					"title": "扩展",
-					"path": "concepts/extensions"
+					"title": "全局配置文件",
+					"path": "configuration/global_configurations"
 				}
 			]
 		},
 		{
-			"title": "教程",
+			"title": "用户指南",
 			"children": [
 				{
-					"title": "AI 教程",
+					"title": "流：无界的事件系列",
 					"children": [
 						{
-							"title": "使用 eKuiper 原生插件实现图像标注",
-							"path": "tutorials/ai/tensorflow_lite_tutorial"
-						},
-						{
-							"title": "使用 Python 函数插件运行 AI 算法",
-							"path": "tutorials/ai/python_tensorflow_lite_tutorial"
+							"title": "流",
+							"path": "guide/streams/overview"
 						}
 					]
 				},
 				{
-					"title": "EdgeX Foundry 相关教程",
+					"title": "表：事件序列的快照",
 					"children": [
 						{
-							"title": "EdgeX Foundry 规则引擎教程",
-							"path": "edgex/edgex_rule_engine_tutorial"
-						},
-						{
-							"title": "使用 EdgeX 流的 meta 函数",
-							"path": "edgex/edgex_meta"
+							"title": "表",
+							"path": "guide/tables/overview"
 						},
 						{
-							"title": "EdgeX 规则引擎使用 command 服务",
-							"path": "edgex/edgex_rule_engine_command"
+							"title": "扫描表",
+							"path": "guide/tables/scan"
 						},
 						{
-							"title": "EdgeX 源配置教程",
-							"path": "edgex/edgex_source_tutorial"
+							"title": "查询表",
+							"path": "guide/tables/lookup"
 						}
 					]
 				},
 				{
-					"title": "使用 eKuiper 对 Neuron 采集的数据进行流式处理",
-					"path": "tutorials/neuron/neuron_integration_tutorial"
-				},
-				{
-					"title": "通过 OpenYurt 部署教程",
-					"path": "tutorials/deploy/openyurt_tutorial"
-				},
-				{
-					"title": "功能使用教程",
+					"title": "规则：查询和动作",
 					"children": [
 						{
-							"title": "流批结合计算",
-							"path": "tutorials/table/lookup"
-						},
-						{
-							"title": "使用 Protobuf 编解码教程",
-							"path": "tutorials/usage/protobuf_tutorial"
+							"title": "规则",
+							"path": "guide/rules/overview"
 						},
 						{
-							"title": "使用 Prometheus 监控规则运行状态",
-							"path": "tutorials/usage/monitor_with_prometheus"
-						}
-					]
-				}
-			]
-		},
-		{
-			"title": "参考",
-			"children": [
-				{
-					"title": "规则",
-					"children": [
-						{
-							"title": "概览",
-							"path": "rules/overview"
+							"title": "图规则",
+							"path": "guide/rules/graph_rule"
 						},
 						{
 							"title": "规则流水线",
-							"path": "rules/rule_pipeline"
+							"path": "guide/rules/rule_pipeline"
 						},
 						{
 							"title": "状态和容错",
-							"path": "rules/state_and_fault_tolerance"
-						},{
-							"title": "编解码",
-							"path": "rules/codecs"
-						},{
-							"title": "图规则",
-							"path": "rules/graph_rule"
+							"path": "guide/rules/state_and_fault_tolerance"
 						}
 					]
 				},
 				{
-					"title": "Sources 源",
+					"title": "数据源",
 					"children": [
 						{
-							"title": "概览",
-							"path": "rules/sources/overview"
+							"title": "数据源",
+							"path": "guide/sources/overview"
 						},
 						{
 							"title": "内置源",
 							"children": [
 								{
 									"title": "MQTT 源",
-									"path": "rules/sources/builtin/mqtt"
+									"path": "guide/sources/builtin/mqtt"
 								},
 								{
 									"title": "Neuron 源",
-									"path": "rules/sources/builtin/neuron"
+									"path": "guide/sources/builtin/neuron"
 								},
 								{
 									"title": "EdgeX 源",
-									"path": "rules/sources/builtin/edgex"
+									"path": "guide/sources/builtin/edgex"
 								},
 								{
 									"title": "HTTP 拉取源",
-									"path": "rules/sources/builtin/http_pull"
+									"path": "guide/sources/builtin/http_pull"
 								},
 								{
 									"title": "HTTP 推送源",
-									"path": "rules/sources/builtin/http_push"
+									"path": "guide/sources/builtin/http_push"
 								},
 								{
 									"title": "内存源",
-									"path": "rules/sources/builtin/memory"
+									"path": "guide/sources/builtin/memory"
 								},
 								{
 									"title": "文件源",
-									"path": "rules/sources/builtin/file"
+									"path": "guide/sources/builtin/file"
 								},
 								{
 									"title": "Redis 源",
-									"path": "rules/sources/builtin/redis"
+									"path": "guide/sources/builtin/redis"
 								}
 							]
 						},
@@ -223,166 +142,321 @@
 							"children": [
 								{
 									"title": "Zero MQ 源",
-									"path": "rules/sources/plugin/zmq"
+									"path": "guide/sources/plugin/zmq"
 								},
 								{
 									"title": "SQL 源",
-									"path": "rules/sources/plugin/sql"
+									"path": "guide/sources/plugin/sql"
 								},
 								{
-									"title": "随机源",
-									"path": "rules/sources/plugin/random"
+									"title": "随机数据产生器源",
+									"path": "guide/sources/plugin/random"
 								},
 								{
 									"title": "视频源",
-									"path": "rules/sources/plugin/video"
+									"path": "guide/sources/plugin/video"
 								}
 							]
 						}
 					]
 				},
 				{
-					"title": "Sinks 动作",
+					"title": "数据汇（Sink）",
 					"children": [
 						{
 							"title": "概览",
-							"path": "rules/sinks/overview"
+							"path": "guide/sinks/overview"
 						},
 						{
 							"title": "数据模板",
-							"path": "rules/data_template"
+							"path": "guide/sinks/data_template"
 						},
 						{
-							"title": "内置 sinks",
+							"title": "内置 Sink",
 							"children": [
 								{
-									"title": "MQTT 动作",
-									"path": "rules/sinks/builtin/mqtt"
+									"title": "MQTT Sink",
+									"path": "guide/sinks/builtin/mqtt"
 								},
 								{
-									"title": "Neuron 动作",
-									"path": "rules/sinks/builtin/neuron"
+									"title": "Neuron Sink",
+									"path": "guide/sinks/builtin/neuron"
 								},
 								{
-									"title": "EdgeX 动作",
-									"path": "rules/sinks/builtin/edgex"
+									"title": "EdgeX Sink",
+									"path": "guide/sinks/builtin/edgex"
 								},
 								{
-									"title": "REST 动作",
-									"path": "rules/sinks/builtin/rest"
+									"title": "REST Sink",
+									"path": "guide/sinks/builtin/rest"
 								},
 								{
-									"title": "内存动作",
-									"path": "rules/sinks/builtin/memory"
+									"title": "Memory Sink",
+									"path": "guide/sinks/builtin/memory"
 								},
 								{
-									"title": "日志动作",
-									"path": "rules/sinks/builtin/log"
+									"title": "Log Sink",
+									"path": "guide/sinks/builtin/log"
 								},
 								{
-									"title": "Nop 动作",
-									"path": "rules/sinks/builtin/nop"
+									"title": "Nop Sink",
+									"path": "guide/sinks/builtin/nop"
 								},
 								{
-									"title": "Redis 动作",
-									"path": "rules/sinks/builtin/redis"
+									"title": "Redis Sink",
+									"path": "guide/sinks/builtin/redis"
 								}
 							]
 						},
 						{
-							"title": "预定义 sink 插件",
+							"title": "预定义插件 Sink",
 							"children": [
 								{
-									"title": "Zero MQ 动作",
-									"path": "rules/sinks/plugin/zmq"
+									"title": "ZeroMQ Sink",
+									"path": "guide/sinks/plugin/zmq"
 								},
 								{
-									"title": "文件动作",
-									"path": "rules/sinks/plugin/file"
+									"title": "File Sink",
+									"path": "guide/sinks/plugin/file"
 								},
 								{
-									"title": "SQL 动作",
-									"path": "rules/sinks/plugin/sql"
+									"title": "SQL Sink",
+									"path": "guide/sinks/plugin/sql"
 								},
 								{
-									"title": "InfluxDB 动作",
-									"path": "rules/sinks/plugin/influx"
+									"title": "InfluxDB Sink",
+									"path": "guide/sinks/plugin/influx"
 								},
 								{
-									"title": "InfluxDBV2 动作",
-									"path": "rules/sinks/plugin/influx2"
+									"title": "InfluxDBV2 Sink",
+									"path": "guide/sinks/plugin/influx2"
 								},
 								{
-									"title": "TDengine 动作",
-									"path": "rules/sinks/plugin/tdengine"
+									"title": "TDengine Sink",
+									"path": "guide/sinks/plugin/tdengine"
 								},
 								{
-									"title": "图像动作",
-									"path": "rules/sinks/plugin/image"
+									"title": "Image Sink",
+									"path": "guide/sinks/plugin/image"
 								}
 							]
 						}
 					]
 				},
 				{
-					"title": "SQL 参考",
+					"title": "序列化",
+					"children": [
+						{
+							"title": "概览",
+							"path": "guide/serialization/serialization"
+						},
+						{
+							"title": "使用 Protobuf 编解码教程",
+							"path": "guide/serialization/protobuf_tutorial"
+						}
+					]
+				},
+				{
+					"title": "AI/ML",
+					"children": [
+						{
+							"title": "使用原生插件实现 AI 函数",
+							"path": "guide/ai/tensorflow_lite_tutorial"
+						},
+						{
+							"title": "使用 Python 插件实现 AI 函数",
+							"path": "guide/ai/python_tensorflow_lite_tutorial"
+						}
+					]
+				}
+			]
+		},
+		{
+			"title": "管理指南",
+			"children": [
+				{
+					"title": "安装与部署",
+					"path": "installation"
+				},
+				{
+					"title": "配置",
+					"children": [
+						{
+							"title": "配置",
+							"path": "configuration/configuration"
+						},
+						{
+							"title": "全局配置文件",
+							"path": "configuration/global_configurations"
+						}
+					]
+				},
+				{
+					"title": "管理控制台",
+					"children": [
+						{
+							"title": "使用教程",
+							"path": "operation/manager-ui/overview"
+						},
+						{
+							"title": "插件管理",
+							"path": "operation/manager-ui/plugins_in_manager"
+						}
+					]
+				},
+				{
+					"title": "编译",
 					"children": [
 						{
-							"title": "语法",
+							"title": "源码编译",
+							"path": "operation/compile/compile"
+						},
+						{
+							"title": "交叉编译",
+							"path": "operation/compile/cross-compile"
+						},
+						{
+							"title": "按需编译",
+							"path": "operation/compile/features"
+						}
+					]
+				},
+				{
+					"title": "监控",
+					"children": [
+						{
+							"title": "使用 Prometheus 监控规则运行状态",
+							"path": "operation/usage/monitor_with_prometheus"
+						}
+					]
+				}
+			]
+		},
+		{
+			"title": "应用场景",
+			"children": [
+				{
+					"title": "工业物联网",
+					"path": "usecases/iiot"
+				},
+				{
+					"title": "车联网",
+					"path": "usecases/iov"
+				}
+			]
+		},
+		{
+			"title": "集成",
+			"children": [
+				{
+					"title": "边云协同",
+					"path": "integrations/edge_cloud/overview"
+				},
+				{
+					"title": "EdgeX Foundry 的规则引擎",
+					"children": [
+						{
+							"title": "EdgeX Foundry 规则引擎教程",
+							"path": "edgex/edgex_rule_engine_tutorial"
+						},
+						{
+							"title": "使用 EdgeX 流的 meta 函数",
+							"path": "edgex/edgex_meta"
+						},
+						{
+							"title": "EdgeX 规则引擎使用 command 服务",
+							"path": "edgex/edgex_rule_engine_command"
+						},
+						{
+							"title": "EdgeX 源配置教程",
+							"path": "edgex/edgex_source_tutorial"
+						}
+					]
+				},
+				{
+					"title": "分析处理 Neuron 采集的数据",
+					"path": "integrations/neuron/neuron_integration_tutorial"
+				},
+				{
+					"title": "KubeEdge 的分析引擎",
+					"path": "integrations/kubeedge/overview"
+				},
+				{
+					"title": "使用 OpenYurt 部署",
+					"path": "integrations/deploy/openyurt_tutorial"
+				}
+			]
+		},
+		{
+			"title": "架构和设计",
+			"children": [
+				{
+					"title": "架构",
+					"path": "concepts/ekuiper"
+				},
+				{
+					"title": "关键概念",
+					"children": [
+						{
+							"title": "规则",
+							"path": "concepts/rules"
+						},
+						{
+							"title": "Sources 源",
 							"children": [
 								{
 									"title": "概览",
-									"path": "sqls/overview"
-								},
-								{
-									"title": "词汇元素",
-									"path": "sqls/lexical_elements"
-								},
-								{
-									"title": "数据类型",
-									"path": "sqls/data_types"
+									"path": "concepts/sources/overview"
 								},
 								{
-									"title": "JSON 表达式",
-									"path": "sqls/json_expr"
+									"title": "流",
+									"path": "concepts/sources/stream"
 								},
 								{
-									"title": "查询语言元素",
-									"path": "sqls/query_language_elements"
+									"title": "表",
+									"path": "concepts/sources/table"
 								}
 							]
 						},
 						{
-							"title": "语句",
-							"children": [
-								{
-									"title": "流语句",
-									"path": "sqls/streams"
-								},
-								{
-									"title": "表语句",
-									"path": "sqls/tables"
-								}
-							]
+							"title": "Sinks 动作",
+							"path": "concepts/sinks"
 						},
 						{
-							"title": "窗口",
-							"path": "sqls/windows"
+							"title": "SQL 查询",
+							"path": "concepts/sql"
 						},
 						{
-							"title": "内置函数",
-							"path": "sqls/built-in_functions"
+							"title": "扩展",
+							"path": "concepts/extensions"
+						}
+					]
+				},
+				{
+					"title": "流式处理",
+					"children": [
+						{
+							"title": "概览",
+							"path": "concepts/streaming/overview"
+						},
+						{
+							"title": "时间属性",
+							"path": "concepts/streaming/time"
 						},
 						{
-							"title": "预定义函数插件",
-							"path": "sqls/custom_functions"
+							"title": "窗口",
+							"path": "concepts/streaming/windowing"
+						},
+						{
+							"title": "连接",
+							"path": "concepts/streaming/join"
 						}
 					]
 				}
 			]
 		},
 		{
-			"title": "扩展开发",
+			"title": "开发者指南",
 			"children": [
 				{
 					"title": "概览",
@@ -396,7 +470,7 @@
 							"path": "extension/native/overview"
 						},
 						{
-							"title": "原生插件总览",
+							"title": "原始插件开发",
 							"path": "extension/native/develop/overview"
 						},
 						{
@@ -408,7 +482,7 @@
 							"path": "extension/native/develop/function"
 						},
 						{
-							"title": "动作插件开发",
+							"title": "Sink 插件开发",
 							"path": "extension/native/develop/sink"
 						},
 						{
@@ -437,84 +511,113 @@
 				{
 					"title": "外部函数",
 					"path": "extension/external/external_func"
+				},
+				{
+					"title": "Wasm 函数 （beta）",
+					"path": "extension/wasm/overview"
 				}
 			]
 		},
 		{
-			"title": "使用指南",
+			"title": "SQL 参考",
 			"children": [
 				{
-					"title": "概览",
-					"path": "operation/overview"
-				},
-				{
-					"title": "安装",
+					"title": "语句",
 					"children": [
 						{
-							"title": "安装指南",
-							"path": "operation/install/overview"
+							"title": "流语句",
+							"path": "sqls/streams"
+						},
+						{
+							"title": "表语句",
+							"path": "sqls/tables"
 						},
 						{
-							"title": "centos 安装",
-							"path": "operation/install/cent-os"
+							"title": "查询语句",
+							"path": "sqls/query_language_elements"
 						}
 					]
 				},
 				{
-					"title": "配置",
+					"title": "语法",
 					"children": [
 						{
-							"title": "配置文件",
-							"path": "operation/config/configuration_file"
+							"title": "概览",
+							"path": "sqls/overview"
+						},
+						{
+							"title": "词汇元素",
+							"path": "sqls/lexical_elements"
+						},
+						{
+							"title": "数据类型",
+							"path": "sqls/data_types"
 						},
 						{
-							"title": "认证配置",
-							"path": "operation/config/authentication"
+							"title": "JSON 表达式",
+							"path": "sqls/json_expr"
 						}
 					]
 				},
 				{
+					"title": "内置函数",
+					"path": "sqls/built-in_functions"
+				},
+				{
+					"title": "预定义函数插件",
+					"path": "sqls/custom_functions"
+				},
+				{
+					"title": "窗口",
+					"path": "sqls/windows"
+				}
+			]
+		},
+		{
+			"title": "API 参考",
+			"children": [
+				{
 					"title": "Rest API 接口",
 					"children": [
 						{
 							"title": "接口介绍",
-							"path": "operation/restapi/overview"
+							"path": "api/restapi/overview"
 						},
 						{
 							"title": "流管理",
-							"path": "operation/restapi/streams"
+							"path": "api/restapi/streams"
 						},
 						{
 							"title": "表管理",
-							"path": "operation/restapi/tables"
+							"path": "api/restapi/tables"
 						},
 						{
 							"title": "规则管理",
-							"path": "operation/restapi/rules"
+							"path": "api/restapi/rules"
 						},
 						{
 							"title": "插件管理",
-							"path": "operation/restapi/plugins"
+							"path": "api/restapi/plugins"
 						},
 						{
 							"title": "外部函数管理",
-							"path": "operation/restapi/services"
+							"path": "api/restapi/services"
 						},
 						{
 							"title": "模式管理",
-							"path": "operation/restapi/schemas"
+							"path": "api/restapi/schemas"
 						},
 						{
 							"title": "上传文件管理",
-							"path": "operation/restapi/uploads"
+							"path": "api/restapi/uploads"
 						},
 						{
 							"title": "规则集管理",
-							"path": "operation/restapi/ruleset"
+							"path": "api/restapi/ruleset"
 						},
 						{
 							"title": "数据导入导出",
-							"path": "operation/restapi/configuration"
+							"path": "api/restapi/data"
 						}
 					]
 				},
@@ -523,65 +626,35 @@
 					"children": [
 						{
 							"title": "总览",
-							"path": "operation/cli/overview"
+							"path": "api/cli/overview"
 						},
 						{
 							"title": "流管理",
-							"path": "operation/cli/streams"
+							"path": "api/cli/streams"
 						},
 						{
 							"title": "表管理",
-							"path": "operation/cli/tables"
+							"path": "api/cli/tables"
 						},
 						{
 							"title": "规则管理",
-							"path": "operation/cli/rules"
+							"path": "api/cli/rules"
 						},
 						{
 							"title": "插件管理",
-							"path": "operation/cli/plugins"
+							"path": "api/cli/plugins"
 						},
 						{
 							"title": "模式管理",
-							"path": "operation/cli/schemas"
+							"path": "api/cli/schemas"
 						},
 						{
 							"title": "规则集管理",
-							"path": "operation/cli/ruleset"
+							"path": "api/cli/ruleset"
 						},
 						{
 							"title": "数据导入导出",
-							"path": "operation/cli/configuration"
-						}
-					]
-				},
-				{
-					"title": "管理控制台",
-					"children": [
-						{
-							"title": "控制台使用",
-							"path": "operation/manager-ui/overview"
-						},
-						{
-							"title": "插件管理",
-							"path": "operation/manager-ui/plugins_in_manager"
-						}
-					]
-				},
-				{
-					"title": "编译",
-					"children": [
-						{
-							"title": "编译指南",
-							"path": "operation/compile/compile"
-						},
-						{
-							"title": "交叉编译",
-							"path": "operation/compile/cross-compile"
-						},
-						{
-							"title": "按需编译",
-							"path": "features"
+							"path": "api/cli/configuration"
 						}
 					]
 				}

docs/zh_CN/configuration/configuration.md

@@ -0,0 +1,35 @@
+# Configuration
+
+eKuiper configuration is based on yaml file and allow to configure by updating the file, environment variable and REST API.
+
+## Configuration Scope
+
+eKuiper configurations include
+1. `etc/kuiper.yaml`: global configuration file. Make change to it need to restart the eKuiper instance. Please refer to [basic configuration file](./global_configurations.md) for detail.
+2. `etc/sources/${source_name}.yaml`: the configuration file for each source to define the default properties (except MQTT source, whose configuration file is `etc/mqtt_source.yaml`). Please refer to the doc for each source for detail. For example, [MQTT source](../guide/sources/builtin/mqtt.md) and [Neuron source](../guide/sources/builtin/neuron.md) covers the configuration items.
+3. `etc/connections/connection.yaml`: shared connection configuration file.
+
+## Configuration Methods
+
+Users can set the configuration through 3 methods order by precedence.
+
+1. Management Console/REST API
+2. Environment variables
+3. Yaml files in etc folder.
+
+The yaml files usually be used to set up the default configurations. It can be heavily use when deploy in bare metal and the user can access the file system easily.
+
+When deploying in docker or k8s, it is not easy enough to manipulate files, small amount of configurations can then be set or override by environment variables. And in runtime, end users will use management console to change the configurations dynamically. The `Configuration` page in the eKuiper manager can help users to modify the configurations visually.
+
+### Environment variable syntax
+
+There is a mapping from environment variable to the configuration yaml file. When modifying configuration through environment variables, the environment variables need to be set according to the prescribed format, for example:
+
+```
+KUIPER__BASIC__DEBUG => basic.debug in etc/kuiper.yaml
+MQTT_SOURCE__DEMO_CONF__QOS => demo_conf.qos in etc/mqtt_source.yaml
+EDGEX__DEFAULT__PORT => default.port in etc/sources/edgex.yaml
+CONNECTION__EDGEX__REDISMSGBUS__PORT => edgex.redismsgbus.port int etc/connections/connection.yaml
+```
+
+The environment variables are separated by "__", the content of the first part after the separation matches the file name of the configuration file, and the remaining content matches the different levels of the configuration items. The file name could be `KUIPER` and `MQTT_SOURCE` in the `etc` folder; or  `CONNECTION` in `etc/connection` folder. Otherwise, the file should in `etc/sources` folder.

docs/zh_CN/getting_started.md

@@ -1,204 +0,0 @@
-
-
-## 下载和安装
-
-通过 <https://github.com/lf-edge/ekuiper/releases>  获取安装包.
-
-### zip、tar.gz 压缩包
-
-解压缩 eKuiper
-
-```sh
-$ unzip kuiper-$VERISON-$OS-$ARCH.zip
-or
-$ tar -xzf kuiper-$VERISON-$OS-$ARCH.zip
-```
-
-运行 `bin/kuiperd` 以启动 eKuiper 服务器
-
-```sh
-$ bin/kuiperd
-```
- 您应该会看到一条成功的消息：`Serving Rule server on port 20498`
-
-eKuiper 的目录结构如下:
-
-```
-eKuiper_installed_dir
-  bin
-    kuiperd
-    kuiper
-  etc
-    mqtt_source.yaml
-    ...
-  data
-    ...
-  plugins
-    ...
-  log
-    ...
-```
-
-
-#### deb、rpm 安装包
-
-使用相关命令安装 eKuiper
-
-```sh
-$ sudo dpkg -i kuiper_$VERSION_$ARCH.deb
-or
-$ sudo rpm -ivh kuiper-$VERSION-1.el7.rpm
-```
-
-运行 `kuiperd` 以启动 eKuiper 服务器
-
-```sh
-$ sudo kuiperd
-```
- 您应该会看到一条成功的消息：`Serving Rule server on port 20498`
-
- kuiper 也支持 systemctl 启动
-
- ```sh
- $ sudo systemctl start kuiper
- ```
-
-eKuiper 的目录结构如下:
-
-```
-/usr/lib/kuiper/bin
-  kuiperd
-  kuiper
-/etc/kuiper
-  mqtt_source.yaml
-  ...
-/var/lib/kuiper/data
-  ...
-/var/lib/kuiper/plugins
-  ...
-/var/log/kuiper
-   ...
-```
-
-## 运行的第一个规则流
-
-eKuiper 规则由一个 SQL 和多个操作组成。 eKuiper SQL 是一种易于使用的类 SQL 语言，用于确定规则流的逻辑。 通过命令行提供规则，规则流将在规则引擎中创建并连续运行。用户之后可以通过命令行管理规则。
-
-eKuiper 具有许多用于复杂分析的内置函数和扩展，您可以访问 [eKuiper SQL 参考](sqls/overview.md)获取有关语法和其功能的更多信息。
-
-让我们考虑一个示例场景：我们正在通过 MQTT 服务从传感器接收温度和湿度记录，并且当温度在一个时间窗口中大于30摄氏度时，我们希望发出警报。 我们可以使用以下几个步骤为上述场景编写 eKuiper 规则。
-
-### 先决条件
-
-我们假设已经有一个 MQTT 消息服务器作为 eKuiper 服务器的数据源。 如果您没有，建议使用 EMQX。 请按照 [EMQ Broker 安装指南](https://docs.emqx.cn/cn/broker/latest/getting-started/install.html)设置 MQTT 消息服务器。
-
-### 定义输入流
-
-流需要具有一个名称和一个架构，以定义每个传入事件应包含的数据。 对于这种情况，我们将使用 MQTT 源应对温度事件。 输入流可以通过 SQL 语言定义。
-
-我们创建一个名为 `demo` 的流，该流使用 `DATASOURCE` 属性中指定的 MQTT `demo` 主题。
-```sh
-$ bin/kuiper create stream demo '(temperature float, humidity bigint) WITH (FORMAT="JSON", DATASOURCE="demo")'
-```
-MQTT 源将通过`tcp://localhost:1883`连接到 MQTT 消息服务器，如果您的 MQTT 消息服务器位于别的位置，请在`etc/mqtt_source.yaml`中进行指定。 您可以通过修改如下配置文件来更改配置。
-
-```yaml
-default:
-  qos: 1
-  sharedsubscription: true
-  server: "tcp://127.0.0.1:1883"
-```
-
-您可以使用`kuiper show streams` 命令来查看是否创建了 `demo` 流。
-
-### 通过查询工具测试流
-
-现在已经创建了流，可以通过 `kuiper query` 命令对其进行测试。键入`kuiper query`后，显示 `kuiper`提示符。
-
-```sh
-$ bin/kuiper query
-kuiper > 
-```
-
-在 `kuiper`提示符下，您可以键入 SQL 并根据流验证 SQL。
-
-```sh
-kuiper > select count(*), avg(humidity) as avg_hum, max(humidity) as max_hum from demo where temperature > 30 group by TUMBLINGWINDOW(ss, 5);
-
-query is submit successfully.
-```
-
-现在，如果有任何数据发布到位于`tcp://127.0.0.1:1883`的 MQTT 服务器，那么它打印如下消息。
-
-```
-kuiper > [{"avg_hum":41,"count":4,"max_hum":91}]
-[{"avg_hum":62,"count":5,"max_hum":96}]
-[{"avg_hum":36,"count":3,"max_hum":63}]
-[{"avg_hum":48,"count":3,"max_hum":71}]
-[{"avg_hum":40,"count":3,"max_hum":69}]
-[{"avg_hum":44,"count":4,"max_hum":57}]
-[{"avg_hum":42,"count":3,"max_hum":74}]
-[{"avg_hum":53,"count":3,"max_hum":81}]
-...
-```
-
-您可以按 `ctrl + c` 键中断查询，如果检测到客户端与查询断开连接，服务器将终止流传输。 以下是服务器上的日志打印。
-
-```
-...
-time="2019-09-09T21:46:54+08:00" level=info msg="The client seems no longer fetch the query result, stop the query now."
-time="2019-09-09T21:46:54+08:00" level=info msg="stop the query."
-...
-```
-
-### 编写规则
-
-作为规则的一部分，我们需要指定以下内容：
-* 规则名称：规则的 ID。 它必须是唯一的
-* sql：针对规则运行的查询
-* 动作：规则的输出动作
-
-我们可以运行 `kuiper rule` 命令来创建规则并在文件中指定规则定义
-
-```sh
-$ bin/kuiper create rule ruleDemo -f myRule
-```
-`myRule`文件的内容。 对于在1分钟内滚动时间窗口中的平均温度大于30的事件，它将打印到日志中。
-
-```json
-{
-    "sql": "SELECT temperature from demo where temperature > 30",
-    "actions": [{
-        "log":  {}
-    }]
-}
-```
-您应该在流日志中看到一条成功的消息` rule ruleDemo created`。 现在，规则已经建立并开始运行。
-
-### 测试规则
-现在，规则引擎已准备就绪，可以接收来自 MQTT `demo` 主题的事件。 要对其进行测试，只需使用 MQTT 客户端将消息发布到 `demo` 主题即可。 该消息应为 json 格式，如下所示：
-
-```json
-{"temperature":31.2, "humidity": 77}
-```
-
-检查位于“ `log/stream.log`”的流日志，您会看到已过滤的数据被打印出来。 另外，如果您发送以下消息，则它不符合 SQL 条件，并且该消息将被过滤。
-
-```json
-{"temperature":29, "humidity": 80}
-```
-
-### 管理规则
-您可以使用命令行暂停规则一段时间，然后重新启动规则和其他管理工作。 规则名称是规则的标识符。 查看[规则管理 CLI](rules/overview.md) 以了解详细信息
-
-```sh
-$ bin/kuiper stop rule ruleDemo
-```
-
-
-请参考以下主题，以获取有关使用 eKuiper 的指导。
-- [命令行界面工具 CLI](operation/cli/overview.md)
-- [eKuiper SQL 参考](./sqls/overview.md)
-- [规则](./rules/overview.md)
-- [扩展 eKuiper](./extension/overview.md)
-- [插件](extension/native/develop/overview.md)

docs/zh_CN/getting_started/getting_started.md

@@ -0,0 +1,216 @@
+# Getting Started
+
+Starting from download and installation, this document will guide you to start eKuiper and run the first rule.
+
+## Install eKuiper
+
+eKuiper provides docker image, binary package and helm chart to install. 
+
+In this tutorial, we provide both web UI and CLI to create and manage the rules. If you want to run the eKuiper manager which is the web management console for eKuiper, please refer to [running eKuiper with management console](../installation.md#running-ekuiper-with-management-console).
+
+### Running in docker
+
+Docker deployment is the fastest way to start experimenting with eKuiper. 
+
+```shell
+docker run -p 9081:9081 -d --name kuiper -e MQTT_SOURCE__DEFAULT__SERVER="tcp://broker.emqx.io:1883" lfedge/ekuiper:$tag
+```
+
+For more information about docker installation, please refer to [running eKuiper in docker](../installation.md#running-ekuiper-in-docker).
+
+### Running in Kubernetes
+
+For Kubernetes, eKuiper offers helm chart. Please refer to [install via helm](../installation.md#install-via-helm--k8sk3s-) for detail.
+
+### Running in a VM or on bare metal
+
+eKuiper can be deployed directly to bare metal servers or virtual machines.
+
+eKuiper has prebuilt packages downloadable for Linux such as CentOS, Debian and Ubuntu and macOS. You can [install from zip](../installation.md#install-from-zip) or [from packages](../installation.md#install-from-package).
+
+For other platforms, you may [build the runnable from source code](../installation.md#compilation).
+
+## Create and manage the first rule
+
+As a rule engine, eKuiper allows the user to submit stream processing job aka. rules and manage rules through CLI, REST API or management console. In this tutorial, we will walk you through the rule creation and management by management console and CLI respectively.
+
+eKuiper rule is composed by a SQL and multiple actions. eKuiper SQL is an easy to use SQL-like language to specify the logic of a rule. eKuiper has a lot of built-in functions and extensions available for complex analysis to be used in your SQL. You can find more information about the syntax and its functions from the [eKuiper SQL reference](../sqls/overview.md).
+
+### Prerequisite
+
+We assume there is already a MQTT broker as the data source of our eKuiper rule. If you don't have one, EMQX is recommended. Please follow the [EMQ Installation Guide](https://docs.emqx.io/en/broker/latest/getting-started/install.html) to set up a mqtt broker.
+
+You can also use the public MQTT test server `tcp://broker.emqx.io:1883` hosted by [EMQ](https://www.emqx.io).
+
+Remember your broker address, we will use it in our MQTT configurations in this tutorial.
+
+### Scenario
+
+Let's consider a sample scenario where we are receiving temperature and humidity event from a sensor through MQTT service, and we want to issue an alert when the average temperature is bigger than 30 degree Celsius in a time window. We can write an eKuiper rule for the above scenario using the following several steps.
+
+1. Create a stream to define the data source that we want to proceed. The stream needs to have a name and an optional schema defining the data structure that each incoming event should contain. For this scenario, we will use an MQTT source to consume temperature events.
+2. Create the rule to define how to proceed the stream and the actions after proceed.
+3. Get the rule status and manage it like start, stop and delete.
+
+We will do these steps in management console and CLI respectively to create the same rule.
+
+### Management console
+
+Please make sure eKuiper manager has installed and configured.
+
+### Defining the stream
+
+1. In Source/Stream page, click `Create stream` button.
+2. Create a stream named `demo` which consumes MQTT `demo` topic as specified in the DATASOURCE property. The MQTT source will connect to MQTT broker at `tcp://localhost:1883`. If your MQTT broker is in another location, click `Add configuration key` to set up a new configuration and use.
+    ![create stream](../resources/create_stream.png)
+3. Click `Submit`. You should find the `demo` stream in the stream list.
+
+### Compose the rule
+
+1. Go to Rules page, click `Create rule`.
+2. Write the rule id, name and SQL as below. Then click `Add` to add actions. The SQL is `SELECT count(*), avg(temperature) AS avg_temp, max(humidity) AS max_hum FROM demo GROUP BY TUMBLINGWINDOW(ss, 5) HAVING avg_temp > 30`.
+![create rule](../resources/create_rule.png)
+3. Add MQTT action and fill in the configurations as below. Select `mqtt` in the Sink type dropdown. Set the broker address to your broker and set the topic to `result/rule1`. ClientID is optional, if not set an uuid will assign to it. If set, please make sure the id is unique and only use in one rule. Set the other properties like username, password according to your MQTT broker setting.
+![add mqtt action](../resources/mqtt_action.png)
+4. Click `Submit`. You should find the `myRule` rule in the rule list and started.
+
+By now, we have created a rule by specifying SQL as the logic, and add one MQTT action. As you could see, the actions could be multiple, you can add more actions like log, REST and file to issue the alarm.
+
+### Manage the rule
+
+In the Rules page, we could find all the created rules and its status as below.
+
+![rule list](../resources/rule_list.png)
+
+You can start or stop the rule by touching the switch button. In the Operations column, the second operation is status, which will show the running status and [metrics](../operation/usage/monitor_with_prometheus.md) of the rule. Once the data source has data in, you should find the metrics number rising.
+
+![rule status](../resources/rule_status.png)
+
+You can edit, duplicate and delete the rules by clicking the button in the Operations column.
+
+### CLI
+
+eKuiper provide CLI binary after installation. It is used to run locally without any external tools to manage the rule engine.
+
+### Defining the stream
+
+We create a stream named `demo` which consumes MQTT `demo` topic as specified in the DATASOURCE property.
+
+```sh
+$ bin/kuiper create stream demo '(temperature float, humidity bigint) WITH (FORMAT="JSON", DATASOURCE="demo")'
+```
+
+The MQTT source will connect to MQTT broker at `tcp://localhost:1883`. If your MQTT broker is in another location, specify it in the `etc/mqtt_source.yaml`.  You can change the server configuration as in below.
+
+```yaml
+default:
+  qos: 1
+  sharedsubscription: true
+  server: "tcp://127.0.0.1:1883"
+```
+
+You can use command `kuiper show streams` to see if the `demo` stream was created or not.
+
+### Testing the stream through query tool
+
+Now the stream is created, it can be tested from `kuiper query` command. The `kuiper` prompt is displayed as below after typing `cli query`.
+
+```sh
+$ bin/kuiper query
+kuiper > 
+```
+
+In the `kuiper` prompt, you can type SQL and validate the SQL against the stream.
+
+```sh
+kuiper > select count(*), avg(humidity) as avg_hum, max(humidity) as max_hum from demo where temperature > 30 group by TUMBLINGWINDOW(ss, 5);
+
+query is submit successfully.
+```
+
+Now if any data are published to the MQTT server available at `tcp://127.0.0.1:1883`, then it prints message as following.
+
+```
+kuiper > [{"avg_hum":41,"count":4,"max_hum":91}]
+[{"avg_hum":62,"count":5,"max_hum":96}]
+[{"avg_hum":36,"count":3,"max_hum":63}]
+[{"avg_hum":48,"count":3,"max_hum":71}]
+[{"avg_hum":40,"count":3,"max_hum":69}]
+[{"avg_hum":44,"count":4,"max_hum":57}]
+[{"avg_hum":42,"count":3,"max_hum":74}]
+[{"avg_hum":53,"count":3,"max_hum":81}]
+...
+```
+
+You can press `ctrl + c` to break the query, and server will terminate streaming if detecting client disconnects from the query. Below is the log print at server.
+
+```
+...
+time="2019-09-09T21:46:54+08:00" level=info msg="The client seems no longer fetch the query result, stop the query now."
+time="2019-09-09T21:46:54+08:00" level=info msg="stop the query."
+...
+```
+
+### Writing the rule
+
+As part of the rule, we need to specify the following:
+* rule id: the id of the rule. It must be unique
+* rule name: the description of the rule
+* sql: the query to run for the rule
+* actions: the output actions for the rule
+
+We can run the `kuiper rule` command to create rule and specify the rule definition in a file
+
+```sh
+$ bin/kuiper create rule myRule -f myRule
+```
+
+The content of `myRule` file as below. It publishes the result to the mqtt topic `result/myRule` when the average temperature in a 5-second tumbling window is bigger than 30.
+
+```json
+{
+    "sql": "SELECT count(*), avg(temperature) as avg_temp, max(humidity) as max_hum from demo group by TUMBLINGWINDOW(ss, 5) HAVING avg_temp > 30;",
+    "actions": [{
+        "mqtt":  {
+          "server": "tcp://127.0.0.1:1883",
+          "topic": "result/myRule",
+          "sendSingle": true
+        }
+    }]
+}
+```
+You should see a successful message `rule myRule created` in the stream log, and the rule is now set up and running.
+
+### Managing the rules
+
+You can use command line tool to stop the rule for a while and restart it and other management work. The rule name is the identifier of a rule. 
+
+```sh
+$ bin/kuiper stop rule myRule
+```
+
+## Testing the rule
+
+Now the rule engine is ready to receive events from MQTT `demo`  topic. To test it, just use a MQTT client such as [MQTT X](https://mqttx.app/) to publish message to the `demo` topic. The message should be in json format like this:
+
+```json
+{"temperature":31.2, "humidity": 77}
+```
+
+Since we publish the alarm to MQTT topic `result/myRule`, we can use a MQTT client to subscribe to the topic. We should receive message if the 5-second average temperature is bigger than 30.
+
+Below is an example data and the output in MQTT X.
+
+![result](../resources/result.png)
+
+## Further Reading
+
+Refer to the following topics for guidance on using the eKuiper.
+
+- [Installation](../installation.md)
+- [Rules](../guide/rules/overview.md)
+- [SQL reference](../sqls/overview.md)
+- [Stream](../guide/streams/overview.md)
+- [Sink](../guide/sinks/overview.md)
+- [Command line interface tools - CLI](../api/cli/overview.md)
+- [Management Console](../guide/rules/overview.md)

docs/zh_CN/guide/tables/overview.md

@@ -0,0 +1,54 @@
+# Table
+
+eKuiper streams is unbounded and immutable, any new data are appended in the current stream for processing.  **Table** is provided to represent the current state of the stream. It can be considered as a snapshot of the stream. Users can use table to retain a batch of data for processing.
+
+There are two kinds of table:
+
+- Scan table: accumulates the data in memory. It is suitable for smaller dataset and the table content do NOT need to share between rules.
+- Lookup table: refer to external table content. It is suitable for bigger dataset and share table content across rules.
+
+## Syntax
+
+Table supports almost the same syntax as streams. To create a table, run the below SQL:
+
+```sql
+CREATE TABLE   
+    table_name   
+    ( column_name <data_type> [ ,...n ] )
+    WITH ( property_name = expression [, ...] );
+```
+
+Table supports the same [data types](../streams/overview.md#data-types) as stream.
+
+Table also supports all [the properties of the stream](../streams/overview.md#stream-properties). Thus, all the source type are also supported in table. Many sources are not batched which have one event at any given time point, which means the table will always have only one event. An additional property `RETAIN_SIZE` to specify the size of the table snapshot so that the table can hold an arbitrary amount of history data.
+
+### Lookup Table Syntax
+
+The syntax is the same as creating a normal scan table, just need to specify kind property to be `lookup`. Below is an example to create a lookup data, which binds to redis database 0.
+
+```sql
+CREATE TABLE alertTable() WITH (DATASOURCE="0", TYPE="redis", KIND="lookup")
+```
+
+Currently, only `memory`, `redis` and `sql` source can be lookup table.
+
+### Table properties
+
+| Property name | Optional | Description                                                                                                                                                    |
+|---------------|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| DATASOURCE    | false    | The value is determined by source type. The topic names list if it's a MQTT data source. Please refer to related document for other sources.                   |
+| FORMAT        | true     | The data format, currently the value can be "JSON", "PROTOBUF" and "BINARY". The default is "JSON". Check [Binary Stream](#binary-stream) for more detail.     |
+| SCHEMAID      | true     | The schema to be used when decoding the events. Currently, only use when format is PROTOBUF.                                                                   |
+| KEY           | true     | The primary key of the table. For example, for SQL source key specifies the primary key in the SQL table. It is not obeyed by all source types.                |
+| TYPE          | true     | The source type. Each source type may support one kind or both kind of tables. Please refer to related documents.                                              |
+| CONF_KEY      | true     | If additional configuration items are requied to be configured, then specify the config key here. See [MQTT stream](../sources/builtin/mqtt.md) for more info. |
+| KIND          | true     | The table kind, could be `scan` or `lookup`. If not specified, the default value is `scan`.                                                                    |
+
+
+## Usage scenarios
+
+Table is a way to keep a large bunch of state for both scan and lookup type. Scan table keeps state in memory while lookup table keeps them externally and possibly persisted. Scan table is easier to set up while lookup table can easily connect to existed persisted states. Both types are suitable for stream batch integrated calculation.
+
+Please check below links for some typical scenarios.
+- [Scan table scenarios](scan.md)
+- [Lookup table scenarios](lookup.md)

docs/zh_CN/guide/tables/scan.md

@@ -0,0 +1,52 @@
+# Scan Table Scenarios
+
+Typically, table will be joined with stream with or without a window. When joining with stream, table data won't affect the downstream data, it is treated like a static referenced data, although it may be updated internally.
+
+## Enrich data
+
+A typical usage for table is as a lookup table. Sample SQL will be like:
+
+```sql
+CREATE TABLE table1 (
+		id BIGINT,
+		name STRING
+	) WITH (DATASOURCE="lookup.json", FORMAT="JSON", TYPE="file");
+
+SELECT * FROM demo INNER JOIN table1 on demo.id = table1.id
+```
+
+In this example, a table `table1` is created to read json data from file *lookup.json*. Then in the rule, `table1` is joined with the stream `demo` so that the stream can lookup the name from the id.
+
+The content of *lookup.json* file should be an array of objects. Below is an example:
+
+```json
+[
+  {
+    "id": 1541152486013,
+    "name": "name1"
+  },
+  {
+    "id": 1541152487632,
+    "name": "name2"
+  },
+  {
+    "id": 1541152489252,
+    "name": "name3"
+  }
+]
+```
+
+## Filter by history state
+
+In some scenario, we may have an event stream for data and another event stream as the control information.
+
+```sql
+CREATE TABLE stateTable (
+		id BIGINT,
+		triggered bool
+	) WITH (DATASOURCE="myTopic", FORMAT="JSON", TYPE="mqtt");
+
+SELECT * FROM demo LEFT JOIN stateTable on demo.id = stateTable.id  WHERE triggered=true
+```
+
+In this example, a table `stateTable` is created to record the trigger state from mqtt topic *myTopic*. In the rule, the data of `demo` stream is filtered with the current trigger state.

docs/zh_CN/installation.md

@@ -0,0 +1,230 @@
+# Installation
+
+eKuiper provides docker image, binary packages and helm chart to install.
+
+## Running eKuiper in Docker
+
+Please make sure docker has installed before running.
+
+1. Get docker image.
+   ```shell
+   docker pull lfedge/ekuiper:x.x.x
+   ```
+2. Start docker container.
+   ```shell
+   docker run -p 9081:9081 -d --name kuiper -e MQTT_SOURCE__DEFAULT__SERVER=tcp://broker.emqx.io:1883 lfedge/ekuiper:xxx
+   ```
+
+In this example, we specify the default MQTT broker via environment variable to `broker.emqx.io`, which is a public MQTT test server hosted by [EMQ](https://www.emqx.io).
+
+For more configuration and docker image tags, please check [lfedge/ekuiper in docker hub](https://hub.docker.com/r/lfedge/ekuiper).
+
+## Running eKuiper with management console
+
+eKuiper manager is a free eKuiper management web console which is provided as a docker image. We can use docker compose to run both eKuiper and eKuiper manager at once to ease the usage.
+
+Please make sure docker compose has installed before running.
+
+1. Create `docker-compose.yaml` file.
+   ```yaml
+   version: '3.4'
+
+   services:
+   manager:
+      image: emqx/ekuiper-manager:x.x.x
+      container_name: ekuiper-manager
+      ports:
+      - "9082:9082"
+      restart: unless-stopped
+   ekuiper:
+      image: lfedge/ekuiper:x.x.x
+      ports:
+        - "9081:9081"
+        - "127.0.0.1:20498:20498"
+      container_name: ekuiper
+      hostname: ekuiper
+      restart: unless-stopped
+      user: root
+      volumes:
+        - /tmp/data:/kuiper/data
+        - /tmp/log:/kuiper/log
+        - /tmp/plugins:/kuiper/plugins
+      environment:
+        MQTT_SOURCE__DEFAULT__SERVER: "tcp://broker.emqx.io:1883"
+        KUIPER__BASIC__CONSOLELOG: "true"
+        KUIPER__BASIC__IGNORECASE: "false"
+     ```
+2. Start docker-compose cluster.
+   ```shell
+   $ docker-compose -p my_ekuiper up -d
+   ```
+3. Check docker images running status, make sure two continers are started.
+   ```shell
+   $ docker ps
+   CONTAINER ID   IMAGE                         COMMAND                  CREATED              STATUS                  PORTS                                                NAMES
+   e2dbcd4c1f92   lfedge/ekuiper:latest          "/usr/bin/docker-ent…"   7 seconds ago        Up Less than a second   0.0.0.0:9081->9081/tcp, 127.0.0.1:20498->20498/tcp   ekuiper
+   fa7c33b3e114   emqx/ekuiper-manager:latest   "/usr/bin/docker-ent…"   About a minute ago   Up 59 seconds           0.0.0.0:9082->9082/tcp                               manager
+   ```
+
+Please check [use of eKuiper management console](./operation/manager-ui/overview.md) to set up and configure the eKuiper manager.
+
+## Install From Zip
+
+eKuiper binary packages are released on below operating systems with AMD64, ARM and ARM64 support:
+
+- CentOS 7 (EL7)
+- CentOS 8 (EL8)
+- Raspbian 10
+- Debian 9
+- Debian 10
+- Ubuntu 16.04
+- Ubuntu 18.04
+- Ubuntu 20.04
+- macOS
+
+For other operating systems such as Windows, users can [compile from source code manually](#compilation).
+
+1. Download eKuiper zip or tar for your CPU architecture from [ekuiper.org](https://ekuiper.org/downloads) or [Github](https://github.com/lf-edge/ekuiper/releases).
+2. Unzip the installation file:
+    ```shell
+    unzip kuiper-x.x.x-linux-amd64.zip
+    ```
+3. Start eKuiper.
+    ```shell
+    $ bin/kuiperd
+    ```
+4. Remove eKuiper. Simply delete the eKuiper directory.
+
+After installation, all the files are inside the unzipped directory. Please check [installed directory structure](#installation-structure) for detail.
+    
+
+## Install from package
+
+1. Download eKuiper package for your CPU architecture from [ekuiper.org](https://ekuiper.org/downloads) or [Github](https://github.com/lf-edge/ekuiper/releases).
+2. Install eKuiper.
+   - DEB package:
+     ```shell
+     # for debian/ubuntu
+     $ sudo apt install ./kuiper-x.x.x-linux-amd64.deb
+     ```   
+   - RPM package:
+     ```shell
+     # for CentOS
+     $ sudo rpm -ivh kuiper-x.x.x-linux-amd64.rpm
+     ```   
+3. Start eKuiper.
+   - quick start
+     ```shell
+     $ sudo kuiperd
+     ```   
+   - systemctl
+     ```shell
+     sudo systemctl start kuiper
+     ```
+4. Remove eKuiper.
+   - DEB:
+     ```shell
+     sudo apt remove --purge kuiper
+     ```
+   - RPM:
+     ```shell
+     sudo yum remove kuiper
+     ```
+     
+When installing by package, the eKuiper folders are not in the same directory. The installation structure is as below:
+
+```
+/usr/lib/kuiper/bin
+  kuiperd
+  kuiper
+/etc/kuiper
+  ...
+/var/lib/kuiper/data
+  ...
+/var/lib/kuiper/plugins
+  ...
+/var/log/kuiper
+   ...
+```
+
+## Install via Helm (K8S、K3S)
+
+1. Add helm repository.
+   ```shell
+    $ helm repo add emqx https://repos.emqx.io/charts
+    $ helm repo update
+   ```
+2. Query eKuiper.
+   ```shell
+    $ helm search repo emqx
+    NAME         CHART VERSION APP VERSION DESCRIPTION
+    emqx/emqx    v4.0.0        v4.0.0      A Helm chart for EMQX
+    emqx/emqx-ee v4.0.0        v4.0.0      A Helm chart for EMQX
+    emqx/ekuiper  0.1.1         0.1.1       A lightweight IoT edge analytic software
+   ```
+3. Start eKuiper.
+   ```shell
+    $ helm install my-ekuiper emqx/ekuiper
+   ``` 
+4. View eKuiper status.
+   ```shell
+   $ kubectl get pods
+   NAME         READY  STATUS    RESTARTS  AGE
+   my-ekuiper-0 1/1    Running   0         56s
+   ```
+
+## Compile from source code
+
+1. Get the source code.
+   ```shell
+   $ git clone https://github.com/lf-edge/ekuiper.git
+   ```
+2. Compile. 
+   ```shell
+   $ make
+   ```
+3. Start eKuiper.
+   ```shell
+   $ cd _build/kuiper-x.x.x-linux-amd64/
+   $ bin/kuiperd
+   ```
+   
+eKuiper allows to tailor the binary in compilation to get a customized feature set. As written by go, it also allows cross compilation. For detail, please check [compilation](./operation/compile/compile.md).
+
+## Installation structure
+
+Below is the directory structure after installation.
+
+```shell
+bin
+  kuiperd
+  kuiper
+etc
+  ...
+data
+  ...
+plugins
+  ...
+log
+  ...
+```
+
+### bin
+
+The `bin` directory includes all of executable files. Such as the kuiper server `kuiperd` and the cli client `kuiper`.
+
+### etc
+
+The `etc` directory contains the default configuration files of eKuiper. Such as the global configuration file `kuiper.yaml` and all the source configuration files such as `mqtt_source.yaml`.
+
+### data
+
+This folder saves the persisted definitions of streams and rules. It also contains any user defined configurations.
+
+### plugins
+
+eKuiper allows users to develop your own plugins, and put these plugins into this folder.  See [extension](./extension/overview.md) for more info for how to extend the eKuiper.
+
+### log
+
+All the log files are under this folder. The default log file name is `stream.log`.

docs/zh_CN/integrations/edge_cloud/overview.md

@@ -0,0 +1,17 @@
+# Edge Cloud Collaboration
+
+Base on open source products, we can build an edge cloud collaboration solution to apply on IIoT(Industrial Internet of Things), IoV(Internet of Vehicles) and other IoT applications like smart city.
+
+![Edge Cloud Collaboration](../resources/edge_cloud.png)
+
+In this solution, eKuiper is integrated with the below open source products:
+
+- [Neuron](https://neugates.io/): lightweight IIoT connectivity server
+- [NanoMQ](https://nanomq.io/): An ultra-lightweight and blazing-fast MQTT broker for IoT Edge
+- [EMQX](https://www.emqx.io/): The Most Scalable MQTT Broker for IoT
+
+The solution realizes the connection, movement, processing, storage and analysis of massive industrial equipment data.
+
+eKuiper is deployed on the edge side and acts in the middle of the overall architecture for stream processing, rule engine and message routing etc. It can consume data from Neuron, NanoMQ or general HTTP on the edge, process or analyze them and publish the result to EMQX in the cloud or save them to the local storage.
+
+For detail about how to consume data collected by neuron, please check [neuron integration tutorial](../neuron/neuron_integration_tutorial.md).

docs/zh_CN/integrations/kubeedge/overview.md

@@ -0,0 +1,11 @@
+# Analytic Engine for KubeEdge
+
+[KubeEdge](https://kubeedge.io/) is an open-source system for extending native containerized application orchestration capabilities to hosts at Edge.
+
+![arch](./arch.png)
+
+As a kubernetes compliance system, KubeEdge enables the containerized deployment of the eKuiper instance. Please check [installation](../../installation.md#install-via-helm--k8sk3s-) for how to install eKuiper in k8s system.
+
+The Edge part of KubeEdge uses MQTT for communication between deviceTwin and devices. To use KubeEdge in double mqtt or external mode, users can configure the MQTT broker to be NanoMQ in the edge node.
+
+Follow up, eKuiper can ingest device data from MQTT and provides versatile analytic capabilities for the KubeEdge components to achieve low latency calculation on edge.

docs/zh_CN/operation/config/authentication.md

@@ -1,45 +0,0 @@
-## Authentication
-
-如果使能的话， eKuiper 从 1.4.0 起将为 RESTful API 提供基于 `JWT RSA256` 的身份验证。用户需要将他们的公钥放在 `etc/mgmt` 文件夹中，并使用相应的私钥来签署 JWT 令牌。
-当用户请求 RESTful API 时，将 `Token` 放在 http 请求头中，格式如下：
-```
-Authorization：XXXXXXXXXXXXXXX
-```
-如果token正确，eKuiper会响应结果；否则，它将返回 http `401` 代码。
-
-
-### JWT Header
-
-```json
-{
-  "typ": "JWT",
-  "alg": "RS256"
-}
-```
-
-
-### JWT Payload
-JWT Payload 应使用以下格式
-
-| 字段  | 是否可选 | 意义                                    |
-|-----|------|---------------------------------------|
-| iss | 否    | 颁发者 ,  此字段必须与`etc/mgmt`目录中的相应公钥文件名字一致 |
-| aud | 否    | 颁发对象 , 此字段必须是 `eKuiper`               |
-| exp | 是    | 过期时间                                  |
-| jti | 是    | JWT ID                                |
-| iat | 是    | 颁发时间                                  |
-| nbf | 是    | Not Before                            |
-| sub | 是    | 主题                                    |
-
-这里有一个 json 格式的例子
-```json
-{
-  "iss": "sample_key.pub",
-  "adu": "eKuiper"
-}
-```
-使用此格式时，用户必须确保正确的公钥文件 `sample_key.pub` 位于 `etc/mgmt` 下。
-
-### JWT Signature
-
-需要使用私钥对令牌进行签名，并将相应的公钥放在 `etc/mgmt` 中。