Merge pull request #2 from didi/master

merge didi logi-km
2025-12-24 11:52:08 +08:00 · 2021-03-09 11:07:17 +08:00
parent 9aefc55534 3695b4363d
commit fcb85ff4be
217 changed files with 4325 additions and 1357 deletions
--- a/README.md
+++ b/README.md
@@ -5,66 +5,89 @@

 **一站式`Apache Kafka`集群指标监控与运维管控平台**

--- 
-
-## 主要功能特性
-
-### 快速体验
- 体验地址 http://117.51.146.109:8080 账号密码 admin/admin
-
-### 集群监控维度
-
- 多版本集群管控，支持从`0.10.2`到`2.x`版本；
- 集群Topic、Broker等多维度历史与实时关键指标查看；


-### 集群管控维度
-
- 集群运维，包括逻辑Region方式管理集群
- Broker运维，包括优先副本选举
- Topic运维，包括创建、查询、扩容、修改属性、数据采样及迁移等；
- 消费组运维，包括指定时间或指定偏移两种方式进行重置消费偏移
+阅读本README文档，您可以了解到滴滴Logi-KafkaManager的用户群体、产品定位等信息，并通过体验地址，快速体验Kafka集群指标监控与运维管控的全流程。<br>若滴滴Logi-KafkaManager已在贵司的生产环境进行使用，并想要获得官方更好地支持和指导，可以通过[`OCE认证`](http://obsuite.didiyun.com/open/openAuth)，加入官方交流平台。


-### 用户使用维度
+## 1 产品简介
+滴滴Logi-KafkaManager脱胎于滴滴内部多年的Kafka运营实践经验，是面向Kafka用户、Kafka运维人员打造的共享多租户Kafka云平台。专注于Kafka运维管控、监控告警、资源治理等核心场景，经历过大规模集群、海量大数据的考验。内部满意度高达90%的同时，还与多家知名企业达成商业化合作。

- Kafka用户、Kafka研发、Kafka运维 视角区分
- Kafka用户、Kafka研发、Kafka运维 权限区分
+### 1.1 快速体验地址
+- 体验地址 http://117.51.146.109:8080  账号密码 admin/admin
+
+### 1.2 体验地图
+相比较于同类产品的用户视角单一（大多为管理员视角），滴滴Logi-KafkaManager建立了基于分角色、多场景视角的体验地图。分别是：**用户体验地图、运维体验地图、运营体验地图**
+
+#### 1.2.1 用户体验地图
+- 平台租户申请&nbsp;&nbsp;：申请应用（App）作为Kafka中的用户名，并用 AppID+password作为身份验证
+- 集群资源申请&nbsp;&nbsp;：按需申请、按需使用。可使用平台提供的共享集群，也可为应用申请独立的集群
+- Topic&nbsp;&nbsp;&nbsp;申&nbsp;&nbsp;&nbsp;请&nbsp;&nbsp;：可根据应用（App）创建Topic，或者申请其他topic的读写权限
+- Topic&nbsp;&nbsp;&nbsp;运&nbsp;&nbsp;&nbsp;维&nbsp;&nbsp;：Topic数据采样、调整配额、申请分区等操作
+- 指&nbsp;&nbsp;&nbsp;标&nbsp;&nbsp;监&nbsp;&nbsp;&nbsp;控&nbsp;&nbsp;：基于Topic生产消费各环节耗时统计，监控不同分位数性能指标
+- 消&nbsp;费&nbsp;组&nbsp;运&nbsp;维&nbsp;：支持将消费偏移重置至指定时间或指定位置
+
+#### 1.2.2 运维体验地图
+- 多版本集群管控&nbsp;&nbsp;：支持从`0.10.2`到`2.x`版本
+- 集&nbsp;&nbsp;&nbsp;&nbsp;群&nbsp;&nbsp;&nbsp;&nbsp;监&nbsp;&nbsp;&nbsp;控&nbsp;&nbsp;：集群Topic、Broker等多维度历史与实时关键指标查看，建立健康分体系
+- 集&nbsp;&nbsp;&nbsp;&nbsp;群&nbsp;&nbsp;&nbsp;&nbsp;运&nbsp;&nbsp;&nbsp;维&nbsp;&nbsp;：划分部分Broker作为Region，使用Region定义资源划分单位，并按照业务、保障能力区分逻辑集群
+- Broker&nbsp;&nbsp;&nbsp;&nbsp;运&nbsp;&nbsp;&nbsp;&nbsp;维&nbsp;&nbsp;：包括优先副本选举等操作
+- Topic&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;运&nbsp;&nbsp;&nbsp;&nbsp;维&nbsp;&nbsp;：包括创建、查询、扩容、修改属性、迁移、下线等


-## kafka-manager架构图
+#### 1.2.3 运营体验地图
+- 资&nbsp;&nbsp;源&nbsp;&nbsp;治&nbsp;&nbsp;理&nbsp;&nbsp;：沉淀资源治理方法。针对Topic分区热点、分区不足等高频常见问题，沉淀资源治理方法，实现资源治理专家化
+- 资&nbsp;&nbsp;源&nbsp;&nbsp;审&nbsp;&nbsp;批&nbsp;&nbsp;：工单体系。Topic创建、调整配额、申请分区等操作，由专业运维人员审批，规范资源使用，保障平台平稳运行
+- 账&nbsp;&nbsp;单&nbsp;&nbsp;体&nbsp;&nbsp;系&nbsp;&nbsp;：成本控制。Topic资源、集群资源按需申请、按需使用。根据流量核算费用，帮助企业建设大数据成本核算体系
+
+### 1.3 核心优势
+- 高&nbsp;效&nbsp;的&nbsp;问&nbsp;题&nbsp;定&nbsp;位&nbsp;&nbsp;：监控多项核心指标，统计不同分位数据，提供种类丰富的指标监控报表，帮助用户、运维人员快速高效定位问题
+- 便&nbsp;捷&nbsp;的&nbsp;集&nbsp;群&nbsp;运&nbsp;维&nbsp;&nbsp;：按照Region定义集群资源划分单位，将逻辑集群根据保障等级划分。在方便资源隔离、提高扩展能力的同时，实现对服务端的强管控
+- 专&nbsp;业&nbsp;的&nbsp;资&nbsp;源&nbsp;治&nbsp;理&nbsp;&nbsp;：基于滴滴内部多年运营实践，沉淀资源治理方法，建立健康分体系。针对Topic分区热点、分区不足等高频常见问题，实现资源治理专家化
+- 友&nbsp;好&nbsp;的&nbsp;运&nbsp;维&nbsp;生&nbsp;态&nbsp;&nbsp;：与滴滴夜莺监控告警系统打通，集成监控告警、集群部署、集群升级等能力。形成运维生态，凝练专家服务，使运维更高效
+
+### 1.4 滴滴Logi-KafkaManager架构图

 ![kafka-manager-arch](https://img-ys011.didistatic.com/static/dicloudpub/do1_xgDHNDLj2ChKxctSuf72)


-## 相关文档
+## 2 相关文档

- [kafka-manager 安装手册](docs/install_guide/install_guide_cn.md)
- [kafka-manager 接入集群](docs/user_guide/add_cluster/add_cluster.md)
- [kafka-manager 用户使用手册](docs/user_guide/user_guide_cn.md)
- [kafka-manager FAQ](docs/user_guide/faq.md)
+### 2.1 产品文档
+- [滴滴Logi-KafkaManager 安装手册](docs/install_guide/install_guide_cn.md)
+- [滴滴Logi-KafkaManager 接入集群](docs/user_guide/add_cluster/add_cluster.md)
+- [滴滴Logi-KafkaManager 用户使用手册](docs/user_guide/user_guide_cn.md)
+- [滴滴Logi-KafkaManager FAQ](docs/user_guide/faq.md)

-## 钉钉交流群
+### 2.2 社区文章
+- [滴滴云官网产品介绍](https://www.didiyun.com/production/logi-KafkaManager.html)
+- [7年沉淀之作--滴滴Logi日志服务套件](https://mp.weixin.qq.com/s/-KQp-Qo3WKEOc9wIR2iFnw)
+- [滴滴Logi-KafkaManager 一站式Kafka监控与管控平台](https://mp.weixin.qq.com/s/9qSZIkqCnU6u9nLMvOOjIQ)
+- [滴滴Logi-KafkaManager 开源之路](https://xie.infoq.cn/article/0223091a99e697412073c0d64)
+- [滴滴Logi-KafkaManager 系列视频教程](https://mp.weixin.qq.com/s/9X7gH0tptHPtfjPPSdGO8g)
+- [kafka实践（十五）：滴滴开源Kafka管控平台 Logi-KafkaManager研究--A叶子叶来](https://blog.csdn.net/yezonggang/article/details/113106244)

-![dingding_group](./docs/assets/images/common/dingding_group.jpg)
+## 3 滴滴Logi开源用户钉钉交流群
+
+![dingding_group](./docs/assets/images/common/dingding_group.jpg)  
  钉钉群ID：32821440
  
-## OCE认证
-OCE是一个认证机制和交流平台，为Logi-KafkaManager生产用户量身打造，我们会为OCE企业提供更好的技术支持，比如专属的技术沙龙、企业一对一的交流机会、专属的答疑群等，如果贵司Logi-KafkaManager上了生产，[快来加入吧](http://obsuite.didiyun.com/open/openAuth)
+## 4 OCE认证
+OCE是一个认证机制和交流平台，为滴滴Logi-KafkaManager生产用户量身打造，我们会为OCE企业提供更好的技术支持，比如专属的技术沙龙、企业一对一的交流机会、专属的答疑群等，如果贵司Logi-KafkaManager上了生产，[快来加入吧](http://obsuite.didiyun.com/open/openAuth)


-## 项目成员
+## 5 项目成员

-### 内部核心人员
+### 5.1 内部核心人员

 `iceyuhui`、`liuyaguang`、`limengmonty`、`zhangliangmike`、`nullhuangyiming`、`zengqiao`、`eilenexuzhe`、`huangjiaweihjw`、`zhaoyinrui`、`marzkonglingxu`、`joysunchao`


-### 外部贡献者
+### 5.2 外部贡献者

 `fangjunyu`、`zhoutaiyang`


-## 协议
+## 6 协议

 `kafka-manager`基于`Apache-2.0`协议进行分发和使用，更多信息参见[协议文件](./LICENSE)
--- a/Releases_Notes.md
+++ b/Releases_Notes.md
@@ -0,0 +1,97 @@
+
+---
+
+![kafka-manager-logo](./docs/assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+## v2.3.0
+
+版本上线时间：2021-02-08
+
+
+### 能力提升
+
+- 新增支持docker化部署
+- 可指定Broker作为候选controller
+- 可新增并管理网关配置
+- 可获取消费组状态
+- 增加集群的JMX认证  
+
+### 体验优化
+
+- 优化编辑用户角色、修改密码的流程
+- 新增consumerID的搜索功能
+- 优化“Topic连接信息”、“消费组重置消费偏移”、“修改Topic保存时间”的文案提示
+- 在相应位置增加《资源申请文档》链接 
+
+### bug修复
+
+- 修复Broker监控图表时间轴展示错误的问题
+- 修复创建夜莺监控告警规则时，使用的告警周期的单位不正确的问题
+
+
+
+## v2.2.0
+
+版本上线时间：2021-01-25
+
+
+
+### 能力提升
+
+- 优化工单批量操作流程 
+- 增加获取Topic75分位/99分位的实时耗时数据
+- 增加定时任务，可将无主未落DB的Topic定期写入DB
+
+### 体验优化
+
+- 在相应位置增加《集群接入文档》链接
+- 优化物理集群、逻辑集群含义
+- 在Topic详情页、Topic扩分区操作弹窗增加展示Topic所属Region的信息
+- 优化Topic审批时，Topic数据保存时间的配置流程
+- 优化Topic/应用申请、审批时的错误提示文案
+- 优化Topic数据采样的操作项文案
+- 优化运维人员删除Topic时的提示文案
+- 优化运维人员删除Region的删除逻辑与提示文案
+- 优化运维人员删除逻辑集群的提示文案
+- 优化上传集群配置文件时的文件类型限制条件
+
+### bug修复
+
+- 修复填写应用名称时校验特殊字符出错的问题
+- 修复普通用户越权访问应用详情的问题
+- 修复由于Kafka版本升级，导致的数据压缩格式无法获取的问题
+- 修复删除逻辑集群或Topic之后，界面依旧展示的问题
+- 修复进行Leader rebalance操作时执行结果重复提示的问题
+
+
+## v2.1.0
+
+版本上线时间：2020-12-19
+
+
+
+### 体验优化
+
+- 优化页面加载时的背景样式
+- 优化普通用户申请Topic权限的流程
+- 优化Topic申请配额、申请分区的权限限制
+- 优化取消Topic权限的文案提示
+- 优化申请配额表单的表单项名称
+- 优化重置消费偏移的操作流程
+- 优化创建Topic迁移任务的表单内容
+- 优化Topic扩分区操作的弹窗界面样式
+- 优化集群Broker监控可视化图表样式
+- 优化创建逻辑集群的表单内容
+- 优化集群安全协议的提示文案
+
+### bug修复
+
+- 修复偶发性重置消费偏移失败的问题
+
+
+
+
--- a/build.sh
+++ b/build.sh
@@ -4,8 +4,9 @@ cd $workspace

 ## constant
 OUTPUT_DIR=./output
-KM_VERSION=2.1.0
-APP_NAME=kafka-manager-$KM_VERSION
+KM_VERSION=2.3.0
+APP_NAME=kafka-manager
+APP_DIR=${APP_NAME}-${KM_VERSION}

 MYSQL_TABLE_SQL_FILE=./docs/install_guide/create_mysql_table.sql
 CONFIG_FILE=./kafka-manager-web/src/main/resources/application.yml
@@ -28,15 +29,15 @@ function build() {
 function make_output() {
    # 新建output目录
    rm -rf ${OUTPUT_DIR} &>/dev/null
-    mkdir -p ${OUTPUT_DIR}/${APP_NAME} &>/dev/null
+    mkdir -p ${OUTPUT_DIR}/${APP_DIR} &>/dev/null

    # 填充output目录, output内的内容
    (
-          cp -rf ${MYSQL_TABLE_SQL_FILE} ${OUTPUT_DIR}/${APP_NAME} &&       # 拷贝 sql 初始化脚本      至output目录
-          cp -rf ${CONFIG_FILE} ${OUTPUT_DIR}/${APP_NAME} &&                # 拷贝 application.yml   至output目录
+          cp -rf ${MYSQL_TABLE_SQL_FILE} ${OUTPUT_DIR}/${APP_DIR} &&       # 拷贝 sql 初始化脚本      至output目录
+          cp -rf ${CONFIG_FILE} ${OUTPUT_DIR}/${APP_DIR} &&                # 拷贝 application.yml   至output目录

          # 拷贝程序包到output路径
-          cp kafka-manager-web/target/kafka-manager-web-${KM_VERSION}-SNAPSHOT.jar ${OUTPUT_DIR}/${APP_NAME}/${APP_NAME}-SNAPSHOT.jar
+          cp kafka-manager-web/target/kafka-manager-web-${KM_VERSION}-SNAPSHOT.jar ${OUTPUT_DIR}/${APP_DIR}/${APP_NAME}.jar
          echo -e "make output ok."
    ) || { echo -e "make output error"; exit 2; } # 填充output目录失败后, 退出码为 非0
 }
@@ -44,7 +45,7 @@ function make_output() {
 function make_package() {
 	# 压缩output目录
 	(
-	    cd ${OUTPUT_DIR} && tar cvzf ${APP_NAME}.tar.gz ${APP_NAME}
+	    cd ${OUTPUT_DIR} && tar cvzf ${APP_DIR}.tar.gz ${APP_DIR}
      echo -e "make package ok."
 	) || { echo -e "make package error"; exit 2; } # 压缩output目录失败后, 退出码为 非0
 }
--- a/container/dockerfiles/Dockerfile
+++ b/container/dockerfiles/Dockerfile
@@ -0,0 +1,44 @@
+FROM openjdk:8-jdk-alpine3.9
+
+LABEL author="yangvipguang"
+
+ENV  VERSION 2.1.0
+ENV  JAR_PATH kafka-manager-web/target
+COPY $JAR_PATH/kafka-manager-web-$VERSION-SNAPSHOT.jar /tmp/app.jar
+COPY $JAR_PATH/application.yml  /km/
+
+RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories
+RUN apk add --no-cache --virtual .build-deps \
+    font-adobe-100dpi \
+    ttf-dejavu \
+    fontconfig \ 
+    curl \
+    apr \
+    apr-util \
+    apr-dev \
+    tomcat-native \
+    && apk del .build-deps
+
+ENV AGENT_HOME /opt/agent/
+
+WORKDIR /tmp
+COPY docker-depends/config.yaml    $AGENT_HOME
+COPY docker-depends/jmx_prometheus_javaagent-0.14.0.jar $AGENT_HOME
+
+ENV JAVA_AGENT="-javaagent:$AGENT_HOME/jmx_prometheus_javaagent-0.14.0.jar=9999:$AGENT_HOME/config.yaml"
+
+ENV JAVA_HEAP_OPTS="-Xms1024M -Xmx1024M -Xmn100M "
+
+ENV JAVA_OPTS="-verbose:gc  \
+               -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintHeapAtGC -Xloggc:/tmp/gc.log -XX:+PrintGCDateStamps  -XX:+PrintGCTimeStamps \
+               -XX:MaxMetaspaceSize=256M  -XX:+DisableExplicitGC -XX:+UseStringDeduplication \
+               -XX:+UseG1GC  -XX:+HeapDumpOnOutOfMemoryError   -XX:-UseContainerSupport" 
+#-Xlog:gc -Xlog:gc* -Xlog:gc+heap=trace  -Xlog:safepoint
+
+EXPOSE 8080  9999
+
+ENTRYPOINT ["sh","-c","java     -jar    $JAVA_HEAP_OPTS  $JAVA_OPTS /tmp/app.jar --spring.config.location=/km/application.yml"]
+
+## 默认不带Prometheus JMX监控，需要可以自行取消以下注释并注释上面一行默认Entrypoint 命令。
+## ENTRYPOINT ["sh","-c","java     -jar  $JAVA_AGENT  $JAVA_HEAP_OPTS  $JAVA_OPTS /tmp/app.jar --spring.config.location=/km/application.yml"]
+
--- a/container/dockerfiles/docker-depends/config.yaml
+++ b/container/dockerfiles/docker-depends/config.yaml
@@ -0,0 +1,5 @@
+---
+    startDelaySeconds: 0
+    ssl: false
+    lowercaseOutputName: false
+    lowercaseOutputLabelNames: false
--- a/container/helm/.helmignore
+++ b/container/helm/.helmignore
@@ -0,0 +1,23 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*.orig
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj
+.vscode/
--- a/container/helm/Chart.yaml
+++ b/container/helm/Chart.yaml
@@ -0,0 +1,24 @@
+apiVersion: v2
+name: didi-km
+description: A Helm chart for Kubernetes
+
+# A chart can be either an 'application' or a 'library' chart.
+#
+# Application charts are a collection of templates that can be packaged into versioned archives
+# to be deployed.
+#
+# Library charts provide useful utilities or functions for the chart developer. They're included as
+# a dependency of application charts to inject those utilities and functions into the rendering
+# pipeline. Library charts do not define any templates and therefore cannot be deployed.
+type: application
+
+# This is the chart version. This version number should be incremented each time you make changes
+# to the chart and its templates, including the app version.
+# Versions are expected to follow Semantic Versioning (https://semver.org/)
+version: 0.1.0
+
+# This is the version number of the application being deployed. This version number should be
+# incremented each time you make changes to the application. Versions are not expected to
+# follow Semantic Versioning. They should reflect the version the application is using.
+# It is recommended to use it with quotes.
+appVersion: "1.16.0"
--- a/container/helm/templates/NOTES.txt
+++ b/container/helm/templates/NOTES.txt
@@ -0,0 +1,22 @@
+1. Get the application URL by running these commands:
+{{- if .Values.ingress.enabled }}
+{{- range $host := .Values.ingress.hosts }}
+  {{- range .paths }}
+  http{{ if $.Values.ingress.tls }}s{{ end }}://{{ $host.host }}{{ .path }}
+  {{- end }}
+{{- end }}
+{{- else if contains "NodePort" .Values.service.type }}
+  export NODE_PORT=$(kubectl get --namespace {{ .Release.Namespace }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "didi-km.fullname" . }})
+  export NODE_IP=$(kubectl get nodes --namespace {{ .Release.Namespace }} -o jsonpath="{.items[0].status.addresses[0].address}")
+  echo http://$NODE_IP:$NODE_PORT
+{{- else if contains "LoadBalancer" .Values.service.type }}
+     NOTE: It may take a few minutes for the LoadBalancer IP to be available.
+           You can watch the status of by running 'kubectl get --namespace {{ .Release.Namespace }} svc -w {{ include "didi-km.fullname" . }}'
+  export SERVICE_IP=$(kubectl get svc --namespace {{ .Release.Namespace }} {{ include "didi-km.fullname" . }} --template "{{"{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}"}}")
+  echo http://$SERVICE_IP:{{ .Values.service.port }}
+{{- else if contains "ClusterIP" .Values.service.type }}
+  export POD_NAME=$(kubectl get pods --namespace {{ .Release.Namespace }} -l "app.kubernetes.io/name={{ include "didi-km.name" . }},app.kubernetes.io/instance={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
+  export CONTAINER_PORT=$(kubectl get pod --namespace {{ .Release.Namespace }} $POD_NAME -o jsonpath="{.spec.containers[0].ports[0].containerPort}")
+  echo "Visit http://127.0.0.1:8080 to use your application"
+  kubectl --namespace {{ .Release.Namespace }} port-forward $POD_NAME 8080:$CONTAINER_PORT
+{{- end }}
--- a/container/helm/templates/_helpers.tpl
+++ b/container/helm/templates/_helpers.tpl
@@ -0,0 +1,62 @@
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "didi-km.name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+If release name contains chart name it will be used as a full name.
+*/}}
+{{- define "didi-km.fullname" -}}
+{{- if .Values.fullnameOverride }}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- $name := default .Chart.Name .Values.nameOverride }}
+{{- if contains $name .Release.Name }}
+{{- .Release.Name | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "didi-km.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Common labels
+*/}}
+{{- define "didi-km.labels" -}}
+helm.sh/chart: {{ include "didi-km.chart" . }}
+{{ include "didi-km.selectorLabels" . }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end }}
+
+{{/*
+Selector labels
+*/}}
+{{- define "didi-km.selectorLabels" -}}
+app.kubernetes.io/name: {{ include "didi-km.name" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- end }}
+
+{{/*
+Create the name of the service account to use
+*/}}
+{{- define "didi-km.serviceAccountName" -}}
+{{- if .Values.serviceAccount.create }}
+{{- default (include "didi-km.fullname" .) .Values.serviceAccount.name }}
+{{- else }}
+{{- default "default" .Values.serviceAccount.name }}
+{{- end }}
+{{- end }}
--- a/container/helm/templates/configmap.yaml
+++ b/container/helm/templates/configmap.yaml
@@ -0,0 +1,88 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: km-cm
+data:
+  application.yml: |
+    server:
+      port: 8080
+      tomcat:
+        accept-count: 1000
+        max-connections: 10000
+        max-threads: 800
+        min-spare-threads: 100
+
+    spring:
+      application:
+        name: kafkamanager
+      datasource:
+        kafka-manager:
+          jdbc-url: jdbc:mysql://xxxxx:3306/kafka-manager?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
+          username: admin
+          password: admin
+          driver-class-name: com.mysql.jdbc.Driver
+      main:
+        allow-bean-definition-overriding: true
+
+      profiles:
+        active: dev
+      servlet:
+        multipart:
+          max-file-size: 100MB
+          max-request-size: 100MB
+
+    logging:
+      config: classpath:logback-spring.xml
+
+    custom:
+      idc: cn
+      jmx:
+        max-conn: 20
+      store-metrics-task:
+        community:
+          broker-metrics-enabled: true
+          topic-metrics-enabled: true
+        didi:
+          app-topic-metrics-enabled: false
+          topic-request-time-metrics-enabled: false
+          topic-throttled-metrics: false
+        save-days: 7
+
+    # 任务相关的开关
+    task:
+      op:
+        sync-topic-enabled: false # 未落盘的Topic定期同步到DB中
+
+    account:
+      ldap:
+
+    kcm:
+      enabled: false
+      storage:
+        base-url: http://127.0.0.1
+      n9e:
+        base-url: http://127.0.0.1:8004
+        user-token: 12345678
+        timeout: 300
+        account: root
+        script-file: kcm_script.sh
+
+    monitor:
+      enabled: false
+      n9e:
+        nid: 2
+        user-token: 1234567890
+        mon:
+          base-url: http://127.0.0.1:8032
+        sink:
+          base-url: http://127.0.0.1:8006
+        rdb:
+          base-url: http://127.0.0.1:80
+
+    notify:
+      kafka:
+        cluster-id: 95
+        topic-name: didi-kafka-notify
+      order:
+        detail-url: http://127.0.0.1
+     
--- a/container/helm/templates/deployment.yaml
+++ b/container/helm/templates/deployment.yaml
@@ -0,0 +1,56 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ include "didi-km.fullname" . }}
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+spec:
+  {{- if not .Values.autoscaling.enabled }}
+  replicas: {{ .Values.replicaCount }}
+  {{- end }}
+  selector:
+    matchLabels:
+      {{- include "didi-km.selectorLabels" . | nindent 6 }}
+  template:
+    metadata:
+      {{- with .Values.podAnnotations }}
+      annotations:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      labels:
+        {{- include "didi-km.selectorLabels" . | nindent 8 }}
+    spec:
+      {{- with .Values.imagePullSecrets }}
+      imagePullSecrets:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      serviceAccountName: {{ include "didi-km.serviceAccountName" . }}
+      securityContext:
+        {{- toYaml .Values.podSecurityContext | nindent 8 }}
+      containers:
+        - name: {{ .Chart.Name }}
+          securityContext:
+            {{- toYaml .Values.securityContext | nindent 12 }}
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          ports:
+          - name: http
+            containerPort: 8080
+            protocol: TCP
+          - name: jmx-metrics
+            containerPort: 9999
+            protocol: TCP
+          resources:
+            {{- toYaml .Values.resources | nindent 12 }}
+      {{- with .Values.nodeSelector }}
+      nodeSelector:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.affinity }}
+      affinity:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.tolerations }}
+      tolerations:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
--- a/container/helm/templates/hpa.yaml
+++ b/container/helm/templates/hpa.yaml
@@ -0,0 +1,28 @@
+{{- if .Values.autoscaling.enabled }}
+apiVersion: autoscaling/v2beta1
+kind: HorizontalPodAutoscaler
+metadata:
+  name: {{ include "didi-km.fullname" . }}
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: {{ include "didi-km.fullname" . }}
+  minReplicas: {{ .Values.autoscaling.minReplicas }}
+  maxReplicas: {{ .Values.autoscaling.maxReplicas }}
+  metrics:
+    {{- if .Values.autoscaling.targetCPUUtilizationPercentage }}
+    - type: Resource
+      resource:
+        name: cpu
+        targetAverageUtilization: {{ .Values.autoscaling.targetCPUUtilizationPercentage }}
+    {{- end }}
+    {{- if .Values.autoscaling.targetMemoryUtilizationPercentage }}
+    - type: Resource
+      resource:
+        name: memory
+        targetAverageUtilization: {{ .Values.autoscaling.targetMemoryUtilizationPercentage }}
+    {{- end }}
+{{- end }}
--- a/container/helm/templates/ingress.yaml
+++ b/container/helm/templates/ingress.yaml
@@ -0,0 +1,41 @@
+{{- if .Values.ingress.enabled -}}
+{{- $fullName := include "didi-km.fullname" . -}}
+{{- $svcPort := .Values.service.port -}}
+{{- if semverCompare ">=1.14-0" .Capabilities.KubeVersion.GitVersion -}}
+apiVersion: networking.k8s.io/v1beta1
+{{- else -}}
+apiVersion: extensions/v1beta1
+{{- end }}
+kind: Ingress
+metadata:
+  name: {{ $fullName }}
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+  {{- with .Values.ingress.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+spec:
+  {{- if .Values.ingress.tls }}
+  tls:
+    {{- range .Values.ingress.tls }}
+    - hosts:
+        {{- range .hosts }}
+        - {{ . | quote }}
+        {{- end }}
+      secretName: {{ .secretName }}
+    {{- end }}
+  {{- end }}
+  rules:
+    {{- range .Values.ingress.hosts }}
+    - host: {{ .host | quote }}
+      http:
+        paths:
+          {{- range .paths }}
+          - path: {{ .path }}
+            backend:
+              serviceName: {{ $fullName }}
+              servicePort: {{ $svcPort }}
+          {{- end }}
+    {{- end }}
+  {{- end }}
--- a/container/helm/templates/service.yaml
+++ b/container/helm/templates/service.yaml
@@ -0,0 +1,15 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "didi-km.fullname" . }}
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+    - port: {{ .Values.service.port }}
+      targetPort: http
+      protocol: TCP
+      name: http
+  selector:
+    {{- include "didi-km.selectorLabels" . | nindent 4 }}
--- a/container/helm/templates/serviceaccount.yaml
+++ b/container/helm/templates/serviceaccount.yaml
@@ -0,0 +1,12 @@
+{{- if .Values.serviceAccount.create -}}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: {{ include "didi-km.serviceAccountName" . }}
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+  {{- with .Values.serviceAccount.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+{{- end }}
--- a/container/helm/templates/tests/test-connection.yaml
+++ b/container/helm/templates/tests/test-connection.yaml
@@ -0,0 +1,15 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: "{{ include "didi-km.fullname" . }}-test-connection"
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
+  annotations:
+    "helm.sh/hook": test
+spec:
+  containers:
+    - name: wget
+      image: busybox
+      command: ['wget']
+      args: ['{{ include "didi-km.fullname" . }}:{{ .Values.service.port }}']
+  restartPolicy: Never
--- a/container/helm/values.yaml
+++ b/container/helm/values.yaml
@@ -0,0 +1,79 @@
+# Default values for didi-km.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+
+replicaCount: 1
+
+image:
+  repository: docker.io/yangvipguang/km
+  pullPolicy: IfNotPresent
+  # Overrides the image tag whose default is the chart appVersion.
+  tag: "v18"
+
+imagePullSecrets: []
+nameOverride: ""
+fullnameOverride: "km"
+
+serviceAccount:
+  # Specifies whether a service account should be created
+  create: true
+  # Annotations to add to the service account
+  annotations: {}
+  # The name of the service account to use.
+  # If not set and create is true, a name is generated using the fullname template
+  name: ""
+
+podAnnotations: {}
+
+podSecurityContext: {}
+  # fsGroup: 2000
+
+securityContext: {}
+  # capabilities:
+  #   drop:
+  #   - ALL
+  # readOnlyRootFilesystem: true
+  # runAsNonRoot: true
+  # runAsUser: 1000
+
+service:
+  type: ClusterIP
+  port: 8080
+
+ingress:
+  enabled: false
+  annotations: {}
+    # kubernetes.io/ingress.class: nginx
+    # kubernetes.io/tls-acme: "true"
+  hosts:
+    - host: chart-example.local
+      paths: []
+  tls: []
+  #  - secretName: chart-example-tls
+  #    hosts:
+  #      - chart-example.local
+
+resources: 
+  # We usually recommend not to specify default resources and to leave this as a conscious
+  # choice for the user. This also increases chances charts run on environments with little
+  # resources, such as Minikube. If you do want to specify resources, uncomment the following
+  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
+  limits:
+    cpu: 50m
+    memory: 2048Mi
+  requests:
+    cpu: 10m
+    memory: 200Mi
+
+autoscaling:
+  enabled: false
+  minReplicas: 1
+  maxReplicas: 100
+  targetCPUUtilizationPercentage: 80
+  # targetMemoryUtilizationPercentage: 80
+
+nodeSelector: {}
+
+tolerations: []
+
+affinity: {}
--- a/docs/assets/images/common/Logi
+++ b/docs/assets/images/common/Logi
--- a/docs/dev_guide/assets/connect_jmx_failed/check_jmx_opened.jpg
+++ b/docs/dev_guide/assets/connect_jmx_failed/check_jmx_opened.jpg
--- a/docs/dev_guide/connect_jmx_failed.md
+++ b/docs/dev_guide/connect_jmx_failed.md
@@ -0,0 +1,101 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+## JMX-连接失败问题解决
+
+集群正常接入Logi-KafkaManager之后，即可以看到集群的Broker列表，此时如果查看不了Topic的实时流量，或者是Broker的实时流量信息时，那么大概率就是JMX连接的问题了。
+
+下面我们按照步骤来一步一步的检查。
+
+### 1、问题&说明
+
+**类型一：JMX配置未开启**
+
+未开启时，直接到`2、解决方法`查看如何开启即可。
+
+![check_jmx_opened](./assets/connect_jmx_failed/check_jmx_opened.jpg)
+
+
+**类型二：配置错误**
+
+`JMX`端口已经开启的情况下，有的时候开启的配置不正确，此时也会导致出现连接失败的问题。这里大概列举几种原因：
+
+- `JMX`配置错误：见`2、解决方法`。
+- 存在防火墙或者网络限制：网络通的另外一台机器`telnet`试一下看是否可以连接上。
+- 需要进行用户名及密码的认证：见`3、解决方法 —— 认证的JMX`。
+
+
+错误日志例子：
+```
+# 错误一： 错误提示的是真实的IP，这样的话基本就是JMX配置的有问题了。
+2021-01-27 10:06:20.730 ERROR 50901 --- [ics-Thread-1-62] c.x.k.m.c.utils.jmx.JmxConnectorWrap     : JMX connect exception, host:192.168.0.1 port:9999.
+java.rmi.ConnectException: Connection refused to host: 192.168.0.1; nested exception is: 
+
+
+# 错误二：错误提示的是127.0.0.1这个IP，这个是机器的hostname配置的可能有问题。
+2021-01-27 10:06:20.730 ERROR 50901 --- [ics-Thread-1-62] c.x.k.m.c.utils.jmx.JmxConnectorWrap     : JMX connect exception, host:127.0.0.1 port:9999.
+java.rmi.ConnectException: Connection refused to host: 127.0.0.1;; nested exception is: 
+```
+
+### 2、解决方法
+
+这里仅介绍一下比较通用的解决方式，如若有更好的方式，欢迎大家指导告知一下。
+
+修改`kafka-server-start.sh`文件：
+```
+# 在这个下面增加JMX端口的配置
+if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
+    export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
+    export JMX_PORT=9999  # 增加这个配置, 这里的数值并不一定是要9999
+fi
+```
+
+&nbsp;
+
+修改`kafka-run-class.sh`文件
+```
+# JMX settings
+if [ -z "$KAFKA_JMX_OPTS" ]; then
+  KAFKA_JMX_OPTS="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=false  -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=${当前机器的IP}"
+fi
+
+# JMX port to use
+if [  $JMX_PORT ]; then
+  KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.port=$JMX_PORT -Dcom.sun.management.jmxremote.rmi.port=$JMX_PORT"
+fi
+```
+
+
+### 3、解决方法 —— 认证的JMX
+
+如果您是直接看的这个部分，建议先看一下上一节：`2、解决方法`以确保`JMX`的配置没有问题了。
+
+在JMX的配置等都没有问题的情况下，如果是因为认证的原因导致连接不了的，此时可以使用下面介绍的方法进行解决。
+
+**当前这块后端刚刚开发完成，可能还不够完善，有问题随时沟通。**
+
+`Logi-KafkaManager 2.2.0+`之后的版本后端已经支持`JMX`认证方式的连接，但是还没有界面，此时我们可以往`cluster`表的`jmx_properties`字段写入`JMX`的认证信息。
+
+这个数据是`json`格式的字符串，例子如下所示：
+
+```json
+{
+    "maxConn": 10,           # KM对单台Broker的最大JMX连接数
+    "username": "xxxxx",     # 用户名
+    "password": "xxxx",      # 密码
+    "openSSL": true,         # 开启SSL, true表示开启ssl, false表示关闭
+}
+```
+
+&nbsp;
+
+SQL的例子：
+```sql
+UPDATE cluster SET jmx_properties='{ "maxConn": 10,	"username": "xxxxx", "password": "xxxx", "openSSL": false }' where id={xxx};
+```
--- a/docs/dev_guide/gateway_config_manager.md
+++ b/docs/dev_guide/gateway_config_manager.md
@@ -0,0 +1,10 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# Kafka-Gateway 配置说明
--- a/docs/dev_guide/upgrade_manual/logi-km-v2.2.0.md
+++ b/docs/dev_guide/upgrade_manual/logi-km-v2.2.0.md
@@ -0,0 +1,27 @@
+
+---
+
+![kafka-manager-logo](../../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# 升级至`2.2.0`版本
+
+`2.2.0`版本在`cluster`表及`logical_cluster`各增加了一个字段，因此需要执行下面的sql进行字段的增加。
+
+```sql
+# 往cluster表中增加jmx_properties字段, 这个字段会用于存储jmx相关的认证以及配置信息
+ALTER TABLE `cluster` ADD COLUMN `jmx_properties` TEXT NULL COMMENT 'JMX配置' AFTER `security_properties`;
+
+# 往logical_cluster中增加identification字段, 同时数据和原先name数据相同, 最后增加一个唯一键. 
+# 此后, name字段还是表示集群名称, 而identification字段表示的是集群标识, 只能是字母数字及下划线组成, 
+# 数据上报到监控系统时, 集群这个标识采用的字段就是identification字段, 之前使用的是name字段.
+ALTER TABLE `logical_cluster` ADD COLUMN `identification` VARCHAR(192) NOT NULL DEFAULT '' COMMENT '逻辑集群标识' AFTER `name`;
+
+UPDATE `logical_cluster` SET `identification`=`name` WHERE id>=0;
+
+ALTER TABLE `logical_cluster` ADD INDEX `uniq_identification` (`identification` ASC);
+```
+
--- a/docs/dev_guide/upgrade_manual/logi-km-v2.3.0.md
+++ b/docs/dev_guide/upgrade_manual/logi-km-v2.3.0.md
@@ -0,0 +1,17 @@
+
+---
+
+![kafka-manager-logo](../../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# 升级至`2.3.0`版本
+
+`2.3.0`版本在`gateway_config`表增加了一个描述说明的字段，因此需要执行下面的sql进行字段的增加。
+
+```sql
+ALTER TABLE `gateway_config` 
+ADD COLUMN `description` TEXT NULL COMMENT '描述信息' AFTER `version`;
+```
--- a/docs/dev_guide/use_mysql_8.md
+++ b/docs/dev_guide/use_mysql_8.md
@@ -15,7 +15,7 @@
 当前因为无法同时兼容`MySQL 8`与`MySQL 5.7`，因此代码中默认的版本还是`MySQL 5.7`。


-当前如需使用`MySQL 8`，则续按照下述流程进行简单修改代码。
+当前如需使用`MySQL 8`，则需按照下述流程进行简单修改代码。


 - Step1. 修改application.yml中的MySQL驱动类
--- a/docs/install_guide/create_mysql_table.sql
+++ b/docs/install_guide/create_mysql_table.sql
@@ -1,3 +1,8 @@
+-- create database
+CREATE DATABASE logi_kafka_manager;
+
+USE logi_kafka_manager;
+
 --
 -- Table structure for table `account`
 --
@@ -104,7 +109,8 @@ CREATE TABLE `cluster` (
  `zookeeper` varchar(512) NOT NULL DEFAULT '' COMMENT 'zk地址',
  `bootstrap_servers` varchar(512) NOT NULL DEFAULT '' COMMENT 'server地址',
  `kafka_version` varchar(32) NOT NULL DEFAULT '' COMMENT 'kafka版本',
-  `security_properties` text COMMENT '安全认证参数',
+  `security_properties` text COMMENT 'Kafka安全认证参数',
+  `jmx_properties` text COMMENT 'JMX配置',
  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT ' 监控标记, 0表示未监控, 1表示监控中',
  `gmt_create` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
@@ -197,7 +203,8 @@ CREATE TABLE `gateway_config` (
  `type` varchar(128) NOT NULL DEFAULT '' COMMENT '配置类型',
  `name` varchar(128) NOT NULL DEFAULT '' COMMENT '配置名称',
  `value` text COMMENT '配置值',
-  `version` bigint(20) unsigned NOT NULL DEFAULT '0' COMMENT '版本信息',
+  `version` bigint(20) unsigned NOT NULL DEFAULT '1' COMMENT '版本信息',
+  `description` text COMMENT '描述信息',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `modify_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`),
@@ -302,20 +309,22 @@ INSERT INTO kafka_user(app_id, password, user_type, operation) VALUES ('dkm_admi
 -- Table structure for table `logical_cluster`
 --

-- DROP TABLE IF EXISTS `logical_cluster`;
 CREATE TABLE `logical_cluster` (
-  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'id',
-  `name` varchar(192) NOT NULL DEFAULT '' COMMENT '逻辑集群名称',
-  `mode` int(16) NOT NULL DEFAULT '0' COMMENT '逻辑集群类型, 0:共享集群, 1:独享集群, 2:独立集群',
-  `app_id` varchar(64) NOT NULL DEFAULT '' COMMENT '所属应用',
-  `cluster_id` bigint(20) NOT NULL DEFAULT '-1' COMMENT '集群id',
-  `region_list` varchar(256) NOT NULL DEFAULT '' COMMENT 'regionid列表',
-  `description` text COMMENT '备注说明',
-  `gmt_create` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
-  `gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `uniq_name` (`name`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='逻辑集群信息表';
+    `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'id',
+    `name` varchar(192) NOT NULL DEFAULT '' COMMENT '逻辑集群名称',
+    `identification` varchar(192) NOT NULL DEFAULT '' COMMENT '逻辑集群标识',
+    `mode` int(16) NOT NULL DEFAULT '0' COMMENT '逻辑集群类型, 0:共享集群, 1:独享集群, 2:独立集群',
+    `app_id` varchar(64) NOT NULL DEFAULT '' COMMENT '所属应用',
+    `cluster_id` bigint(20) NOT NULL DEFAULT '-1' COMMENT '集群id',
+    `region_list` varchar(256) NOT NULL DEFAULT '' COMMENT 'regionid列表',
+    `description` text COMMENT '备注说明',
+    `gmt_create` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+    `gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uniq_name` (`name`),
+    UNIQUE KEY `uniq_identification` (`identification`)
+) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COMMENT='逻辑集群信息表';
+

 --
 -- Table structure for table `monitor_rule`
--- a/docs/install_guide/install_guide_cn.md
+++ b/docs/install_guide/install_guide_cn.md
@@ -9,19 +9,39 @@

 # 安装手册

+## 1、环境依赖

-## 环境依赖
+如果是以Release包进行安装的，则仅安装`Java`及`MySQL`即可。如果是要先进行源码包进行打包，然后再使用，则需要安装`Maven`及`Node`环境。

- `Maven 3.5+`(后端打包依赖)
- `node v12+`(前端打包依赖)
 - `Java 8+`(运行环境需要)
 - `MySQL 5.7`(数据存储)
+- `Maven 3.5+`(后端打包依赖)
+- `Node 10+`(前端打包依赖)

 ---

-## 环境初始化
+## 2、获取安装包

-执行[create_mysql_table.sql](create_mysql_table.sql)中的SQL命令，从而创建所需的MySQL库及表，默认创建的库名是`kafka_manager`。
+**1、Release直接下载**
+
+这里如果觉得麻烦，然后也不想进行二次开发，则可以直接下载Release包，下载地址：[Github Release包下载地址](https://github.com/didi/Logi-KafkaManager/releases)
+
+如果觉得Github的下载地址太慢了，也可以进入`Logi-KafkaManager`的用户群获取，群地址在README中。
+
+
+**2、源代码进行打包**
+
+下载好代码之后，进入`Logi-KafkaManager`的主目录，执行`sh build.sh`命令即可，执行完成之后会在`output/kafka-manager-xxx`目录下面生成一个jar包。
+
+对于`windows`环境的用户，估计执行不了`sh build.sh`命令，因此可以直接执行`mvn install`，然后在`kafka-manager-web/target`目录下生成一个kafka-manager-web-xxx.jar的包。
+
+获取到jar包之后，我们继续下面的步骤。
+
+---
+
+## 3、MySQL-DB初始化
+
+执行[create_mysql_table.sql](create_mysql_table.sql)中的SQL命令，从而创建所需的MySQL库及表，默认创建的库名是`logi_kafka_manager`。

 ```
 # 示例：
@@ -30,29 +50,15 @@ mysql -uXXXX -pXXX -h XXX.XXX.XXX.XXX -PXXXX < ./create_mysql_table.sql

 ---

-## 打包
-
-```bash
-
-# 一次性打包
-cd ..
-mvn install
+## 4、启动

 ```
+# application.yml 是配置文件，最简单的是仅修改MySQL相关的配置即可启动

---
-
-## 启动
-
-```
-# application.yml 是配置文件
-
-cp kafka-manager-web/src/main/resources/application.yml kafka-manager-web/target/
-cd kafka-manager-web/target/
-nohup java -jar kafka-manager-web-2.1.0-SNAPSHOT.jar --spring.config.location=./application.yml > /dev/null 2>&1 &
+nohup java -jar kafka-manager.jar --spring.config.location=./application.yml > /dev/null 2>&1 &
 ```

-## 使用
+### 5、使用

 本地启动的话，访问`http://localhost:8080`，输入帐号及密码(默认`admin/admin`)进行登录。更多参考：[kafka-manager 用户使用手册](../user_guide/user_guide_cn.md)

--- a/docs/user_guide/add_cluster/add_cluster.md
+++ b/docs/user_guide/add_cluster/add_cluster.md
@@ -5,16 +5,26 @@

 **一站式`Apache Kafka`集群指标监控与运维管控平台**

+
 --- 

 # 集群接入

-集群的接入总共需要三个步骤，分别是：
-1. 接入物理集群
-2. 创建Region
-3. 创建逻辑集群
+## 主要概念讲解
+面对大规模集群、业务场景复杂的情况，引入Region、逻辑集群的概念
+- Region：划分部分Broker作为一个 Region，用Region定义资源划分的单位，提高扩展性和隔离性。如果部分Topic异常也不会影响大面积的Broker
+- 逻辑集群：逻辑集群由部分Region组成，便于对大规模集群按照业务划分、保障能力进行管理  
+![op_cluster_arch](assets/op_cluster_arch.png)

-备注：接入集群需要2、3两步是因为普通用户的视角下，看到的都是逻辑集群，如果没有2、3两步，那么普通用户看不到任何信息。
+集群的接入总共需要三个步骤，分别是：
+1. 接入物理集群：填写机器地址、安全协议等配置信息，接入真实的物理集群
+2. 创建Region：将部分Broker划分为一个Region
+3. 创建逻辑集群：逻辑集群由部分Region组成，可根据业务划分、保障等级来创建相应的逻辑集群
+
+![op_cluster_flow](assets/op_cluster_flow.png)
+
+
+**备注：接入集群需要2、3两步是因为普通用户的视角下，看到的都是逻辑集群，如果没有2、3两步，那么普通用户看不到任何信息。**


 ## 1、接入物理集群
@@ -36,4 +46,4 @@
 ![op_add_logical_cluster](assets/op_add_logical_cluster.jpg)


-如上图所示，填写逻辑集群信息，然后点击确定，即可完成逻辑集群的创建。
+如上图所示，填写逻辑集群信息，然后点击确定，即可完成逻辑集群的创建。
--- a/docs/user_guide/add_cluster/assets/op_cluster_arch.png
+++ b/docs/user_guide/add_cluster/assets/op_cluster_arch.png
--- a/docs/user_guide/add_cluster/assets/op_cluster_flow.png
+++ b/docs/user_guide/add_cluster/assets/op_cluster_flow.png
--- a/docs/user_guide/alarm_rules.md
+++ b/docs/user_guide/alarm_rules.md
@@ -0,0 +1,25 @@
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+---
+
+
+## 报警策略-报警函数介绍
+
+
+
+| 类别 | 函数 | 含义 |函数文案 |备注  |
+| --- | --- | --- | --- | --- |
+| 发生次数 |all，n  | 最近$n个周期内，全发生 | 连续发生(all) |  |
+| 发生次数 | happen, n, m | 最近$n个周期内，发生m次 | 出现(happen) | null点也计算在n内 |
+| 数学统计 | 	sum, n | 最近$n个周期取值 的 和 | 求和(sum) | sum_over_time |
+| 数学统计 | avg, n | 最近$n个周期取值 的 平均值 | 平均值(avg) | avg_over_time |
+| 数学统计 | min, n | 最近$n个周期取值 的 最小值 | 最小值(min) | min_over_time |
+| 数学统计	 | max, n | 最近$n个周期取值 的 最大值 | 最大值(max | max_over_time |
+| 变化率 | pdiff, n | 最近$n个点的变化率, 有一个满足 则触发 | 突增突降率(pdiff) | 假设, 最近3个周期的值分别为 v, v2, v3（v为最新值）那么计算公式为 any( (v-v2)/v2, (v-v3)/v3 )**区分正负** |
+| 变化量 | diff, n | 最近$n个点的变化量, 有一个满足 则触发 | 突增突降值(diff) | 假设, 最近3个周期的值分别为 v, v2, v3（v为最新值）那么计算公式为 any( (v-v2), (v-v3) )**区分正负** |
+| 变化量 | ndiff | 最近n个周期，发生m次 v(t) - v(t-1) $OP threshold其中 v(t) 为最新值 | 连续变化（区分正负） - ndiff	 |  |
+| 数据中断 | nodata, t | 最近 $t 秒内 无数据上报 | 数据上报中断(nodata) |  |
+| 同环比 | c_avg_rate_abs, n | 最近$n个周期的取值，相比 1天或7天前取值 的变化率 的绝对值 | 同比变化率(c_avg_rate_abs) | 假设最近的n个值为 v1, v2, v3历史取到的对应n'个值为 v1', v2'那么计算公式为abs((avg(v1,v2,v3) / avg(v1',v2') -1)* 100%) |
+| 同环比 | c_avg_rate, n | 最近$n个周期的取值，相比 1天或7天前取值 的变化率（**区分正负**) | 同比变化率(c_avg_rate) | 假设最近的n个值为 v1, v2, v3历史取到的对应n'个值为 v1', v2'那么计算公式为(avg(v1,v2,v3) / avg(v1',v2') -1)* 100% |
--- a/docs/user_guide/assets/resource_apply/production_consumption_flow.png
+++ b/docs/user_guide/assets/resource_apply/production_consumption_flow.png
--- a/docs/user_guide/faq.md
+++ b/docs/user_guide/faq.md
@@ -9,18 +9,42 @@

 # FAQ 

- 1、Topic申请时没有可选择的集群？
+- 0、Github图裂问题解决
+- 1、Topic申请、新建监控告警等操作时没有可选择的集群？
 - 2、逻辑集群 & Region的用途？
 - 3、登录失败？
 - 4、页面流量信息等无数据？
 - 5、如何对接夜莺的监控告警功能？
 - 6、如何使用`MySQL 8`？
+- 7、`Jmx`连接失败如何解决？
+- 8、`topic biz data not exist`错误及处理方式
+- 9、进程启动后，如何查看API文档

 ---

-### 1、Topic申请时没有可选择的集群？
+### 0、Github图裂问题解决

- 参看 [kafka-manager 接入集群](docs/user_guide/add_cluster/add_cluster.md) 手册，这里的Region和逻辑集群都必须添加。
+可以在本地机器`ping github.com`这个地址，获取到`github.com`地址的IP地址。
+
+然后将IP绑定到`/etc/hosts`文件中。
+
+例如
+
+```shell
+# 在 /etc/hosts文件中增加如下信息
+
+140.82.113.3 github.com
+```
+
+---
+
+### 1、Topic申请、新建监控告警等操作时没有可选择的集群？
+
+缺少逻辑集群导致的，在Topic管理、监控告警、集群管理这三个Tab下面都是普通用户视角，普通用户看到的集群都是逻辑集群，因此在这三个Tab下进行操作时，都需要有逻辑集群。
+
+逻辑集群的创建参看：
+
+- [kafka-manager 接入集群](docs/user_guide/add_cluster/add_cluster.md) 手册，这里的Region和逻辑集群都必须添加。

 ---

@@ -43,7 +67,7 @@

 - 1、检查`Broker JMX`是否正确开启。

-如若还未开启，具体可百度一下看如何开启。
+如若还未开启，具体可百度一下看如何开启，或者参看：[Jmx连接配置&问题解决说明文档](../dev_guide/connect_jmx_failed.md)

 ![helpcenter](./assets/faq/jmx_check.jpg)

@@ -53,7 +77,7 @@

 - 3、数据库时区问题。

-检查MySQL的topic_metrics、broker_metrics表，查看是否有数据，如果有数据，那么再检查设置的时区是否正确。
+检查MySQL的topic_metrics表，查看是否有数据，如果有数据，那么再检查设置的时区是否正确。

 ---

@@ -66,3 +90,27 @@
 ### 6、如何使用`MySQL 8`？

 - 参看 [kafka-manager 使用`MySQL 8`](../dev_guide/use_mysql_8.md) 说明。
+
+---
+
+### 7、`Jmx`连接失败如何解决？
+
+- 参看 [Jmx连接配置&问题解决](../dev_guide/connect_jmx_failed.md) 说明。
+
+---
+
+### 8、`topic biz data not exist`错误及处理方式
+
+**错误原因**
+
+在进行权限审批的时候，可能会出现这个错误，出现这个错误的原因是因为Topic相关的业务信息没有在DB中存储，或者更具体的说就是该Topic不属于任何应用导致的，只需要将这些无主的Topic挂在某个应用下面即可。
+
+**解决方式**
+
+可以在`运维管控->集群列表->Topic信息`下面，编辑申请权限的Topic，为Topic选择一个应用即可。
+
+以上仅仅只是针对单个Topic的场景，如果你有非常多的Topic需要进行初始化的，那么此时可以在配置管理中增加一个配置，来定时的对无主的Topic进行同步，具体见：[动态配置管理 - 1、Topic定时同步任务](../dev_guide/dynamic_config_manager.md)
+
+### 9、进程启动后，如何查看API文档
+
+- 滴滴Logi-KafkaManager采用Swagger-API工具记录API文档。Swagger-API地址： [http://IP:PORT/swagger-ui.html#/](http://IP:PORT/swagger-ui.html#/) 
--- a/docs/user_guide/resource_apply.md
+++ b/docs/user_guide/resource_apply.md
@@ -0,0 +1,32 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+
+# 资源申请文档
+
+## 主要名词解释
+
+- 应用（App）：作为Kafka中的账户，使用AppID+password作为身份标识
+- 集群：可使用平台提供的共享集群，也可为某一应用申请单独的集群
+- Topic：可申请创建Topic或申请其他Topic的生产/消费权限。进行生产/消费时通过Topic+AppID进行身份鉴权  
+![production_consumption_flow](assets/resource_apply/production_consumption_flow.png)
+
+## 应用申请
+应用（App）作为Kafka中的账户，使用AppID+password作为身份标识。对Topic进行生产/消费时通过Topic+AppID进行身份鉴权。
+
+用户申请应用，经由运维人员审批，审批通过后获得AppID和密钥
+
+## 集群申请
+可使用平台提供的共享集群，若对隔离性、稳定性、生产消费速率有更高的需求，可对某一应用申请单独的集群
+
+## Topic申请
+- 用户可根据已申请的应用创建Topic。创建后，应用负责人默认拥有该Topic的生产/消费权限和管理权限
+- 也可申请其他Topic的生产、消费权限。经由Topic所属应用的负责人审批后，即可拥有相应权限。
+
+
--- a/kafka-manager-common/pom.xml
+++ b/kafka-manager-common/pom.xml
@@ -5,13 +5,13 @@
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.xiaojukeji.kafka</groupId>
    <artifactId>kafka-manager-common</artifactId>
-    <version>2.1.0-SNAPSHOT</version>
+    <version>${kafka-manager.revision}</version>
    <packaging>jar</packaging>

    <parent>
        <artifactId>kafka-manager</artifactId>
        <groupId>com.xiaojukeji.kafka</groupId>
-        <version>2.1.0-SNAPSHOT</version>
+        <version>${kafka-manager.revision}</version>
    </parent>

    <properties>
@@ -104,5 +104,10 @@
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
    </dependencies>
 </project>
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/AccountRoleEnum.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/AccountRoleEnum.java
@@ -47,4 +47,13 @@ public enum AccountRoleEnum {
        }
        return AccountRoleEnum.UNKNOWN;
    }
+
+    public static AccountRoleEnum getUserRoleEnum(String roleName) {
+        for (AccountRoleEnum elem: AccountRoleEnum.values()) {
+            if (elem.message.equalsIgnoreCase(roleName)) {
+                return elem;
+            }
+        }
+        return AccountRoleEnum.UNKNOWN;
+    }
 }
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/SinkMonitorSystemEnum.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/SinkMonitorSystemEnum.java
@@ -1,45 +0,0 @@
-package com.xiaojukeji.kafka.manager.common.bizenum;
-
-/**
- * 是否上报监控系统
- * @author zengqiao
- * @date 20/9/25
- */
-public enum SinkMonitorSystemEnum {
-    SINK_MONITOR_SYSTEM(0, "上报监控系统"),
-    NOT_SINK_MONITOR_SYSTEM(1, "不上报监控系统"),
-    ;
-
-    private Integer code;
-
-    private String message;
-
-    SinkMonitorSystemEnum(Integer code, String message) {
-        this.code = code;
-        this.message = message;
-    }
-
-    public Integer getCode() {
-        return code;
-    }
-
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
-    @Override
-    public String toString() {
-        return "SinkMonitorSystemEnum{" +
-                "code=" + code +
-                ", message='" + message + '\'' +
-                '}';
-    }
-}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TopicExpiredStatusEnum.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TopicExpiredStatusEnum.java
@@ -0,0 +1,32 @@
+package com.xiaojukeji.kafka.manager.common.bizenum;
+
+/**
+ * 过期Topic状态
+ * @author zengqiao
+ * @date 21/01/25
+ */
+public enum TopicExpiredStatusEnum {
+    ALREADY_NOTIFIED_AND_DELETED(-2, "已通知, 已下线"),
+    ALREADY_NOTIFIED_AND_CAN_DELETE(-1, "已通知, 可下线"),
+    ALREADY_EXPIRED_AND_WAIT_NOTIFY(0, "已过期, 待通知"),
+    ALREADY_NOTIFIED_AND_WAIT_RESPONSE(1, "已通知, 待反馈"),
+
+    ;
+
+    private int status;
+
+    private String message;
+
+    TopicExpiredStatusEnum(int status, String message) {
+        this.status = status;
+        this.message = message;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/Result.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/Result.java
@@ -97,7 +97,7 @@ public class Result<T> implements Serializable {
        return result;
    }

-    public static <T> Result<T> buildFailure(String message) {
+    public static <T> Result<T> buildGatewayFailure(String message) {
        Result<T> result = new Result<T>();
        result.setCode(ResultStatus.GATEWAY_INVALID_REQUEST.getCode());
        result.setMessage(message);
@@ -105,6 +105,14 @@ public class Result<T> implements Serializable {
        return result;
    }

+    public static <T> Result<T> buildFailure(String message) {
+        Result<T> result = new Result<T>();
+        result.setCode(ResultStatus.FAIL.getCode());
+        result.setMessage(message);
+        result.setData(null);
+        return result;
+    }
+
    public static Result buildFrom(ResultStatus resultStatus) {
        Result result = new Result();
        result.setCode(resultStatus.getCode());
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ResultStatus.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ResultStatus.java
@@ -12,125 +12,102 @@ public enum ResultStatus {

    SUCCESS(Constant.SUCCESS, "success"),

-    LOGIN_FAILED(1, "login failed, please check username and password"),
-
+    FAIL(1, "操作失败"),

    /**
-     * 内部依赖错误, [1000, 1200)
+     * 操作错误[1000, 2000)
     * ------------------------------------------------------------------------------------------
     */
-    MYSQL_ERROR(1000, "operate database failed"),
-
-    CONNECT_ZOOKEEPER_FAILED(1000, "connect zookeeper failed"),
-    READ_ZOOKEEPER_FAILED(1000, "read zookeeper failed"),
-    READ_JMX_FAILED(1000, "read jmx failed"),
-
-
-    // 内部依赖错误 —— Kafka特定错误, [1000, 1100)
-    BROKER_NUM_NOT_ENOUGH(1000, "broker not enough"),
-    CONTROLLER_NOT_ALIVE(1000, "controller not alive"),
-    CLUSTER_METADATA_ERROR(1000, "cluster metadata error"),
-    TOPIC_CONFIG_ERROR(1000, "topic config error"),
-
-
-    /**
-     * 外部依赖错误, [1200, 1400)
-     * ------------------------------------------------------------------------------------------
-     */
-    CALL_CLUSTER_TASK_AGENT_FAILED(1000, " call cluster task agent failed"),
-    CALL_MONITOR_SYSTEM_ERROR(1000, " call monitor-system failed"),
-
-
-
-    /**
-     * 外部用户操作错误, [1400, 1600)
-     * ------------------------------------------------------------------------------------------
-     */
-    PARAM_ILLEGAL(1400, "param illegal"),
    OPERATION_FAILED(1401, "operation failed"),
    OPERATION_FORBIDDEN(1402, "operation forbidden"),
    API_CALL_EXCEED_LIMIT(1403, "api call exceed limit"),
+    USER_WITHOUT_AUTHORITY(1404, "user without authority"),
+    CHANGE_ZOOKEEPER_FORBIDDEN(1405, "change zookeeper forbidden"),

-    // 资源不存在
-    CLUSTER_NOT_EXIST(10000, "cluster not exist"),
-    BROKER_NOT_EXIST(10000, "broker not exist"),
-    TOPIC_NOT_EXIST(10000, "topic not exist"),
-    PARTITION_NOT_EXIST(10000, "partition not exist"),

-    ACCOUNT_NOT_EXIST(10000, "account not exist"),
-    APP_NOT_EXIST(1000, "app not exist"),
-    ORDER_NOT_EXIST(1000, "order not exist"),
-    CONFIG_NOT_EXIST(1000, "config not exist"),
-    IDC_NOT_EXIST(1000, "idc not exist"),
-    TASK_NOT_EXIST(1110, "task not exist"),
+    TOPIC_OPERATION_PARAM_NULL_POINTER(1450, "参数错误"),
+    TOPIC_OPERATION_PARTITION_NUM_ILLEGAL(1451, "分区数错误"),
+    TOPIC_OPERATION_BROKER_NUM_NOT_ENOUGH(1452, "Broker数不足错误"),
+    TOPIC_OPERATION_TOPIC_NAME_ILLEGAL(1453, "Topic名称非法"),
+    TOPIC_OPERATION_TOPIC_EXISTED(1454, "Topic已存在"),
+    TOPIC_OPERATION_UNKNOWN_TOPIC_PARTITION(1455, "Topic未知"),
+    TOPIC_OPERATION_TOPIC_CONFIG_ILLEGAL(1456, "Topic配置错误"),
+    TOPIC_OPERATION_TOPIC_IN_DELETING(1457, "Topic正在删除"),
+    TOPIC_OPERATION_UNKNOWN_ERROR(1458, "未知错误"),

-    AUTHORITY_NOT_EXIST(1000, "authority not exist"),
+    /**
+     * 参数错误[2000, 3000)
+     * ------------------------------------------------------------------------------------------
+     */
+    PARAM_ILLEGAL(2000, "param illegal"),
+    CG_LOCATION_ILLEGAL(2001, "consumer group location illegal"),
+    ORDER_ALREADY_HANDLED(2002, "order already handled"),
+    APP_ID_OR_PASSWORD_ILLEGAL(2003, "app or password illegal"),
+    SYSTEM_CODE_ILLEGAL(2004, "system code illegal"),
+    CLUSTER_TASK_HOST_LIST_ILLEGAL(2005, "主机列表错误，请检查主机列表"),
+    JSON_PARSER_ERROR(2006, "json parser error"),

-    MONITOR_NOT_EXIST(1110, "monitor not exist"),
+    BROKER_NUM_NOT_ENOUGH(2050, "broker not enough"),
+    CONTROLLER_NOT_ALIVE(2051, "controller not alive"),
+    CLUSTER_METADATA_ERROR(2052, "cluster metadata error"),
+    TOPIC_CONFIG_ERROR(2053, "topic config error"),

-    QUOTA_NOT_EXIST(1000, "quota not exist, please check clusterId, topicName and appId"),
+    /**
+     * 参数错误 - 资源检查错误
+     * 因为外部系统的问题, 操作时引起的错误, [7000, 8000)
+     * ------------------------------------------------------------------------------------------
+     */
+    RESOURCE_NOT_EXIST(7100, "资源不存在"),
+    CLUSTER_NOT_EXIST(7101, "cluster not exist"),
+    BROKER_NOT_EXIST(7102, "broker not exist"),
+    TOPIC_NOT_EXIST(7103, "topic not exist"),
+    PARTITION_NOT_EXIST(7104, "partition not exist"),
+    ACCOUNT_NOT_EXIST(7105, "account not exist"),
+    APP_NOT_EXIST(7106, "app not exist"),
+    ORDER_NOT_EXIST(7107, "order not exist"),
+    CONFIG_NOT_EXIST(7108, "config not exist"),
+    IDC_NOT_EXIST(7109, "idc not exist"),
+    TASK_NOT_EXIST(7110, "task not exist"),
+    AUTHORITY_NOT_EXIST(7111, "authority not exist"),
+    MONITOR_NOT_EXIST(7112, "monitor not exist"),
+    QUOTA_NOT_EXIST(7113, "quota not exist, please check clusterId, topicName and appId"),
+    CONSUMER_GROUP_NOT_EXIST(7114, "consumerGroup not exist"),
+    TOPIC_BIZ_DATA_NOT_EXIST(7115, "topic biz data not exist, please sync topic to db"),

-    // 资源不存在, 已存在, 已被使用
-    RESOURCE_NOT_EXIST(1200, "资源不存在"),
-    RESOURCE_ALREADY_EXISTED(1200, "资源已经存在"),
-    RESOURCE_NAME_DUPLICATED(1200, "资源名称重复"),
-    RESOURCE_ALREADY_USED(1000, "资源早已被使用"),
+    // 资源已存在
+    RESOURCE_ALREADY_EXISTED(7200, "资源已经存在"),
+    TOPIC_ALREADY_EXIST(7201, "topic already existed"),
+
+    // 资源重名
+    RESOURCE_NAME_DUPLICATED(7300, "资源名称重复"),
+
+    // 资源已被使用
+    RESOURCE_ALREADY_USED(7400, "资源早已被使用"),


    /**
-     * 资源参数错误
+     * 因为外部系统的问题, 操作时引起的错误, [8000, 9000)
+     * ------------------------------------------------------------------------------------------
     */
-    CG_LOCATION_ILLEGAL(10000, "consumer group location illegal"),
-    ORDER_ALREADY_HANDLED(1000, "order already handled"),
+    MYSQL_ERROR(8010, "operate database failed"),

-    APP_ID_OR_PASSWORD_ILLEGAL(1000, "app or password illegal"),
-    SYSTEM_CODE_ILLEGAL(1000, "system code illegal"),
+    ZOOKEEPER_CONNECT_FAILED(8020, "zookeeper connect failed"),
+    ZOOKEEPER_READ_FAILED(8021, "zookeeper read failed"),
+    ZOOKEEPER_WRITE_FAILED(8022, "zookeeper write failed"),
+    ZOOKEEPER_DELETE_FAILED(8023, "zookeeper delete failed"),

-    CLUSTER_TASK_HOST_LIST_ILLEGAL(1000, "主机列表错误，请检查主机列表"),
+    // 调用集群任务里面的agent失败
+    CALL_CLUSTER_TASK_AGENT_FAILED(8030, " call cluster task agent failed"),

+    // 调用监控系统失败
+    CALL_MONITOR_SYSTEM_ERROR(8040, " call monitor-system failed"),

+    // 存储相关的调用失败
+    STORAGE_UPLOAD_FILE_FAILED(8050, "upload file failed"),
+    STORAGE_FILE_TYPE_NOT_SUPPORT(8051, "File type not support"),
+    STORAGE_DOWNLOAD_FILE_FAILED(8052, "download file failed"),
+    LDAP_AUTHENTICATION_FAILED(8053, "LDAP authentication failed"),

-
-
-
-
-
-
-    ///////////////////////////////////////////////////////////////
-
-    USER_WITHOUT_AUTHORITY(1000, "user without authority"),
-
-
-
-    JSON_PARSER_ERROR(1000, "json parser error"),
-
-
-    TOPIC_OPERATION_PARAM_NULL_POINTER(2, "参数错误"),
-    TOPIC_OPERATION_PARTITION_NUM_ILLEGAL(3, "分区数错误"),
-    TOPIC_OPERATION_BROKER_NUM_NOT_ENOUGH(4, "Broker数不足错误"),
-    TOPIC_OPERATION_TOPIC_NAME_ILLEGAL(5, "Topic名称非法"),
-    TOPIC_OPERATION_TOPIC_EXISTED(6, "Topic已存在"),
-    TOPIC_OPERATION_UNKNOWN_TOPIC_PARTITION(7, "Topic未知"),
-    TOPIC_OPERATION_TOPIC_CONFIG_ILLEGAL(8, "Topic配置错误"),
-    TOPIC_OPERATION_TOPIC_IN_DELETING(9, "Topic正在删除"),
-    TOPIC_OPERATION_UNKNOWN_ERROR(10, "未知错误"),
-    TOPIC_EXIST_CONNECT_CANNOT_DELETE(10, "topic exist connect cannot delete"),
-    EXIST_TOPIC_CANNOT_DELETE(10, "exist topic cannot delete"),
-
-
-    /**
-     * 工单
-     */
-    CHANGE_ZOOKEEPER_FORBIDEN(100, "change zookeeper forbiden"),
-//    APP_EXIST_TOPIC_AUTHORITY_CANNOT_DELETE(1000, "app exist topic authority cannot delete"),
-
-    UPLOAD_FILE_FAIL(1000, "upload file fail"),
-    FILE_TYPE_NOT_SUPPORT(1000, "File type not support"),
-    DOWNLOAD_FILE_FAIL(1000, "download file fail"),
-
-
-    TOPIC_ALREADY_EXIST(17400, "topic already existed"),
-    CONSUMER_GROUP_NOT_EXIST(17411, "consumerGroup not exist"),
    ;

    private int code;
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/ClusterDetailDTO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/ClusterDetailDTO.java
@@ -23,6 +23,8 @@ public class ClusterDetailDTO {

    private String securityProperties;

+    private String jmxProperties;
+
    private Integer status;

    private Date gmtCreate;
@@ -103,6 +105,14 @@ public class ClusterDetailDTO {
        this.securityProperties = securityProperties;
    }

+    public String getJmxProperties() {
+        return jmxProperties;
+    }
+
+    public void setJmxProperties(String jmxProperties) {
+        this.jmxProperties = jmxProperties;
+    }
+
    public Integer getStatus() {
        return status;
    }
@@ -176,8 +186,9 @@ public class ClusterDetailDTO {
                ", bootstrapServers='" + bootstrapServers + '\'' +
                ", kafkaVersion='" + kafkaVersion + '\'' +
                ", idc='" + idc + '\'' +
-                ", mode='" + mode + '\'' +
+                ", mode=" + mode +
                ", securityProperties='" + securityProperties + '\'' +
+                ", jmxProperties='" + jmxProperties + '\'' +
                ", status=" + status +
                ", gmtCreate=" + gmtCreate +
                ", gmtModify=" + gmtModify +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/cluster/LogicalCluster.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/cluster/LogicalCluster.java
@@ -9,6 +9,8 @@ public class LogicalCluster {

    private String logicalClusterName;

+    private String logicalClusterIdentification;
+
    private Integer mode;

    private Integer topicNum;
@@ -41,6 +43,14 @@ public class LogicalCluster {
        this.logicalClusterName = logicalClusterName;
    }

+    public String getLogicalClusterIdentification() {
+        return logicalClusterIdentification;
+    }
+
+    public void setLogicalClusterIdentification(String logicalClusterIdentification) {
+        this.logicalClusterIdentification = logicalClusterIdentification;
+    }
+
    public Integer getMode() {
        return mode;
    }
@@ -81,6 +91,14 @@ public class LogicalCluster {
        this.bootstrapServers = bootstrapServers;
    }

+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
    public Long getGmtCreate() {
        return gmtCreate;
    }
@@ -97,19 +115,12 @@ public class LogicalCluster {
        this.gmtModify = gmtModify;
    }

-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
    @Override
    public String toString() {
        return "LogicalCluster{" +
                "logicalClusterId=" + logicalClusterId +
                ", logicalClusterName='" + logicalClusterName + '\'' +
+                ", logicalClusterIdentification='" + logicalClusterIdentification + '\'' +
                ", mode=" + mode +
                ", topicNum=" + topicNum +
                ", clusterVersion='" + clusterVersion + '\'' +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/config/SinkTopicRequestTimeMetricsConfig.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/config/SinkTopicRequestTimeMetricsConfig.java
@@ -1,57 +0,0 @@
-package com.xiaojukeji.kafka.manager.common.entity.ao.config;
-
-/**
- * @author zengqiao
- * @date 20/9/7
- */
-public class SinkTopicRequestTimeMetricsConfig {
-    private Long clusterId;
-
-    private String topicName;
-
-    private Long startId;
-
-    private Long step;
-
-    public Long getClusterId() {
-        return clusterId;
-    }
-
-    public void setClusterId(Long clusterId) {
-        this.clusterId = clusterId;
-    }
-
-    public String getTopicName() {
-        return topicName;
-    }
-
-    public void setTopicName(String topicName) {
-        this.topicName = topicName;
-    }
-
-    public Long getStartId() {
-        return startId;
-    }
-
-    public void setStartId(Long startId) {
-        this.startId = startId;
-    }
-
-    public Long getStep() {
-        return step;
-    }
-
-    public void setStep(Long step) {
-        this.step = step;
-    }
-
-    @Override
-    public String toString() {
-        return "SinkTopicRequestTimeMetricsConfig{" +
-                "clusterId=" + clusterId +
-                ", topicName='" + topicName + '\'' +
-                ", startId=" + startId +
-                ", step=" + step +
-                '}';
-    }
-}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/op/ControllerPreferredCandidateDTO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/op/ControllerPreferredCandidateDTO.java
@@ -0,0 +1,45 @@
+package com.xiaojukeji.kafka.manager.common.entity.dto.op;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+import java.util.List;
+
+/**
+ * @author zengqiao
+ * @date 21/01/24
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+@ApiModel(description="优选为Controller的候选者")
+public class ControllerPreferredCandidateDTO {
+    @ApiModelProperty(value="集群ID")
+    private Long clusterId;
+
+    @ApiModelProperty(value="优选为controller的BrokerId")
+    private List<Integer> brokerIdList;
+
+    public Long getClusterId() {
+        return clusterId;
+    }
+
+    public void setClusterId(Long clusterId) {
+        this.clusterId = clusterId;
+    }
+
+    public List<Integer> getBrokerIdList() {
+        return brokerIdList;
+    }
+
+    public void setBrokerIdList(List<Integer> brokerIdList) {
+        this.brokerIdList = brokerIdList;
+    }
+
+    @Override
+    public String toString() {
+        return "ControllerPreferredCandidateDTO{" +
+                "clusterId=" + clusterId +
+                ", brokerIdList=" + brokerIdList +
+                '}';
+    }
+}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/rd/ClusterDTO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/rd/ClusterDTO.java
@@ -27,9 +27,12 @@ public class ClusterDTO {
    @ApiModelProperty(value="数据中心")
    private String idc;

-    @ApiModelProperty(value="安全配置参数")
+    @ApiModelProperty(value="Kafka安全配置")
    private String securityProperties;

+    @ApiModelProperty(value="Jmx配置")
+    private String jmxProperties;
+
    public Long getClusterId() {
        return clusterId;
    }
@@ -78,6 +81,14 @@ public class ClusterDTO {
        this.securityProperties = securityProperties;
    }

+    public String getJmxProperties() {
+        return jmxProperties;
+    }
+
+    public void setJmxProperties(String jmxProperties) {
+        this.jmxProperties = jmxProperties;
+    }
+
    @Override
    public String toString() {
        return "ClusterDTO{" +
@@ -87,15 +98,15 @@ public class ClusterDTO {
                ", bootstrapServers='" + bootstrapServers + '\'' +
                ", idc='" + idc + '\'' +
                ", securityProperties='" + securityProperties + '\'' +
+                ", jmxProperties='" + jmxProperties + '\'' +
                '}';
    }

-    public Boolean legal() {
+    public boolean legal() {
        if (ValidateUtils.isNull(clusterName)
                || ValidateUtils.isNull(zookeeper)
                || ValidateUtils.isNull(idc)
-                || ValidateUtils.isNull(bootstrapServers)
-                ) {
+                || ValidateUtils.isNull(bootstrapServers)) {
            return false;
        }
        return true;
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/rd/LogicalClusterDTO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/dto/rd/LogicalClusterDTO.java
@@ -21,6 +21,9 @@ public class LogicalClusterDTO {
    @ApiModelProperty(value = "名称")
    private String name;

+    @ApiModelProperty(value = "集群标识, 用于告警的上报")
+    private String identification;
+
    @ApiModelProperty(value = "集群模式")
    private Integer mode;

@@ -52,6 +55,14 @@ public class LogicalClusterDTO {
        this.name = name;
    }

+    public String getIdentification() {
+        return identification;
+    }
+
+    public void setIdentification(String identification) {
+        this.identification = identification;
+    }
+
    public Integer getMode() {
        return mode;
    }
@@ -97,6 +108,7 @@ public class LogicalClusterDTO {
        return "LogicalClusterDTO{" +
                "id=" + id +
                ", name='" + name + '\'' +
+                ", identification='" + identification + '\'' +
                ", mode=" + mode +
                ", clusterId=" + clusterId +
                ", regionIdList=" + regionIdList +
@@ -117,6 +129,7 @@ public class LogicalClusterDTO {
        }
        appId = ValidateUtils.isNull(appId)? "": appId;
        description = ValidateUtils.isNull(description)? "": description;
+        identification = ValidateUtils.isNull(identification)? name: identification;
        return true;
    }
 }
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/ClusterDO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/ClusterDO.java
@@ -1,6 +1,7 @@
 package com.xiaojukeji.kafka.manager.common.entity.pojo;

 import java.util.Date;
+import java.util.Objects;

 /**
 * @author zengqiao
@@ -17,6 +18,8 @@ public class ClusterDO implements Comparable<ClusterDO> {

    private String securityProperties;

+    private String jmxProperties;
+
    private Integer status;

    private Date gmtCreate;
@@ -31,30 +34,6 @@ public class ClusterDO implements Comparable<ClusterDO> {
        this.id = id;
    }

-    public Integer getStatus() {
-        return status;
-    }
-
-    public void setStatus(Integer status) {
-        this.status = status;
-    }
-
-    public Date getGmtCreate() {
-        return gmtCreate;
-    }
-
-    public void setGmtCreate(Date gmtCreate) {
-        this.gmtCreate = gmtCreate;
-    }
-
-    public Date getGmtModify() {
-        return gmtModify;
-    }
-
-    public void setGmtModify(Date gmtModify) {
-        this.gmtModify = gmtModify;
-    }
-
    public String getClusterName() {
        return clusterName;
    }
@@ -87,6 +66,38 @@ public class ClusterDO implements Comparable<ClusterDO> {
        this.securityProperties = securityProperties;
    }

+    public String getJmxProperties() {
+        return jmxProperties;
+    }
+
+    public void setJmxProperties(String jmxProperties) {
+        this.jmxProperties = jmxProperties;
+    }
+
+    public Integer getStatus() {
+        return status;
+    }
+
+    public void setStatus(Integer status) {
+        this.status = status;
+    }
+
+    public Date getGmtCreate() {
+        return gmtCreate;
+    }
+
+    public void setGmtCreate(Date gmtCreate) {
+        this.gmtCreate = gmtCreate;
+    }
+
+    public Date getGmtModify() {
+        return gmtModify;
+    }
+
+    public void setGmtModify(Date gmtModify) {
+        this.gmtModify = gmtModify;
+    }
+
    @Override
    public String toString() {
        return "ClusterDO{" +
@@ -95,6 +106,7 @@ public class ClusterDO implements Comparable<ClusterDO> {
                ", zookeeper='" + zookeeper + '\'' +
                ", bootstrapServers='" + bootstrapServers + '\'' +
                ", securityProperties='" + securityProperties + '\'' +
+                ", jmxProperties='" + jmxProperties + '\'' +
                ", status=" + status +
                ", gmtCreate=" + gmtCreate +
                ", gmtModify=" + gmtModify +
@@ -105,4 +117,22 @@ public class ClusterDO implements Comparable<ClusterDO> {
    public int compareTo(ClusterDO clusterDO) {
        return this.id.compareTo(clusterDO.id);
    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ClusterDO clusterDO = (ClusterDO) o;
+        return Objects.equals(id, clusterDO.id)
+                && Objects.equals(clusterName, clusterDO.clusterName)
+                && Objects.equals(zookeeper, clusterDO.zookeeper)
+                && Objects.equals(bootstrapServers, clusterDO.bootstrapServers)
+                && Objects.equals(securityProperties, clusterDO.securityProperties)
+                && Objects.equals(jmxProperties, clusterDO.jmxProperties);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, clusterName, zookeeper, bootstrapServers, securityProperties, jmxProperties);
+    }
 }
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/LogicalClusterDO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/LogicalClusterDO.java
@@ -11,6 +11,8 @@ public class LogicalClusterDO {

    private String name;

+    private String identification;
+
    private Integer mode;

    private String appId;
@@ -41,6 +43,14 @@ public class LogicalClusterDO {
        this.name = name;
    }

+    public String getIdentification() {
+        return identification;
+    }
+
+    public void setIdentification(String identification) {
+        this.identification = identification;
+    }
+
    public Integer getMode() {
        return mode;
    }
@@ -102,6 +112,7 @@ public class LogicalClusterDO {
        return "LogicalClusterDO{" +
                "id=" + id +
                ", name='" + name + '\'' +
+                ", identification='" + identification + '\'' +
                ", mode=" + mode +
                ", appId='" + appId + '\'' +
                ", clusterId=" + clusterId +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/gateway/GatewayConfigDO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/pojo/gateway/GatewayConfigDO.java
@@ -17,6 +17,8 @@ public class GatewayConfigDO {

    private Long version;

+    private String description;
+
    private Date createTime;

    private Date modifyTime;
@@ -61,6 +63,14 @@ public class GatewayConfigDO {
        this.version = version;
    }

+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
    public Date getCreateTime() {
        return createTime;
    }
@@ -85,6 +95,7 @@ public class GatewayConfigDO {
                ", name='" + name + '\'' +
                ", value='" + value + '\'' +
                ", version=" + version +
+                ", description='" + description + '\'' +
                ", createTime=" + createTime +
                ", modifyTime=" + modifyTime +
                '}';
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/normal/cluster/LogicClusterVO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/normal/cluster/LogicClusterVO.java
@@ -15,6 +15,9 @@ public class LogicClusterVO {
    @ApiModelProperty(value="逻辑集群名称")
    private String clusterName;

+    @ApiModelProperty(value="逻辑标识")
+    private String clusterIdentification;
+
    @ApiModelProperty(value="逻辑集群类型, 0:共享集群, 1:独享集群, 2:独立集群")
    private Integer mode;

@@ -24,9 +27,6 @@ public class LogicClusterVO {
    @ApiModelProperty(value="集群版本")
    private String clusterVersion;

-    @ApiModelProperty(value="物理集群ID")
-    private Long physicalClusterId;
-
    @ApiModelProperty(value="集群服务地址")
    private String bootstrapServers;

@@ -55,6 +55,22 @@ public class LogicClusterVO {
        this.clusterName = clusterName;
    }

+    public String getClusterIdentification() {
+        return clusterIdentification;
+    }
+
+    public void setClusterIdentification(String clusterIdentification) {
+        this.clusterIdentification = clusterIdentification;
+    }
+
+    public Integer getMode() {
+        return mode;
+    }
+
+    public void setMode(Integer mode) {
+        this.mode = mode;
+    }
+
    public Integer getTopicNum() {
        return topicNum;
    }
@@ -71,14 +87,6 @@ public class LogicClusterVO {
        this.clusterVersion = clusterVersion;
    }

-    public Long getPhysicalClusterId() {
-        return physicalClusterId;
-    }
-
-    public void setPhysicalClusterId(Long physicalClusterId) {
-        this.physicalClusterId = physicalClusterId;
-    }
-
    public String getBootstrapServers() {
        return bootstrapServers;
    }
@@ -87,6 +95,14 @@ public class LogicClusterVO {
        this.bootstrapServers = bootstrapServers;
    }

+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
    public Long getGmtCreate() {
        return gmtCreate;
    }
@@ -103,32 +119,15 @@ public class LogicClusterVO {
        this.gmtModify = gmtModify;
    }

-    public Integer getMode() {
-        return mode;
-    }
-
-    public void setMode(Integer mode) {
-        this.mode = mode;
-    }
-
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
    @Override
    public String toString() {
        return "LogicClusterVO{" +
                "clusterId=" + clusterId +
                ", clusterName='" + clusterName + '\'' +
+                ", clusterIdentification='" + clusterIdentification + '\'' +
                ", mode=" + mode +
                ", topicNum=" + topicNum +
                ", clusterVersion='" + clusterVersion + '\'' +
-                ", physicalClusterId=" + physicalClusterId +
                ", bootstrapServers='" + bootstrapServers + '\'' +
                ", description='" + description + '\'' +
                ", gmtCreate=" + gmtCreate +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/op/expert/ExpiredTopicVO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/op/expert/ExpiredTopicVO.java
@@ -28,7 +28,7 @@ public class ExpiredTopicVO {
    @ApiModelProperty(value = "负责人")
    private String principals;

-    @ApiModelProperty(value = "状态, -1:可下线, 0:过期待通知, 1+:已通知待反馈")
+    @ApiModelProperty(value = "状态, -1:已通知可下线, 0:过期待通知, 1+:已通知待反馈")
    private Integer status;

    public Long getClusterId() {
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/GatewayConfigVO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/GatewayConfigVO.java
@@ -26,6 +26,9 @@ public class GatewayConfigVO {
    @ApiModelProperty(value="版本")
    private Long version;

+    @ApiModelProperty(value="描述说明")
+    private String description;
+
    @ApiModelProperty(value="创建时间")
    private Date createTime;

@@ -72,6 +75,14 @@ public class GatewayConfigVO {
        this.version = version;
    }

+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
    public Date getCreateTime() {
        return createTime;
    }
@@ -96,6 +107,7 @@ public class GatewayConfigVO {
                ", name='" + name + '\'' +
                ", value='" + value + '\'' +
                ", version=" + version +
+                ", description='" + description + '\'' +
                ", createTime=" + createTime +
                ", modifyTime=" + modifyTime +
                '}';
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/cluster/ClusterBaseVO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/cluster/ClusterBaseVO.java
@@ -32,9 +32,12 @@ public class ClusterBaseVO {
    @ApiModelProperty(value="集群类型")
    private Integer mode;

-    @ApiModelProperty(value="安全配置参数")
+    @ApiModelProperty(value="Kafka安全配置")
    private String securityProperties;

+    @ApiModelProperty(value="Jmx配置")
+    private String jmxProperties;
+
    @ApiModelProperty(value="1:监控中, 0:暂停监控")
    private Integer status;

@@ -108,6 +111,14 @@ public class ClusterBaseVO {
        this.securityProperties = securityProperties;
    }

+    public String getJmxProperties() {
+        return jmxProperties;
+    }
+
+    public void setJmxProperties(String jmxProperties) {
+        this.jmxProperties = jmxProperties;
+    }
+
    public Integer getStatus() {
        return status;
    }
@@ -141,8 +152,9 @@ public class ClusterBaseVO {
                ", bootstrapServers='" + bootstrapServers + '\'' +
                ", kafkaVersion='" + kafkaVersion + '\'' +
                ", idc='" + idc + '\'' +
-                ", mode='" + mode + '\'' +
+                ", mode=" + mode +
                ", securityProperties='" + securityProperties + '\'' +
+                ", jmxProperties='" + jmxProperties + '\'' +
                ", status=" + status +
                ", gmtCreate=" + gmtCreate +
                ", gmtModify=" + gmtModify +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/cluster/LogicalClusterVO.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/vo/rd/cluster/LogicalClusterVO.java
@@ -18,6 +18,9 @@ public class LogicalClusterVO {
    @ApiModelProperty(value = "逻辑集群名称")
    private String logicalClusterName;

+    @ApiModelProperty(value = "逻辑集群标识")
+    private String logicalClusterIdentification;
+
    @ApiModelProperty(value = "物理集群ID")
    private Long physicalClusterId;

@@ -55,6 +58,14 @@ public class LogicalClusterVO {
        this.logicalClusterName = logicalClusterName;
    }

+    public String getLogicalClusterIdentification() {
+        return logicalClusterIdentification;
+    }
+
+    public void setLogicalClusterIdentification(String logicalClusterIdentification) {
+        this.logicalClusterIdentification = logicalClusterIdentification;
+    }
+
    public Long getPhysicalClusterId() {
        return physicalClusterId;
    }
@@ -116,6 +127,7 @@ public class LogicalClusterVO {
        return "LogicalClusterVO{" +
                "logicalClusterId=" + logicalClusterId +
                ", logicalClusterName='" + logicalClusterName + '\'' +
+                ", logicalClusterIdentification='" + logicalClusterIdentification + '\'' +
                ", physicalClusterId=" + physicalClusterId +
                ", regionIdList=" + regionIdList +
                ", mode=" + mode +
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/JsonUtils.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/JsonUtils.java
@@ -53,6 +53,20 @@ public class JsonUtils {
        return JSON.toJSONString(obj);
    }

+    public static <T> T stringToObj(String src, Class<T> clazz) {
+        if (ValidateUtils.isBlank(src)) {
+            return null;
+        }
+        return JSON.parseObject(src, clazz);
+    }
+
+    public static <T> List<T> stringToArrObj(String src, Class<T> clazz) {
+        if (ValidateUtils.isBlank(src)) {
+            return null;
+        }
+        return JSON.parseArray(src, clazz);
+    }
+
    public static List<TopicConnectionDO> parseTopicConnections(Long clusterId, JSONObject jsonObject, long postTime) {
        List<TopicConnectionDO> connectionDOList = new ArrayList<>();
        for (String clientType: jsonObject.keySet()) {
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/ValidateUtils.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/ValidateUtils.java
@@ -2,6 +2,7 @@ package com.xiaojukeji.kafka.manager.common.utils;

 import org.apache.commons.lang.StringUtils;

+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -11,6 +12,20 @@ import java.util.Set;
 * @date 20/4/16
 */
 public class ValidateUtils {
+    /**
+     * 任意一个为空, 则返回true
+     */
+    public static boolean anyNull(Object... objects) {
+        return Arrays.stream(objects).anyMatch(ValidateUtils::isNull);
+    }
+
+    /**
+     * 是空字符串或者空
+     */
+    public static boolean anyBlank(String... strings) {
+        return Arrays.stream(strings).anyMatch(StringUtils::isBlank);
+    }
+
    /**
     * 为空
     */
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/jmx/JmxConfig.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/jmx/JmxConfig.java
@@ -0,0 +1,65 @@
+package com.xiaojukeji.kafka.manager.common.utils.jmx;
+
+public class JmxConfig {
+    /**
+     * 单台最大连接数
+     */
+    private Integer maxConn;
+
+    /**
+     * 用户名
+     */
+    private String username;
+
+    /**
+     * 密码
+     */
+    private String password;
+
+    /**
+     * 开启SSL
+     */
+    private Boolean openSSL;
+
+    public Integer getMaxConn() {
+        return maxConn;
+    }
+
+    public void setMaxConn(Integer maxConn) {
+        this.maxConn = maxConn;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Boolean isOpenSSL() {
+        return openSSL;
+    }
+
+    public void setOpenSSL(Boolean openSSL) {
+        this.openSSL = openSSL;
+    }
+
+    @Override
+    public String toString() {
+        return "JmxConfig{" +
+                "maxConn=" + maxConn +
+                ", username='" + username + '\'' +
+                ", password='" + password + '\'' +
+                ", openSSL=" + openSSL +
+                '}';
+    }
+}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/jmx/JmxConnectorWrap.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/jmx/JmxConnectorWrap.java
@@ -1,5 +1,6 @@
 package com.xiaojukeji.kafka.manager.common.utils.jmx;

+import com.xiaojukeji.kafka.manager.common.utils.ValidateUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

@@ -7,8 +8,14 @@ import javax.management.*;
 import javax.management.remote.JMXConnector;
 import javax.management.remote.JMXConnectorFactory;
 import javax.management.remote.JMXServiceURL;
+import javax.management.remote.rmi.RMIConnectorServer;
+import javax.naming.Context;
+import javax.rmi.ssl.SslRMIClientSocketFactory;
 import java.io.IOException;
 import java.net.MalformedURLException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;

@@ -28,13 +35,19 @@ public class JmxConnectorWrap {

    private AtomicInteger atomicInteger;

-    public JmxConnectorWrap(String host, int port, int maxConn) {
+    private JmxConfig jmxConfig;
+
+    public JmxConnectorWrap(String host, int port, JmxConfig jmxConfig) {
        this.host = host;
        this.port = port;
-        if (maxConn <= 0) {
-            maxConn = 1;
+        this.jmxConfig = jmxConfig;
+        if (ValidateUtils.isNull(this.jmxConfig)) {
+            this.jmxConfig = new JmxConfig();
        }
-        this.atomicInteger = new AtomicInteger(maxConn);
+        if (ValidateUtils.isNullOrLessThanZero(this.jmxConfig.getMaxConn())) {
+            this.jmxConfig.setMaxConn(1);
+        }
+        this.atomicInteger = new AtomicInteger(this.jmxConfig.getMaxConn());
    }

    public boolean checkJmxConnectionAndInitIfNeed() {
@@ -64,8 +77,18 @@ public class JmxConnectorWrap {
        }
        String jmxUrl = String.format("service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi", host, port);
        try {
-            JMXServiceURL url = new JMXServiceURL(jmxUrl);
-            jmxConnector = JMXConnectorFactory.connect(url, null);
+            Map<String, Object> environment = new HashMap<String, Object>();
+            if (!ValidateUtils.isBlank(this.jmxConfig.getUsername()) && !ValidateUtils.isBlank(this.jmxConfig.getPassword())) {
+                environment.put(JMXConnector.CREDENTIALS, Arrays.asList(this.jmxConfig.getUsername(), this.jmxConfig.getPassword()));
+            }
+            if (jmxConfig.isOpenSSL() != null && this.jmxConfig.isOpenSSL()) {
+                environment.put(Context.SECURITY_PROTOCOL, "ssl");
+                SslRMIClientSocketFactory clientSocketFactory = new SslRMIClientSocketFactory();
+                environment.put(RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, clientSocketFactory);
+                environment.put("com.sun.jndi.rmi.factory.socket", clientSocketFactory);
+            }
+
+            jmxConnector = JMXConnectorFactory.connect(new JMXServiceURL(jmxUrl), environment);
            LOGGER.info("JMX connect success, host:{} port:{}.", host, port);
            return true;
        } catch (MalformedURLException e) {
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/ldap/LDAPAuthentication.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/ldap/LDAPAuthentication.java
@@ -0,0 +1,128 @@
+package com.xiaojukeji.kafka.manager.common.utils.ldap;
+
+import com.xiaojukeji.kafka.manager.common.utils.ValidateUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.naming.AuthenticationException;
+import javax.naming.Context;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.directory.SearchControls;
+import javax.naming.directory.SearchResult;
+import javax.naming.ldap.InitialLdapContext;
+import javax.naming.ldap.LdapContext;
+import java.util.Hashtable;
+
+@Component
+public class LDAPAuthentication {
+
+    @Value(value = "${ldap.url}")
+    private String ldapUrl;
+
+    @Value(value = "${ldap.basedn}")
+    private String ldapBasedn;
+
+    @Value(value = "${ldap.factory}")
+    private String ldapFactory;
+
+    @Value(value = "${ldap.filter}")
+    private String ldapfilter;
+
+    @Value(value = "${ldap.auth-user-registration-role}")
+    private String authUserRegistrationRole;
+
+    @Value(value = "${ldap.security.authentication}")
+    private String securityAuthentication;
+
+    @Value(value = "${ldap.security.principal}")
+    private String securityPrincipal;
+
+    @Value(value = "${ldap.security.credentials}")
+    private String securityCredentials;
+
+    private LdapContext getConnect() {
+        Hashtable<String, String> env = new Hashtable<String, String>();
+        env.put(Context.INITIAL_CONTEXT_FACTORY, ldapFactory);
+        env.put(Context.PROVIDER_URL, ldapUrl + ldapBasedn);
+        env.put(Context.SECURITY_AUTHENTICATION, securityAuthentication);
+
+        // 此处若不指定用户名和密码,则自动转换为匿名登录
+        env.put(Context.SECURITY_PRINCIPAL, securityPrincipal);
+        env.put(Context.SECURITY_CREDENTIALS, securityCredentials);
+        try {
+           return new InitialLdapContext(env, null);
+        } catch (AuthenticationException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private String getUserDN(String account,LdapContext ctx) {
+        String userDN = "";
+        try {
+            SearchControls constraints = new SearchControls();
+            constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectClass=*)("+ldapfilter+"=" + account + "))";
+
+            NamingEnumeration<SearchResult> en = ctx.search("", filter, constraints);
+            if (en == null || !en.hasMoreElements()) {
+                return "";
+            }
+            // maybe more than one element
+            while (en.hasMoreElements()) {
+                Object obj = en.nextElement();
+                if (obj instanceof SearchResult) {
+                    SearchResult si = (SearchResult) obj;
+                    userDN += si.getName();
+                    userDN += "," + ldapBasedn;
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return userDN;
+    }
+
+    /**
+     * LDAP账密验证
+     * @param account
+     * @param password
+     * @return
+     */
+    public boolean authenricate(String account, String password) {
+        LdapContext ctx = getConnect();
+
+        boolean valide = false;
+
+        try {
+            String userDN = getUserDN(account,ctx);
+            if(ValidateUtils.isBlank(userDN)){
+                return    valide;
+            }
+            ctx.addToEnvironment(Context.SECURITY_PRINCIPAL, userDN);
+            ctx.addToEnvironment(Context.SECURITY_CREDENTIALS, password);
+            ctx.reconnect(null);
+            valide = true;
+        } catch (AuthenticationException e) {
+            System.out.println(e.toString());
+        } catch (NamingException e) {
+            e.printStackTrace();
+        }finally {
+            if(ctx!=null) {
+                try {
+                    ctx.close();
+                } catch (NamingException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        return valide;
+    }
+
+}
--- a/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/zookeeper/ZkPathUtil.java
+++ b/kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/zookeeper/ZkPathUtil.java
@@ -33,7 +33,9 @@ public class ZkPathUtil {

    private static final String      D_METRICS_CONFIG_ROOT_NODE         = CONFIG_ROOT_NODE + ZOOKEEPER_SEPARATOR + "KafkaExMetrics";

-    public static final String       D_CONTROLLER_CANDIDATES            = CONFIG_ROOT_NODE + ZOOKEEPER_SEPARATOR +  "extension/candidates";
+    public static final String       D_CONFIG_EXTENSION_ROOT_NODE       = CONFIG_ROOT_NODE + ZOOKEEPER_SEPARATOR +  "extension";
+
+    public static final String       D_CONTROLLER_CANDIDATES            = D_CONFIG_EXTENSION_ROOT_NODE  + ZOOKEEPER_SEPARATOR + "candidates";

    public static String getBrokerIdNodePath(Integer brokerId) {
        return BROKER_IDS_ROOT + ZOOKEEPER_SEPARATOR + String.valueOf(brokerId);
@@ -111,6 +113,10 @@ public class ZkPathUtil {
    }

    public static String getKafkaExtraMetricsPath(Integer brokerId) {
-        return D_METRICS_CONFIG_ROOT_NODE + ZOOKEEPER_SEPARATOR + String.valueOf(brokerId);
+        return D_METRICS_CONFIG_ROOT_NODE + ZOOKEEPER_SEPARATOR + brokerId;
+    }
+
+    public static String getControllerCandidatePath(Integer brokerId) {
+        return D_CONTROLLER_CANDIDATES + ZOOKEEPER_SEPARATOR + brokerId;
    }
 }
--- a/kafka-manager-common/src/test/java/com/xiaojukeji/kafka/manager/common/utils/JsonUtilsTest.java
+++ b/kafka-manager-common/src/test/java/com/xiaojukeji/kafka/manager/common/utils/JsonUtilsTest.java
@@ -0,0 +1,18 @@
+package com.xiaojukeji.kafka.manager.common.utils;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class JsonUtilsTest {
+    @Test
+    public void testMapToJsonString() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("key", "value");
+        map.put("int", 1);
+        String expectRes = "{\"key\":\"value\",\"int\":1}";
+        Assert.assertEquals(expectRes, JsonUtils.toJSONString(map));
+    }
+}
--- a/kafka-manager-console/pom.xml
+++ b/kafka-manager-console/pom.xml
@@ -8,7 +8,7 @@
    <parent>
        <artifactId>kafka-manager</artifactId>
        <groupId>com.xiaojukeji.kafka</groupId>
-        <version>2.1.0-SNAPSHOT</version>
+        <version>${kafka-manager.revision}</version>
    </parent>

    <build>
--- a/kafka-manager-console/src/component/antd/index.tsx
+++ b/kafka-manager-console/src/component/antd/index.tsx
@@ -94,6 +94,9 @@ import 'antd/es/divider/style';
 import Upload from 'antd/es/upload';
 import 'antd/es/upload/style';

+import Transfer from 'antd/es/transfer';
+import 'antd/es/transfer/style';
+
 import TimePicker from 'antd/es/time-picker';
 import 'antd/es/time-picker/style';

@@ -142,5 +145,6 @@ export {
  TimePicker,
  RangePickerValue,
  Badge,
-  Popover
+  Popover,
+  Transfer
 };
--- a/kafka-manager-console/src/component/editor/index.less
+++ b/kafka-manager-console/src/component/editor/index.less
@@ -25,7 +25,7 @@
  .editor{
    height: 100%;
    position: absolute;
-    left: -14%;
+    left: -12%;
    width: 120%;
  }
 }
--- a/kafka-manager-console/src/component/editor/monacoEditor.tsx
+++ b/kafka-manager-console/src/component/editor/monacoEditor.tsx
@@ -21,24 +21,12 @@ class Monacoeditor extends React.Component<IEditorProps> {
  public state = {
    placeholder: '',
  };
-  // public arr = '{"clusterId":95,"startId":37397856,"step":100,"topicName":"kmo_topic_metrics_tempory_zq"}';
-  // public Ars(a: string) {
-  //   const obj = JSON.parse(a);
-  //   const newobj: any = {};
-  //   for (const item in obj) {
-  //     if (typeof obj[item] === 'object') {
-  //       this.Ars(obj[item]);
-  //     } else {
-  //       newobj[item] = obj[item];
-  //     }
-  //   }
-  //   return JSON.stringify(newobj);
-  // }
+
  public async componentDidMount() {
    const { value, onChange } = this.props;
    const format: any = await format2json(value);
    this.editor = monaco.editor.create(this.ref, {
-      value: format.result,
+      value: format.result || value,
      language: 'json',
      lineNumbers: 'off',
      scrollBeyondLastLine: false,
@@ -48,7 +36,7 @@ class Monacoeditor extends React.Component<IEditorProps> {
      minimap: {
        enabled: false,
      },
-      // automaticLayout: true, // 自动布局
+      automaticLayout: true, // 自动布局
      glyphMargin: true, // 字形边缘 {},[]
      // useTabStops: false,
      // formatOnPaste: true,
--- a/kafka-manager-console/src/component/x-form/index.tsx
+++ b/kafka-manager-console/src/component/x-form/index.tsx
@@ -2,6 +2,7 @@ import * as React from 'react';
 import { Select, Input, InputNumber, Form, Switch, Checkbox, DatePicker, Radio, Upload, Button, Icon, Tooltip } from 'component/antd';
 import Monacoeditor from 'component/editor/monacoEditor';
 import { searchProps } from 'constants/table';
+import { version } from 'store/version';
 import './index.less';

 const TextArea = Input.TextArea;
@@ -129,6 +130,8 @@ class XForm extends React.Component<IXFormProps> {
                this.renderFormItem(formItem),
              )}
              {formItem.renderExtraElement ? formItem.renderExtraElement() : null}
+              {/* 添加保存时间提示文案 */}
+              {formItem.attrs?.prompttype ? <span style={{ color: "#cccccc", fontSize: '12px', lineHeight: '20px', display: 'block' }}>{formItem.attrs.prompttype}</span> : null}
            </Form.Item>
          );
        })}
@@ -189,7 +192,7 @@ class XForm extends React.Component<IXFormProps> {
      case FormItemType.upload:
        return (
          <Upload beforeUpload={(file: any) => false} {...item.attrs}>
-            <Button><Icon type="upload" />上传</Button>
+            <Button><Icon type="upload" />上传</Button>{version.fileSuffix && <span style={{ color: '#fb3939', padding: '0 0 0 10px' }}>{`请上传${version.fileSuffix}文件`}</span>}
          </Upload>
        );
    }
--- a/kafka-manager-console/src/constants/strategy.ts
+++ b/kafka-manager-console/src/constants/strategy.ts
@@ -67,7 +67,7 @@ export const timeMonthStr = 'YYYY/MM';
 // tslint:disable-next-line:max-line-length

 export const indexUrl ={
-  indexUrl:'https://github.com/didi/kafka-manager',
+  indexUrl:'https://github.com/didi/Logi-KafkaManager/blob/master/docs/user_guide/kafka_metrics_desc.md', // 指标说明
  cagUrl:'https://github.com/didi/Logi-KafkaManager/blob/master/docs/user_guide/add_cluster/add_cluster.md', // 集群接入指南 Cluster access Guide
 } 

--- a/kafka-manager-console/src/constants/table.ts
+++ b/kafka-manager-console/src/constants/table.ts
@@ -19,7 +19,7 @@ export const cellStyle = {
  overflow: 'hidden',
  whiteSpace: 'nowrap',
  textOverflow: 'ellipsis',
-  cursor: 'pointer',
+  // cursor: 'pointer',
 };

 export const searchProps = {
--- a/kafka-manager-console/src/container/admin/cluster-detail/cluster-consumer.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/cluster-consumer.tsx
@@ -38,7 +38,7 @@ export class ClusterConsumer extends SearchAndFilterContainer {
    key: 'operation',
    width: '10%',
    render: (t: string, item: IOffset) => {
-      return (<a onClick={() => this.getConsumeDetails(item)}>详情</a>);
+      return (<a onClick={() => this.getConsumeDetails(item)}>消费详情</a>);
    },
  }];
  private xFormModal: IXFormWrapper;
@@ -100,7 +100,7 @@ export class ClusterConsumer extends SearchAndFilterContainer {
        <div className="k-row">
          <ul className="k-tab">
            <li>{this.props.tab}</li>
-            {this.renderSearch()}
+            {this.renderSearch('', '请输入消费组名称')}
          </ul>
          <Table
            columns={this.columns}
@@ -110,7 +110,7 @@ export class ClusterConsumer extends SearchAndFilterContainer {
          />
        </div>
        <Modal
-          title="消费的Topic"
+          title="消费详情"
          visible={this.state.detailsVisible}
          onOk={() => this.handleDetailsOk()}
          onCancel={() => this.handleDetailsCancel()}
--- a/kafka-manager-console/src/container/admin/cluster-detail/cluster-controller.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/cluster-controller.tsx
@@ -2,7 +2,8 @@
 import * as React from 'react';

 import { SearchAndFilterContainer } from 'container/search-filter';
-import { Table } from 'component/antd';
+import { Table, Button, Popconfirm, Modal, Transfer, notification } from 'component/antd';
+// import { Transfer } from 'antd'
 import { observer } from 'mobx-react';
 import { pagination } from 'constants/table';
 import Url from 'lib/url-parser';
@@ -16,8 +17,12 @@ import { timeFormat } from 'constants/strategy';
 export class ClusterController extends SearchAndFilterContainer {
  public clusterId: number;

-  public state = {
+  public state: any = {
    searchKey: '',
+    searchCandidateKey: '',
+    isCandidateModel: false,
+    mockData: [],
+    targetKeys: [],
  };

  constructor(props: any) {
@@ -37,6 +42,94 @@ export class ClusterController extends SearchAndFilterContainer {
    return data;
  }

+  public getCandidateData<T extends IController>(origin: T[]) {
+    let data: T[] = origin;
+    let { searchCandidateKey } = this.state;
+    searchCandidateKey = (searchCandidateKey + '').trim().toLowerCase();
+
+    data = searchCandidateKey ? origin.filter((item: IController) =>
+      (item.host !== undefined && item.host !== null) && item.host.toLowerCase().includes(searchCandidateKey as string),
+    ) : origin;
+    return data;
+  }
+
+  // 候选controller
+  public renderCandidateController() {
+    const columns = [
+      {
+        title: 'BrokerId',
+        dataIndex: 'brokerId',
+        key: 'brokerId',
+        width: '20%',
+        sorter: (a: IController, b: IController) => b.brokerId - a.brokerId,
+        render: (r: string, t: IController) => {
+          return (
+            <a href={`${this.urlPrefix}/admin/broker-detail?clusterId=${this.clusterId}&brokerId=${t.brokerId}`}>{r}
+            </a>
+          );
+        },
+      },
+      {
+        title: 'BrokerHost',
+        key: 'host',
+        dataIndex: 'host',
+        width: '20%',
+        // render: (r: string, t: IController) => {
+        //   return (
+        //     <a href={`${this.urlPrefix}/admin/broker-detail?clusterId=${this.clusterId}&brokerId=${t.brokerId}`}>{r}
+        //     </a>
+        //   );
+        // },
+      },
+      {
+        title: 'Broker状态',
+        key: 'status',
+        dataIndex: 'status',
+        width: '20%',
+        render: (r: number, t: IController) => {
+          return (
+            <span>{r === 1 ? '不在线' : '在线'}</span>
+          );
+        },
+      },
+      {
+        title: '创建时间',
+        dataIndex: 'startTime',
+        key: 'startTime',
+        width: '25%',
+        sorter: (a: IController, b: IController) => b.timestamp - a.timestamp,
+        render: (t: number) => moment(t).format(timeFormat),
+      },
+      {
+        title: '操作',
+        dataIndex: 'operation',
+        key: 'operation',
+        width: '15%',
+        render: (r: string, t: IController) => {
+          return (
+            <Popconfirm
+              title="确定删除？"
+              onConfirm={() => this.deleteCandidateCancel(t)}
+              cancelText="取消"
+              okText="确认"
+            >
+              <a>删除</a>
+            </Popconfirm>
+          );
+        },
+      },
+    ];
+
+    return (
+      <Table
+        columns={columns}
+        dataSource={this.getCandidateData(admin.controllerCandidate)}
+        pagination={pagination}
+        rowKey="key"
+      />
+    );
+  }
+
  public renderController() {

    const columns = [
@@ -58,12 +151,6 @@ export class ClusterController extends SearchAndFilterContainer {
        key: 'host',
        dataIndex: 'host',
        width: '30%',
-        // render: (r: string, t: IController) => {
-        //   return (
-        //     <a href={`${this.urlPrefix}/admin/broker-detail?clusterId=${this.clusterId}&brokerId=${t.brokerId}`}>{r}
-        //     </a>
-        //   );
-        // },
      },
      {
        title: '变更时间',
@@ -87,16 +174,104 @@ export class ClusterController extends SearchAndFilterContainer {

  public componentDidMount() {
    admin.getControllerHistory(this.clusterId);
+    admin.getCandidateController(this.clusterId);
+    admin.getBrokersMetadata(this.clusterId);
+  }
+
+  public addController = () => {
+    this.setState({ isCandidateModel: true, targetKeys: [] })
+  }
+
+  public addCandidateChange = (targetKeys: any) => {
+    this.setState({ targetKeys })
+  }
+
+
+
+  public handleCandidateCancel = () => {
+    this.setState({ isCandidateModel: false });
+  }
+
+  public handleCandidateOk = () => {
+    let brokerIdList = this.state.targetKeys.map((item: any) => {
+      return admin.brokersMetadata[item].brokerId
+    })
+    admin.addCandidateController(this.clusterId, brokerIdList).then(data => {
+      notification.success({ message: '新增成功' });
+      admin.getCandidateController(this.clusterId);
+    }).catch(err => {
+      notification.error({ message: '新增失败' });
+    })
+    this.setState({ isCandidateModel: false, targetKeys: [] });
+  }
+
+  public deleteCandidateCancel = (target: any) => {
+    admin.deleteCandidateCancel(this.clusterId, [target.brokerId]).then(() => {
+      notification.success({ message: '删除成功' });
+    });
+    this.setState({ isCandidateModel: false });
+  }
+
+  public renderAddCandidateController() {
+    let filterControllerCandidate = admin.brokersMetadata.filter((item: any) => {
+      return !admin.filtercontrollerCandidate.includes(item.brokerId)
+    })
+
+    return (
+      <Modal
+        title="新增候选Controller"
+        visible={this.state.isCandidateModel}
+        // okText="确认"
+        // cancelText="取消"
+        maskClosable={false}
+        // onOk={() => this.handleCandidateOk()}
+        onCancel={() => this.handleCandidateCancel()}
+        footer={<>
+          <Button style={{ width: '60px' }} onClick={() => this.handleCandidateCancel()}>取消</Button>
+          <Button disabled={this.state.targetKeys.length > 0 ? false : true} style={{ width: '60px' }} type="primary" onClick={() => this.handleCandidateOk()}>确定</Button>
+        </>
+        }
+      >
+        <Transfer
+          dataSource={filterControllerCandidate}
+          targetKeys={this.state.targetKeys}
+          render={item => item.host}
+          onChange={(targetKeys) => this.addCandidateChange(targetKeys)}
+          titles={['未选', '已选']}
+          locale={{
+            itemUnit: '项',
+            itemsUnit: '项',
+          }}
+          listStyle={{
+            width: "45%",
+          }}
+        />
+      </Modal>
+    );
  }

  public render() {
    return (
      <div className="k-row">
        <ul className="k-tab">
+          <li>
+            <span>候选Controller</span>
+            <span style={{ display: 'inline-block', color: "#a7a8a9", fontSize: '12px', marginLeft: '15px' }}>Controller将会优先从以下Broker中选举</span>
+          </li>
+          <div style={{ display: 'flex' }}>
+            <div style={{ marginRight: '15px' }}>
+              <Button onClick={() => this.addController()} type='primary'>新增候选Controller</Button>
+            </div>
+            {this.renderSearch('', '请查找Host', 'searchCandidateKey')}
+          </div>
+        </ul>
+        {this.renderCandidateController()}
+        <ul className="k-tab" style={{ marginTop: '10px' }}>
          <li>{this.props.tab}</li>
          {this.renderSearch('', '请输入Host')}
        </ul>
        {this.renderController()}
+        {this.renderAddCandidateController()}
      </div>
    );
  }
--- a/kafka-manager-console/src/container/admin/cluster-detail/cluster-topic.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/cluster-topic.tsx
@@ -2,7 +2,7 @@ import * as React from 'react';
 import Url from 'lib/url-parser';
 import { region } from 'store';
 import { admin } from 'store/admin';
-import { topic } from 'store/topic';
+import { app } from 'store/app';
 import { Table, notification, Tooltip, Popconfirm } from 'antd';
 import { pagination, cellStyle } from 'constants/table';
 import { observer } from 'mobx-react';
@@ -56,8 +56,6 @@ export class ClusterTopic extends SearchAndFilterContainer {
  public expandPartition(item: IClusterTopics) {
    //   getTopicBasicInfo
    admin.getTopicsBasicInfo(item.clusterId, item.topicName).then(data => {
-      console.log(admin.topicsBasic);
-      console.log(admin.basicInfo);
      this.clusterTopicsFrom = item;
      this.setState({
        expandVisible: true,
@@ -114,6 +112,7 @@ export class ClusterTopic extends SearchAndFilterContainer {

  public componentDidMount() {
    admin.getClusterTopics(this.clusterId);
+    app.getAdminAppList()
  }

  public renderClusterTopicList() {
--- a/kafka-manager-console/src/container/admin/cluster-detail/exclusive-cluster.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/exclusive-cluster.tsx
@@ -159,7 +159,6 @@ export class ExclusiveCluster extends SearchAndFilterContainer {

  public handleDeleteRegion = (record: IBrokersRegions) => {
    const filterRegion = admin.logicalClusters.filter(item => item.regionIdList.includes(record.id));
-
    if (!filterRegion) {
      return;
    }
@@ -335,6 +334,7 @@ export class ExclusiveCluster extends SearchAndFilterContainer {
          {this.renderSearch('', '请输入Region名称／broker ID')}
        </ul>
        {this.renderRegion()}
+        {this.renderDeleteRegionModal()}
      </div >
    );
  }
--- a/kafka-manager-console/src/container/admin/cluster-detail/index.less
+++ b/kafka-manager-console/src/container/admin/cluster-detail/index.less
@@ -94,4 +94,10 @@
 .region-prompt{
  font-weight: bold;
  text-align: center;
+}
+
+.asd{
+  display: flex;
+  justify-content: space-around;
+  align-items: center;
 }
--- a/kafka-manager-console/src/container/admin/cluster-detail/index.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/index.tsx
@@ -32,9 +32,9 @@ export class ClusterDetail extends React.Component {
  }

  public render() {
-     let content = {} as IMetaData;
-     content = admin.basicInfo ? admin.basicInfo : content;
-     return (
+    let content = {} as IMetaData;
+    content = admin.basicInfo ? admin.basicInfo : content;
+    return (
      <>
        <PageHeader
          className="detail topic-detail-header"
@@ -46,7 +46,7 @@ export class ClusterDetail extends React.Component {
            <ClusterOverview basicInfo={content} />
          </TabPane>
          <TabPane tab="Topic信息" key="2">
-            <ClusterTopic tab={'Topic信息'}/>
+            <ClusterTopic tab={'Topic信息'} />
          </TabPane>
          <TabPane tab="Broker信息" key="3">
            <ClusterBroker tab={'Broker信息'} basicInfo={content} />
@@ -60,11 +60,11 @@ export class ClusterDetail extends React.Component {
          <TabPane tab="逻辑集群信息" key="6">
            <LogicalCluster tab={'逻辑集群信息'} basicInfo={content} />
          </TabPane>
-          <TabPane tab="Controller变更历史" key="7">
+          <TabPane tab="Controller信息" key="7">
            <ClusterController tab={'Controller变更历史'} />
          </TabPane>
-          <TabPane tab="限流信息"  key="8">
-            <CurrentLimiting tab={'限流信息'}/>
+          <TabPane tab="限流信息" key="8">
+            <CurrentLimiting tab={'限流信息'} />
          </TabPane>
        </Tabs>
      </>
--- a/kafka-manager-console/src/container/admin/cluster-detail/logical-cluster.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-detail/logical-cluster.tsx
@@ -40,15 +40,15 @@ export class LogicalCluster extends SearchAndFilterContainer {
        key: 'logicalClusterId',
      },
      {
-        title: '逻辑集群中文名称',
+        title: '逻辑集群名称',
        dataIndex: 'logicalClusterName',
        key: 'logicalClusterName',
        width: '150px'
      },
      {
-        title: '逻辑集群英文名称',
-        dataIndex: 'logicalClusterName',
-        key: 'logicalClusterName1',
+        title: '逻辑集群标识',
+        dataIndex: 'logicalClusterIdentification',
+        key: 'logicalClusterIdentification',
        width: '150px'
      },
      {
--- a/kafka-manager-console/src/container/admin/cluster-list/index.tsx
+++ b/kafka-manager-console/src/container/admin/cluster-list/index.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { Modal, Table, Button, notification, message, Tooltip, Icon, Popconfirm, Alert } from 'component/antd';
+import { Modal, Table, Button, notification, message, Tooltip, Icon, Popconfirm, Alert, Popover } from 'component/antd';
 import { wrapper } from 'store';
 import { observer } from 'mobx-react';
 import { IXFormWrapper, IMetaData, IRegister } from 'types/base-type';
@@ -12,6 +12,7 @@ import { urlPrefix } from 'constants/left-menu';
 import { indexUrl } from 'constants/strategy'
 import { region } from 'store';
 import './index.less';
+import Monacoeditor from 'component/editor/monacoEditor';
 import { getAdminClusterColumns } from '../config';

 const { confirm } = Modal;
@@ -58,7 +59,7 @@ export class ClusterList extends SearchAndFilterContainer {
            message: '请输入zookeeper地址',
          }],
          attrs: {
-            placeholder: '请输入zookeeper地址',
+            placeholder: '请输入zookeeper地址，例如：192.168.0.1:2181,192.168.0.2:2181/logi-kafka',
            rows: 2,
            disabled: item ? true : false,
          },
@@ -72,7 +73,7 @@ export class ClusterList extends SearchAndFilterContainer {
            message: '请输入bootstrapServers',
          }],
          attrs: {
-            placeholder: '请输入bootstrapServers',
+            placeholder: '请输入bootstrapServers，例如：192.168.1.1:9092,192.168.1.2:9092',
            rows: 2,
            disabled: item ? true : false,
          },
@@ -131,7 +132,26 @@ export class ClusterList extends SearchAndFilterContainer {
 { 
  "security.protocol": "SASL_PLAINTEXT", 
  "sasl.mechanism": "PLAIN", 
-  "sasl.jaas.config": "org.apache.kafka.common.security.plain.PlainLoginModule required username=\"xxxxxx\" password=\"xxxxxx\";"
+  "sasl.jaas.config": "org.apache.kafka.common.security.plain.PlainLoginModule required username=\\"xxxxxx\\" password=\\"xxxxxx\\";"
+}`,
+            rows: 8,
+          },
+        },
+        {
+          key: 'jmxProperties',
+          label: 'JMX认证',
+          type: 'text_area',
+          rules: [{
+            required: false,
+            message: '请输入JMX认证',
+          }],
+          attrs: {
+            placeholder: `请输入JMX认证，例如：
+{
+"maxConn": 10, #KM对单台Broker对最大连接数
+"username": "xxxxx", #用户名
+"password": "xxxxx", #密码
+"openSSL": true, #开启SSL，true表示开启SSL，false表示关闭
 }`,
            rows: 8,
          },
@@ -271,11 +291,13 @@ export class ClusterList extends SearchAndFilterContainer {
            cancelText="取消"
            okText="确认"
          >
-            <a
-              className="action-button"
-            >
-              {item.status === 1 ? '暂停监控' : '开始监控'}
-            </a>
+            <Tooltip title="暂停监控将无法正常监控指标信息，建议开启监控">
+              <a
+                className="action-button"
+              >
+                {item.status === 1 ? '暂停监控' : '开始监控'}
+              </a>
+            </Tooltip>
          </Popconfirm>
          <a onClick={this.showMonitor.bind(this, item)}>
            删除
--- a/kafka-manager-console/src/container/admin/config.tsx
+++ b/kafka-manager-console/src/container/admin/config.tsx
@@ -1,8 +1,8 @@
 import * as React from 'react';
-import { IUser, IUploadFile, IConfigure, IMetaData, IBrokersPartitions } from 'types/base-type';
+import { IUser, IUploadFile, IConfigure, IConfigGateway, IMetaData } from 'types/base-type';
 import { users } from 'store/users';
 import { version } from 'store/version';
-import { showApplyModal, showModifyModal, showConfigureModal } from 'container/modal/admin';
+import { showApplyModal, showApplyModalModifyPassword, showModifyModal, showConfigureModal, showConfigGatewayModal } from 'container/modal/admin';
 import { Popconfirm, Tooltip } from 'component/antd';
 import { admin } from 'store/admin';
 import { cellStyle } from 'constants/table';
@@ -27,6 +27,7 @@ export const getUserColumns = () => {
        return (
          <span className="table-operation">
            <a onClick={() => showApplyModal(record)}>编辑</a>
+            <a onClick={() => showApplyModalModifyPassword(record)}>修改密码</a>
            <Popconfirm
              title="确定删除？"
              onConfirm={() => users.deleteUser(record.username)}
@@ -184,6 +185,87 @@ export const getConfigureColumns = () => {
  return columns;
 };

+// 网关配置
+export const getConfigColumns = () => {
+  const columns = [
+    {
+      title: '配置类型',
+      dataIndex: 'type',
+      key: 'type',
+      width: '25%',
+      ellipsis: true,
+      sorter: (a: IConfigGateway, b: IConfigGateway) => a.type.charCodeAt(0) - b.type.charCodeAt(0),
+    },
+    {
+      title: '配置键',
+      dataIndex: 'name',
+      key: 'name',
+      width: '15%',
+      ellipsis: true,
+      sorter: (a: IConfigGateway, b: IConfigGateway) => a.name.charCodeAt(0) - b.name.charCodeAt(0),
+    },
+    {
+      title: '配置值',
+      dataIndex: 'value',
+      key: 'value',
+      width: '20%',
+      ellipsis: true,
+      sorter: (a: IConfigGateway, b: IConfigGateway) => a.value.charCodeAt(0) - b.value.charCodeAt(0),
+      render: (t: string) => {
+        return t.substr(0, 1) === '{' && t.substr(0, -1) === '}' ? JSON.stringify(JSON.parse(t), null, 4) : t;
+      },
+    },
+    {
+      title: '修改时间',
+      dataIndex: 'modifyTime',
+      key: 'modifyTime',
+      width: '15%',
+      sorter: (a: IConfigGateway, b: IConfigGateway) => b.modifyTime - a.modifyTime,
+      render: (t: number) => moment(t).format(timeFormat),
+    },
+    {
+      title: '版本号',
+      dataIndex: 'version',
+      key: 'version',
+      width: '10%',
+      ellipsis: true,
+      sorter: (a: IConfigGateway, b: IConfigGateway) => b.version.charCodeAt(0) - a.version.charCodeAt(0),
+    },
+    {
+      title: '描述信息',
+      dataIndex: 'description',
+      key: 'description',
+      width: '20%',
+      ellipsis: true,
+      onCell: () => ({
+        style: {
+          maxWidth: 180,
+          ...cellStyle,
+        },
+      }),
+    },
+    {
+      title: '操作',
+      width: '10%',
+      render: (text: string, record: IConfigGateway) => {
+        return (
+          <span className="table-operation">
+            <a onClick={() => showConfigGatewayModal(record)}>编辑</a>
+            <Popconfirm
+              title="确定删除？"
+              onConfirm={() => admin.deleteConfigGateway({ id: record.id })}
+              cancelText="取消"
+              okText="确认"
+            >
+              <a>删除</a>
+            </Popconfirm>
+          </span>);
+      },
+    },
+  ];
+  return columns;
+};
+
 const renderClusterHref = (value: number | string, item: IMetaData, key: number) => {
  return ( // 0 暂停监控--不可点击  1 监控中---可正常点击
    <>
--- a/kafka-manager-console/src/container/admin/configure-management.tsx
+++ b/kafka-manager-console/src/container/admin/configure-management.tsx
@@ -3,11 +3,11 @@ import { SearchAndFilterContainer } from 'container/search-filter';
 import { Table, Button, Spin } from 'component/antd';
 import { admin } from 'store/admin';
 import { observer } from 'mobx-react';
-import { IConfigure } from 'types/base-type';
+import { IConfigure, IConfigGateway } from 'types/base-type';
 import { users } from 'store/users';
 import { pagination } from 'constants/table';
-import { getConfigureColumns } from './config';
-import { showConfigureModal } from 'container/modal/admin';
+import { getConfigureColumns, getConfigColumns } from './config';
+import { showConfigureModal, showConfigGatewayModal } from 'container/modal/admin';

@observer
 export class ConfigureManagement extends SearchAndFilterContainer {
@@ -17,7 +17,12 @@ export class ConfigureManagement extends SearchAndFilterContainer {
  };

  public componentDidMount() {
-    admin.getConfigure();
+    if (this.props.isShow) {
+      admin.getGatewayList();
+      admin.getGatewayType();
+    } else {
+      admin.getConfigure();
+    }
  }

  public getData<T extends IConfigure>(origin: T[]) {
@@ -34,15 +39,34 @@ export class ConfigureManagement extends SearchAndFilterContainer {
    return data;
  }

+  public getGatewayData<T extends IConfigGateway>(origin: T[]) {
+    let data: T[] = origin;
+    let { searchKey } = this.state;
+    searchKey = (searchKey + '').trim().toLowerCase();
+
+    data = searchKey ? origin.filter((item: IConfigGateway) =>
+      ((item.name !== undefined && item.name !== null) && item.name.toLowerCase().includes(searchKey as string))
+      || ((item.value !== undefined && item.value !== null) && item.value.toLowerCase().includes(searchKey as string))
+      || ((item.description !== undefined && item.description !== null) &&
+        item.description.toLowerCase().includes(searchKey as string)),
+    ) : origin;
+    return data;
+  }
+
  public renderTable() {
    return (
      <Spin spinning={users.loading}>
-        <Table
+        {this.props.isShow ? <Table
+          rowKey="key"
+          columns={getConfigColumns()}
+          dataSource={this.getGatewayData(admin.configGatewayList)}
+          pagination={pagination}
+        /> : <Table
          rowKey="key"
          columns={getConfigureColumns()}
          dataSource={this.getData(admin.configureList)}
          pagination={pagination}
-        />
+        />}
      </Spin>

    );
@@ -53,7 +77,7 @@ export class ConfigureManagement extends SearchAndFilterContainer {
      <ul>
        {this.renderSearch('', '请输入配置键、值或描述')}
        <li className="right-btn-1">
-          <Button type="primary" onClick={() => showConfigureModal()}>增加配置</Button>
+          <Button type="primary" onClick={() => this.props.isShow ? showConfigGatewayModal() : showConfigureModal()}>增加配置</Button>
        </li>
      </ul>
    );
--- a/kafka-manager-console/src/container/admin/data-curve/index.tsx
+++ b/kafka-manager-console/src/container/admin/data-curve/index.tsx
@@ -6,6 +6,7 @@ import { curveKeys, CURVE_KEY_MAP, PERIOD_RADIO_MAP, PERIOD_RADIO } from './conf
 import moment = require('moment');
 import { observer } from 'mobx-react';
 import { timeStampStr } from 'constants/strategy';
+import { adminMonitor } from 'store/admin-monitor';

@observer
 export class DataCurveFilter extends React.Component {
@@ -21,6 +22,7 @@ export class DataCurveFilter extends React.Component {
  }

  public refreshAll = () => {
+    adminMonitor.setRequestId(null);
    Object.keys(curveKeys).forEach((c: curveKeys) => {
      const { typeInfo, curveInfo: option } = CURVE_KEY_MAP.get(c);
      const { parser } = typeInfo;
@@ -32,7 +34,7 @@ export class DataCurveFilter extends React.Component {
    return (
      <>
        <Radio.Group onChange={this.radioChange} defaultValue={curveInfo.periodKey}>
-        {PERIOD_RADIO.map(p => <Radio.Button key={p.key} value={p.key}>{p.label}</Radio.Button>)}
+          {PERIOD_RADIO.map(p => <Radio.Button key={p.key} value={p.key}>{p.label}</Radio.Button>)}
        </Radio.Group>
        <DatePicker.RangePicker
          format={timeStampStr}
--- a/kafka-manager-console/src/container/admin/individual-bill.tsx
+++ b/kafka-manager-console/src/container/admin/individual-bill.tsx
@@ -79,7 +79,7 @@ export class IndividualBill extends React.Component {
  }

  public renderTableList() {
-    const adminUrl=`${urlPrefix}/admin/bill-detail`
+    const adminUrl = `${urlPrefix}/admin/bill-detail`
    return (
      <Table
        rowKey="key"
@@ -89,11 +89,11 @@ export class IndividualBill extends React.Component {
      />
    );
  }
-  
+
  public renderChart() {
    return (
      <div className="chart-box">
-        <BarChartComponet ref={(ref) => this.chart = ref } getChartData={this.getData.bind(this, null)} />
+        <BarChartComponet ref={(ref) => this.chart = ref} getChartData={this.getData.bind(this, null)} />
      </div>
    );
  }
@@ -132,7 +132,7 @@ export class IndividualBill extends React.Component {
      <>
        <div className="container">
          <Tabs defaultActiveKey="1" type="card">
-            <TabPane 
+            <TabPane
              tab={<>
                <span>账单趋势</span>&nbsp;
                <a
@@ -142,7 +142,7 @@ export class IndividualBill extends React.Component {
                >
                  <Icon type="question-circle" />
                </a>
-              </>}  
+              </>}
              key="1"
            >
              {this.renderDatePick()}
--- a/kafka-manager-console/src/container/admin/platform-management.tsx
+++ b/kafka-manager-console/src/container/admin/platform-management.tsx
@@ -13,17 +13,20 @@ export class PlatformManagement extends React.Component {
  public render() {
    return (
      <>
-      <Tabs activeKey={location.hash.substr(1) || '1'} type="card" onChange={handleTabKey}>
-        <TabPane tab="应用管理" key="1">
-          <AdminAppList />
-        </TabPane>
-        <TabPane tab="用户管理" key="2">
-          <UserManagement />
-        </TabPane>
-        <TabPane tab="配置管理" key="3">
-          <ConfigureManagement />
-        </TabPane>
-      </Tabs>
+        <Tabs activeKey={location.hash.substr(1) || '1'} type="card" onChange={handleTabKey}>
+          <TabPane tab="应用管理" key="1">
+            <AdminAppList />
+          </TabPane>
+          <TabPane tab="用户管理" key="2">
+            <UserManagement />
+          </TabPane>
+          <TabPane tab="平台配置" key="3">
+            <ConfigureManagement isShow={false} />
+          </TabPane>
+          <TabPane tab="网关配置" key="4">
+            <ConfigureManagement isShow={true} />
+          </TabPane>
+        </Tabs>
      </>
    );
  }
--- a/kafka-manager-console/src/container/admin/user-management.tsx
+++ b/kafka-manager-console/src/container/admin/user-management.tsx
@@ -29,7 +29,7 @@ export class UserManagement extends SearchAndFilterContainer {
    searchKey = (searchKey + '').trim().toLowerCase();

    data = searchKey ? origin.filter((item: IUser) =>
-      (item.username !== undefined && item.username !== null) && item.username.toLowerCase().includes(searchKey as string)) : origin ;
+      (item.username !== undefined && item.username !== null) && item.username.toLowerCase().includes(searchKey as string)) : origin;
    return data;
  }

--- a/kafka-manager-console/src/container/alarm/add-alarm/alarm-select.tsx
+++ b/kafka-manager-console/src/container/alarm/add-alarm/alarm-select.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { alarm } from 'store/alarm';
 import { IMonitorGroups } from 'types/base-type';
-import { getValueFromLocalStorage, setValueToLocalStorage } from 'lib/local-storage';
+import { getValueFromLocalStorage, setValueToLocalStorage, deleteValueFromLocalStorage } from 'lib/local-storage';
 import { VirtualScrollSelect } from '../../../component/virtual-scroll-select';

 interface IAlarmSelectProps {
@@ -36,6 +36,10 @@ export class AlarmSelect extends React.Component<IAlarmSelectProps> {
    onChange && onChange(params);
  }

+  public componentWillUnmount() {
+    deleteValueFromLocalStorage('monitorGroups');
+  }
+
  public render() {
    const { value, isDisabled } = this.props;
    return (
--- a/kafka-manager-console/src/container/alarm/add-alarm/filter-form.tsx
+++ b/kafka-manager-console/src/container/alarm/add-alarm/filter-form.tsx
@@ -11,6 +11,7 @@ import { filterKeys } from 'constants/strategy';
 import { VirtualScrollSelect } from 'component/virtual-scroll-select';
 import { IsNotNaN } from 'lib/utils';
 import { searchProps } from 'constants/table';
+import { toJS } from 'mobx';

 interface IDynamicProps {
  form?: any;
@@ -33,6 +34,7 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
  public monitorType: string = null;
  public clusterId: number = null;
  public clusterName: string = null;
+  public clusterIdentification: string | number = null;
  public topicName: string = null;
  public consumerGroup: string = null;
  public location: string = null;
@@ -45,16 +47,18 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
    this.props.form.validateFields((err: Error, values: any) => {
      if (!err) {
        monitorType = values.monitorType;
-        const index = cluster.clusterData.findIndex(item => item.clusterId === values.cluster);
+        const index = cluster.clusterData.findIndex(item => item.clusterIdentification === values.cluster);
        if (index > -1) {
+          values.clusterIdentification = cluster.clusterData[index].clusterIdentification;
          values.clusterName = cluster.clusterData[index].clusterName;
        }
        for (const key of Object.keys(values)) {
          if (filterKeys.indexOf(key) > -1) { // 只有这几种值可以设置
            filterList.push({
-              tkey: key === 'clusterName' ? 'cluster' : key, // 传参需要将clusterName转成cluster
+              tkey: key === 'clusterName' ? 'cluster' : key, // clusterIdentification
              topt: '=',
              tval: [values[key]],
+              clusterIdentification: values.clusterIdentification
            });
          }
        }
@@ -74,13 +78,13 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {

  public resetFormValue(
    monitorType: string = null,
-    clusterId: number = null,
+    clusterIdentification: any = null,
    topicName: string = null,
    consumerGroup: string = null,
    location: string = null) {
    const { setFieldsValue } = this.props.form;
    setFieldsValue({
-      cluster: clusterId,
+      cluster: clusterIdentification,
      topic: topicName,
      consumerGroup,
      location,
@@ -88,18 +92,18 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
    });
  }

-  public getClusterId = (clusterName: string) => {
+  public getClusterId = async (clusterIdentification: any) => {
    let clusterId = null;
-    const index = cluster.clusterData.findIndex(item => item.clusterName === clusterName);
+    const index = cluster.clusterData.findIndex(item => item.clusterIdentification === clusterIdentification);
    if (index > -1) {
      clusterId = cluster.clusterData[index].clusterId;
    }
    if (clusterId) {
-      cluster.getClusterMetaTopics(clusterId);
+      await cluster.getClusterMetaTopics(clusterId);
      this.clusterId = clusterId;
      return this.clusterId;
-    }
-    return this.clusterId = clusterName as any;
+    };
+    return this.clusterId = clusterId as any;
  }

  public async initFormValue(monitorRule: IRequestParams) {
@@ -108,17 +112,19 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
    const topicFilter = strategyFilterList.filter(item => item.tkey === 'topic')[0];
    const consumerFilter = strategyFilterList.filter(item => item.tkey === 'consumerGroup')[0];

-    const clusterName = clusterFilter ? clusterFilter.tval[0] : null;
+    const clusterIdentification = clusterFilter ? clusterFilter.tval[0] : null;
    const topic = topicFilter ? topicFilter.tval[0] : null;
    const consumerGroup = consumerFilter ? consumerFilter.tval[0] : null;
    const location: string = null;
    const monitorType = monitorRule.strategyExpressionList[0].metric;
    alarm.changeMonitorStrategyType(monitorType);
-
-    await this.getClusterId(clusterName);
+    //增加clusterIdentification替代原来的clusterName
+    this.clusterIdentification = clusterIdentification;
+    await this.getClusterId(this.clusterIdentification);
+    //
    await this.handleSelectChange(topic, 'topic');
    await this.handleSelectChange(consumerGroup, 'consumerGroup');
-    this.resetFormValue(monitorType, this.clusterId, topic, consumerGroup, location);
+    this.resetFormValue(monitorType, this.clusterIdentification, topic, consumerGroup, location);
  }

  public clearFormData() {
@@ -130,11 +136,12 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
    this.resetFormValue();
  }

-  public async handleClusterChange(e: number) {
-    this.clusterId = e;
+  public async handleClusterChange(e: any) {
+    this.clusterIdentification = e;
    this.topicName = null;
    topic.setLoading(true);
-    await cluster.getClusterMetaTopics(e);
+    const clusterId = await this.getClusterId(e);
+    await cluster.getClusterMetaTopics(clusterId);
    this.resetFormValue(this.monitorType, e, null, this.consumerGroup, this.location);
    topic.setLoading(false);
  }
@@ -170,7 +177,7 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
    }
    this.consumerGroup = null;
    this.location = null;
-    this.resetFormValue(this.monitorType, this.clusterId, this.topicName);
+    this.resetFormValue(this.monitorType, this.clusterIdentification, this.topicName);
    topic.setLoading(false);
  }

@@ -213,17 +220,24 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
      },
      rules: [{ required: true, message: '请选择监控指标' }],
    } as IVritualScrollSelect;
+    const clusterData = toJS(cluster.clusterData);
+    const options = clusterData?.length ? clusterData.map(item => {
+      return {
+        label: `${item.clusterName}${item.description ? '（' + item.description + '）' : ''}`,
+        value: item.clusterIdentification
+      }
+    }) : null;

    const clusterItem = {
      label: '集群',
-      options: cluster.clusterData,
-      defaultValue: this.clusterId,
+      options,
+      defaultValue: this.clusterIdentification,
      rules: [{ required: true, message: '请选择集群' }],
      attrs: {
        placeholder: '请选择集群',
-        className: 'middle-size',
+        className: 'large-size',
        disabled: this.isDetailPage,
-        onChange: (e: number) => this.handleClusterChange(e),
+        onChange: (e: any) => this.handleClusterChange(e),
      },
      key: 'cluster',
    } as unknown as IVritualScrollSelect;
@@ -241,7 +255,7 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
      }),
      attrs: {
        placeholder: '请选择Topic',
-        className: 'middle-size',
+        className: 'large-size',
        disabled: this.isDetailPage,
        onChange: (e: string) => this.handleSelectChange(e, 'topic'),
      },
@@ -329,7 +343,7 @@ export class DynamicSetFilter extends React.Component<IDynamicProps> {
            key={v.value || v.key || index}
            value={v.value}
          >
-            {v.label.length > 25 ? <Tooltip placement="bottomLeft" title={v.label}>
+            {v.label?.length > 25 ? <Tooltip placement="bottomLeft" title={v.label}>
              {v.label}
            </Tooltip> : v.label}
          </Select.Option>
--- a/kafka-manager-console/src/container/alarm/add-alarm/index.less
+++ b/kafka-manager-console/src/container/alarm/add-alarm/index.less
@@ -43,21 +43,23 @@
    Icon {
      margin-left: 8px;
    }
+    .ant-form-item-label {
+      // padding-left: 10px;
+      width: 118px;
+      text-align: right !important;
+    }

    &.type-form {
-      padding-top: 10px; 
+      padding-top: 10px;
      .ant-form{
        min-width: 755px;
      }
      .ant-form-item {
-        width: 30%;
+        width: 45%;
        min-width: 360px;
      }
-      .ant-form-item-label {
-        padding-left: 10px;
-      }
      .ant-form-item-control {
-        width: 220px;
+        width: 300px;
      }
    }

--- a/kafka-manager-console/src/container/alarm/add-alarm/index.tsx
+++ b/kafka-manager-console/src/container/alarm/add-alarm/index.tsx
@@ -12,7 +12,6 @@ import { alarm } from 'store/alarm';
 import { app } from 'store/app';
 import Url from 'lib/url-parser';
 import { IStrategyExpression, IRequestParams } from 'types/alarm';
-
@observer
 export class AddAlarm extends SearchAndFilterContainer {
  public isDetailPage = window.location.pathname.includes('/alarm-detail'); // 判断是否为详情
@@ -90,8 +89,8 @@ export class AddAlarm extends SearchAndFilterContainer {
    const filterObj = this.typeForm.getFormData().filterObj;
    // tslint:disable-next-line:max-line-length
    if (!actionValue || !timeValue || !typeValue || !strategyList.length || !filterObj || !filterObj.filterList.length) {
-       message.error('请正确填写必填项');
-       return null;
+      message.error('请正确填写必填项');
+      return null;
    }

    if (filterObj.monitorType === 'online-kafka-topic-throttled') {
@@ -101,13 +100,17 @@ export class AddAlarm extends SearchAndFilterContainer {
        tval: [typeValue.app],
      });
    }
+    this.id && filterObj.filterList.forEach((item: any) => {
+      if (item.tkey === 'cluster') {
+        item.tval = [item.clusterIdentification]
+      }
+    })
    strategyList = strategyList.map((row: IStrategyExpression) => {
      return {
        ...row,
        metric: filterObj.monitorType,
      };
    });
-
    return {
      appId: typeValue.app,
      name: typeValue.alarmName,
@@ -129,7 +132,7 @@ export class AddAlarm extends SearchAndFilterContainer {
  public renderAlarmStrategy() {
    return (
      <div className="config-wrapper">
-        <span className="span-tag">报警策略</span>
+        <span className="span-tag" data-set={alarm.monitorType}>报警策略</span>
        <div className="info-wrapper">
          <WrappedDynamicSetStrategy wrappedComponentRef={(form: any) => this.strategyForm = form} />
        </div>
@@ -139,9 +142,9 @@ export class AddAlarm extends SearchAndFilterContainer {

  public renderTimeForm() {
    return (
-     <>
-      <WrappedTimeForm wrappedComponentRef={(form: any) => this.timeForm = form} />
-     </>
+      <>
+        <WrappedTimeForm wrappedComponentRef={(form: any) => this.timeForm = form} />
+      </>
    );
  }

@@ -164,7 +167,7 @@ export class AddAlarm extends SearchAndFilterContainer {
          {this.renderAlarmStrategy()}
          {this.renderTimeForm()}
          <ActionForm ref={(actionForm) => this.actionForm = actionForm} />
-          </div>
+        </div>
      </Spin>
    );
  }
--- a/kafka-manager-console/src/container/alarm/add-alarm/strategy-form.tsx
+++ b/kafka-manager-console/src/container/alarm/add-alarm/strategy-form.tsx
@@ -5,6 +5,7 @@ import { IStringMap } from 'types/base-type';
 import { IRequestParams } from 'types/alarm';
 import { IFormSelect, IFormItem, FormItemType } from 'component/x-form';
 import { searchProps } from 'constants/table';
+import { alarm } from 'store/alarm';

 interface IDynamicProps {
  form: any;
@@ -27,6 +28,7 @@ class DynamicSetStrategy extends React.Component<IDynamicProps> {
  public crudList = [] as ICRUDItem[];
  public state = {
    shouldUpdate: false,
+    monitorType: alarm.monitorType
  };

  public componentDidMount() {
@@ -130,7 +132,7 @@ class DynamicSetStrategy extends React.Component<IDynamicProps> {

          if (lineValue.func === 'happen' && paramsArray.length > 1 && paramsArray[0] < paramsArray[1]) {
            strategyList = []; // 清空赋值
-            return message.error('周期值应大于次数') ;
+            return message.error('周期值应大于次数');
          }

          lineValue.params = paramsArray.join(',');
@@ -292,8 +294,39 @@ class DynamicSetStrategy extends React.Component<IDynamicProps> {
    }
    return element;
  }
-
-  public renderFormList(row: ICRUDItem) {
+  public unit(monitorType: string) {
+    let element = null;
+    switch (monitorType) {
+      case 'online-kafka-topic-msgIn':
+        element = "条/秒"
+        break;
+      case 'online-kafka-topic-bytesIn':
+        element = "字节/秒"
+        break;
+      case 'online-kafka-topic-bytesRejected':
+        element = "字节/秒"
+        break;
+      case 'online-kafka-topic-produce-throttled':
+        element = "1表示被限流"
+        break;
+      case 'online-kafka-topic-fetch-throttled':
+        element = "1表示被限流"
+        break;
+      case 'online-kafka-consumer-maxLag':
+        element = "条"
+        break;
+      case 'online-kafka-consumer-lag':
+        element = "条"
+        break;
+      case 'online-kafka-consumer-maxDelayTime':
+        element = "秒"
+        break;
+    }
+    return (
+      <span>{element}</span>
+    )
+  }
+  public renderFormList(row: ICRUDItem, monitorType: string) {
    const key = row.id;
    const funcType = row.func;

@@ -309,6 +342,7 @@ class DynamicSetStrategy extends React.Component<IDynamicProps> {
          key: key + '-func',
        } as IFormSelect)}
        {this.getFuncItem(row)}
+        {row.func !== 'c_avg_rate_abs' && row.func !== 'pdiff' ? this.unit(monitorType) : null}
      </div>
    );
  }
@@ -340,8 +374,8 @@ class DynamicSetStrategy extends React.Component<IDynamicProps> {
      <Form>
        {crudList.map((row, index) => {
          return (
-            <div key={index}>
-              {this.renderFormList(row)}
+            <div key={`${index}-${this.state.monitorType}`}>
+              {this.renderFormList(row, alarm.monitorType)}
              {
                crudList.length > 1 ? (
                  <Icon
--- a/kafka-manager-console/src/container/alarm/add-alarm/type-form.tsx
+++ b/kafka-manager-console/src/container/alarm/add-alarm/type-form.tsx
@@ -50,23 +50,23 @@ export class TypeForm extends React.Component {

    return (
      <>
-      <div className="config-wrapper">
-        <span className="span-tag">基本信息</span>
-        <div className="alarm-x-form type-form">
-          <XFormComponent
-            ref={form => this.$form = form}
-            formData={formData}
-            formMap={xTypeFormMap}
-            layout="inline"
-          />
-        </div>
-      </div >
-      <div className="config-wrapper">
-        <span className="span-tag">选择指标</span>
-        <div className="alarm-x-form type-form">
-          <WrappedDynamicSetFilter wrappedComponentRef={(form: any) => this.filterForm = form} />
-        </div>
-      </div >
+        <div className="config-wrapper">
+          <span className="span-tag">基本信息</span>
+          <div className="alarm-x-form type-form">
+            <XFormComponent
+              ref={form => this.$form = form}
+              formData={formData}
+              formMap={xTypeFormMap}
+              layout="inline"
+            />
+          </div>
+        </div >
+        <div className="config-wrapper">
+          <span className="span-tag">选择指标</span>
+          <div className="alarm-x-form type-form">
+            <WrappedDynamicSetFilter wrappedComponentRef={(form: any) => this.filterForm = form} />
+          </div>
+        </div >
      </>
    );
  }
--- a/kafka-manager-console/src/container/alarm/alarm-list.tsx
+++ b/kafka-manager-console/src/container/alarm/alarm-list.tsx
@@ -9,6 +9,7 @@ import { pagination } from 'constants/table';
 import { urlPrefix } from 'constants/left-menu';
 import { alarm } from 'store/alarm';
 import 'styles/table-filter.less';
+import { Link } from 'react-router-dom';

@observer
 export class AlarmList extends SearchAndFilterContainer {
@@ -24,7 +25,7 @@ export class AlarmList extends SearchAndFilterContainer {
    if (app.active !== '-1' || searchKey !== '') {
      data = origin.filter(d =>
        ((d.name !== undefined && d.name !== null) && d.name.toLowerCase().includes(searchKey as string)
-        || ((d.operator !== undefined && d.operator !== null) && d.operator.toLowerCase().includes(searchKey as string)))
+          || ((d.operator !== undefined && d.operator !== null) && d.operator.toLowerCase().includes(searchKey as string)))
        && (app.active === '-1' || d.appId === (app.active + '')),
      );
    } else {
@@ -55,9 +56,7 @@ export class AlarmList extends SearchAndFilterContainer {
        {this.renderSearch('名称：', '请输入告警规则或者操作人')}
        <li className="right-btn-1">
          <Button type="primary">
-            <a href={`${urlPrefix}/alarm/add`}>
-              新增规则
-            </a>
+            <Link to={`/alarm/add`}>新增规则</Link>
          </Button>
        </li>
      </>
@@ -68,6 +67,9 @@ export class AlarmList extends SearchAndFilterContainer {
    if (!alarm.monitorStrategies.length) {
      alarm.getMonitorStrategies();
    }
+    if (!app.data.length) {
+      app.getAppList();
+    }
  }

  public render() {
--- a/kafka-manager-console/src/container/cluster/cluster-detail/cluster-overview.tsx
+++ b/kafka-manager-console/src/container/cluster/cluster-detail/cluster-overview.tsx
@@ -31,11 +31,11 @@ export class ClusterOverview extends React.Component<IOverview> {
    const content = this.props.basicInfo as IBasicInfo;
    const clusterContent = [{
      value: content.clusterName,
-      label: '集群中文名称',
+      label: '集群名称',
    },
    {
-      value: content.clusterName,
-      label: '集群英文名称',
+      value: content.clusterIdentification,
+      label: '集群标识',
    },
    {
      value: clusterTypeMap[content.mode],
@@ -44,8 +44,8 @@ export class ClusterOverview extends React.Component<IOverview> {
      value: moment(content.gmtCreate).format(timeFormat),
      label: '接入时间',
    }, {
-      value: content.physicalClusterId,
-      label: '物理集群ID',
+      value: content.clusterId,
+      label: '集群ID',
    }];
    const clusterInfo = [{
      value: content.clusterVersion,
--- a/kafka-manager-console/src/container/cluster/config.tsx
+++ b/kafka-manager-console/src/container/cluster/config.tsx
@@ -13,32 +13,14 @@ const { confirm } = Modal;
 export const getClusterColumns = (urlPrefix: string) => {
  return [
    {
-      title: '逻辑集群ID',
+      title: '集群ID',
      dataIndex: 'clusterId',
      key: 'clusterId',
      width: '9%',
      sorter: (a: IClusterData, b: IClusterData) => b.clusterId - a.clusterId,
    },
    {
-      title: '逻辑集群中文名称',
-      dataIndex: 'clusterName',
-      key: 'clusterName',
-      width: '13%',
-      onCell: () => ({
-        style: {
-          maxWidth: 120,
-          ...cellStyle,
-        },
-      }),
-      sorter: (a: IClusterData, b: IClusterData) => a.clusterName.charCodeAt(0) - b.clusterName.charCodeAt(0),
-      render: (text: string, record: IClusterData) => (
-        <Tooltip placement="bottomLeft" title={text} >
-          <a href={`${urlPrefix}/cluster/cluster-detail?clusterId=${record.clusterId}`}> {text} </a>
-        </Tooltip>
-      ),
-    },
-    {
-      title: '逻辑集群英文名称',
+      title: '集群名称',
      dataIndex: 'clusterName',
      key: 'clusterName',
      width: '13%',
@@ -55,6 +37,24 @@ export const getClusterColumns = (urlPrefix: string) => {
        </Tooltip>
      ),
    },
+    // {
+    //   title: '逻辑集群英文名称',
+    //   dataIndex: 'clusterName',
+    //   key: 'clusterName',
+    //   width: '13%',
+    //   onCell: () => ({
+    //     style: {
+    //       maxWidth: 120,
+    //       ...cellStyle,
+    //     },
+    //   }),
+    //   sorter: (a: IClusterData, b: IClusterData) => a.clusterName.charCodeAt(0) - b.clusterName.charCodeAt(0),
+    //   render: (text: string, record: IClusterData) => (
+    //     <Tooltip placement="bottomLeft" title={text} >
+    //       <a href={`${urlPrefix}/cluster/cluster-detail?clusterId=${record.clusterId}`}> {text} </a>
+    //     </Tooltip>
+    //   ),
+    // },
    {
      title: 'Topic数量',
      dataIndex: 'topicNum',
--- a/kafka-manager-console/src/container/cluster/my-cluster.tsx
+++ b/kafka-manager-console/src/container/cluster/my-cluster.tsx
@@ -78,7 +78,7 @@ export class MyCluster extends SearchAndFilterContainer {
          rules: [
            {
              required: true,
-              pattern: /^.{5,}.$/,
+              pattern: /^.{4,}.$/,
              message: '请输入至少5个字符',
            },
          ],
@@ -91,7 +91,7 @@ export class MyCluster extends SearchAndFilterContainer {
      ],
      formData: {},
      visible: true,
-      title: '申请集群',
+      title: <div><span>申请集群</span><a className='applicationDocument' href="https://github.com/didi/Logi-KafkaManager/blob/master/docs/user_guide/resource_apply.md" target='_blank'>资源申请文档</a></div>,
      okText: '确认',
      onSubmit: (value: any) => {
        value.idc = region.currentRegion;
@@ -160,7 +160,7 @@ export class MyCluster extends SearchAndFilterContainer {

    data = searchKey ? origin.filter((item: IClusterData) =>
      (item.clusterName !== undefined && item.clusterName !== null) && item.clusterName.toLowerCase().includes(searchKey as string),
-    ) : origin ;
+    ) : origin;
    return data;
  }

--- a/kafka-manager-console/src/container/drawer/data-migration.tsx
+++ b/kafka-manager-console/src/container/drawer/data-migration.tsx
@@ -117,17 +117,17 @@ class DataMigrationFormTable extends React.Component<IFormTableProps> {
      key: 'maxThrottle',
      editable: true,
    }, {
-      title: '迁移保存时间(h)',
+      title: '迁移后Topic保存时间(h)',
      dataIndex: 'reassignRetentionTime',
      key: 'reassignRetentionTime',
      editable: true,
    }, {
-      title: '原本保存时间(h)',
+      title: '原Topic保存时间(h)',
      dataIndex: 'retentionTime',
      key: 'retentionTime', // originalRetentionTime
      width: '132px',
      sorter: (a: IRenderData, b: IRenderData) => b.retentionTime - a.retentionTime,
-      render: (time: any) =>  transMSecondToHour(time),
+      render: (time: any) => transMSecondToHour(time),
    }, {
      title: 'BrokerID',
      dataIndex: 'brokerIdList',
@@ -254,7 +254,7 @@ class DataMigrationFormTable extends React.Component<IFormTableProps> {
            dataSource={this.props.data}
            columns={columns}
            pagination={false}
-            scroll={{y: 520}}
+            scroll={{ y: 520 }}
            className="migration-table"
          />
        </EditableContext.Provider>
@@ -316,7 +316,7 @@ export class InfoForm extends React.Component<IFormTableProps> {
        <Form.Item label="迁移说明" key={2} className="form-item">
          {getFieldDecorator('description', {
            initialValue: '',
-            rules: [{ required: true, message: '请输入至少5个字符', pattern: /^.{5,}.$/ }],
+            rules: [{ required: true, message: '请输入至少5个字符', pattern: /^.{4,}.$/ }],
          })(
            <Input.TextArea rows={5} placeholder="请输入至少5个字符" />,
          )}
--- a/kafka-manager-console/src/container/modal/admin/cluster.ts
+++ b/kafka-manager-console/src/container/modal/admin/cluster.ts
@@ -23,13 +23,22 @@ export const showEditClusterTopic = (item: IClusterTopics) => {
      {
        key: 'appId',
        label: '应用ID',
+        type: 'select',
+        options: app.adminAppData.map(item => {
+          return {
+            label: item.appId,
+            value: item.appId,
+          };
+        }),
        rules: [{
          required: true,
-          message: '请输入应用ID',
+          // message: '请输入应用ID',
+          // message: '请输入应用ID，应用名称只支持字母、数字、下划线、短划线，长度限制在3-64字符',
+          // pattern: /[_a-zA-Z0-9_-]{3,64}$/,
        }],
        attrs: {
          placeholder: '请输入应用ID',
-          disabled: true,
+          // disabled: true,
        },
      },
      {
@@ -52,6 +61,7 @@ export const showEditClusterTopic = (item: IClusterTopics) => {
        attrs: {
          placeholder: '请输入保存时间',
          suffix: '小时',
+          prompttype:'修改保存时间，预计一分钟左右生效!'
        },
      },
      {
@@ -104,7 +114,7 @@ export const showLogicalClusterOpModal = (clusterId: number, record?: ILogicalCl
  }
  const updateFormModal = (isShow: boolean) => {
    const formMap = wrapper.xFormWrapper.formMap;
-    isShow ? formMap.splice(2, 0,
+    isShow ? formMap.splice(3, 0,
      {
        key: 'appId',
        label: '所属应用',
@@ -119,7 +129,7 @@ export const showLogicalClusterOpModal = (clusterId: number, record?: ILogicalCl
        attrs: {
          placeholder: '请选择所属应用',
        },
-      }) : formMap.splice(2, 1);
+      }) : formMap.splice(3, 1);
    const formData = wrapper.xFormWrapper.formData;
    wrapper.ref && wrapper.ref.updateFormMap$(formMap, formData || {});
  };
@@ -129,30 +139,30 @@ export const showLogicalClusterOpModal = (clusterId: number, record?: ILogicalCl
    formMap: [
      {
        key: 'logicalClusterName',
-        label: '逻辑集群中文名称',
+        label: '逻辑集群名称',
        // defaultValue:'',
-        rules: [{ 
-          required: true, 
-          message: '请输入逻辑集群中文名称，支持中文、字母、数字、下划线(_)和短划线(-)组成，长度在3-128字符之间', // 不能以下划线（_）和短划线(-)开头和结尾
+        rules: [{
+          required: true,
+          message: '请输入逻辑集群名称，支持中文、字母、数字、下划线(_)和短划线(-)组成，长度在3-128字符之间', // 不能以下划线（_）和短划线(-)开头和结尾
          pattern: /^[a-zA-Z0-9_\-\u4e00-\u9fa5]{3,128}$/g, //(?!(_|\-))(?!.*?(_|\-)$)
        }],
        attrs: {
          // disabled: record ? true : false,
-          placeholder:'请输入逻辑集群中文名称'
+          placeholder: '请输入逻辑集群名称'
        },
      },
      {
-        key: 'logicalClusterName1',
-        label: '逻辑集群英文名称',
+        key: 'logicalClusterIdentification',
+        label: '逻辑集群标识',
        // defaultValue:'',
-        rules: [{ 
-          required: true, 
-          message: '请输入逻辑集群英文名称，支持字母、数字、下划线(_)和短划线(-)组成，长度在3-128字符之间', //不能以下划线（_）和短划线(-)开头和结尾
-          pattern:/^[a-zA-Z0-9_\-]{3,128}$/g, //(?!(_|\-))(?!.*?(_|\-)$)
+        rules: [{
+          required: true,
+          message: '请输入逻辑集群标识，支持字母、数字、下划线(_)和短划线(-)组成，长度在3-128字符之间', //不能以下划线（_）和短划线(-)开头和结尾
+          pattern: /^[a-zA-Z0-9_\-]{3,128}$/g, //(?!(_|\-))(?!.*?(_|\-)$)
        }],
        attrs: {
          disabled: record ? true : false,
-          placeholder:'请输入逻辑集群英文名称，创建后无法修改'
+          placeholder: '请输入逻辑集标识，创建后无法修改'
        },
      },
      {
@@ -233,7 +243,7 @@ export const showLogicalClusterOpModal = (clusterId: number, record?: ILogicalCl
        id: record ? record.logicalClusterId : '',
        mode: value.mode,
        name: value.logicalClusterName,
-        englishName:value.logicalClusterEName, // 存储逻辑集群英文名称
+        identification: value.logicalClusterIdentification,
        regionIdList: value.regionIdList,
      } as INewLogical;
      if (record) {
@@ -246,7 +256,25 @@ export const showLogicalClusterOpModal = (clusterId: number, record?: ILogicalCl
      });
    },
  };
-
+  if (record && record.mode != 0) {
+    isShow = true;
+    let formMap: any = xFormModal.formMap
+    formMap.splice(3, 0, {
+      key: 'appId',
+      label: '所属应用',
+      rules: [{ required: true, message: '请选择所属应用' }],
+      type: 'select',
+      options: app.adminAppData.map(item => {
+        return {
+          label: item.name,
+          value: item.appId,
+        };
+      }),
+      attrs: {
+        placeholder: '请选择所属应用',
+      },
+    })
+  }
  wrapper.open(xFormModal);
 };

--- a/kafka-manager-console/src/container/modal/admin/expand-partition.tsx
+++ b/kafka-manager-console/src/container/modal/admin/expand-partition.tsx
@@ -50,7 +50,10 @@ class CustomForm extends React.Component<IXFormProps> {
          notification.success({ message: '扩分成功' });
          this.props.form.resetFields();
          admin.getClusterTopics(this.props.clusterId);
-        });
+        }).catch(err => {
+          notification.error({ message: '扩分成功' });
+
+        })
      }
    });
  }
@@ -93,7 +96,7 @@ class CustomForm extends React.Component<IXFormProps> {
          {/* 运维管控-topic信息-扩分区操作 */}
          <Form.Item label="所属region" >
            {getFieldDecorator('regionNameList', {
-              initialValue: admin.topicsBasic ? admin.topicsBasic.regionNameList : '',
+              initialValue: admin.topicsBasic && admin.topicsBasic.regionNameList.length > 0 ? admin.topicsBasic.regionNameList.join(',') : ' ',
              rules: [{ required: true, message: '请输入所属region' }],
            })(<Input disabled={true} />)}
          </Form.Item>
--- a/kafka-manager-console/src/container/modal/admin/task.ts
+++ b/kafka-manager-console/src/container/modal/admin/task.ts
@@ -158,26 +158,26 @@ export const createMigrationTasks = () => {
      },
      {
        key: 'originalRetentionTime',
-        label: '原本保存时间',
+        label: '原Topic保存时间',
        rules: [{
          required: true,
-          message: '请输入原本保存时间',
+          message: '请输入原Topic保存时间',
        }],
        attrs: {
          disabled: true,
-          placeholder: '请输入原本保存时间',
+          placeholder: '请输入原Topic保存时间',
          suffix: '小时',
        },
      },
      {
        key: 'reassignRetentionTime',
-        label: '迁移保存时间',
+        label: '迁移后Topic保存时间',
        rules: [{
          required: true,
-          message: '请输入迁移保存时间',
+          message: '请输入迁移后Topic保存时间',
        }],
        attrs: {
-          placeholder: '请输入迁移保存时间',
+          placeholder: '请输入迁移后Topic保存时间',
          suffix: '小时',
        },
      },
@@ -186,10 +186,10 @@ export const createMigrationTasks = () => {
        label: '初始限流',
        rules: [{
          required: true,
-          message: '请输入初始限流',
+          message: '请输入初始限流，并按照：“限流上限>初始限流>限流下限”的大小顺序',
        }],
        attrs: {
-          placeholder: '请输入初始限流',
+          placeholder: '请输入初始限流，并按照：“限流上限>初始限流>限流下限”的大小顺序',
          suffix: 'MB/s',
        },
      },
@@ -198,10 +198,10 @@ export const createMigrationTasks = () => {
        label: '限流上限',
        rules: [{
          required: true,
-          message: '请输入限流上限',
+          message: '请输入限流上限，并按照：“限流上限>初始限流>限流下限”的大小顺序',
        }],
        attrs: {
-          placeholder: '请输入限流上限',
+          placeholder: '请输入限流上限，并按照：“限流上限>初始限流>限流下限”的大小顺序',
          suffix: 'MB/s',
        },
      },
@@ -210,10 +210,10 @@ export const createMigrationTasks = () => {
        label: '限流下限',
        rules: [{
          required: true,
-          message: '请输入限流下限',
+          message: '请输入限流下限，并按照：“限流上限>初始限流>限流下限”的大小顺序',
        }],
        attrs: {
-          placeholder: '请输入限流下限',
+          placeholder: '请输入限流下限，并按照：“限流上限>初始限流>限流下限”的大小顺序',
          suffix: 'MB/s',
        },
      },
@@ -224,7 +224,7 @@ export const createMigrationTasks = () => {
        rules: [{
          required: false,
          message: '请输入至少5个字符',
-          pattern: /^.{5,}.$/,
+          pattern: /^.{4,}.$/,
        }],
        attrs: {
          placeholder: '请输入备注',
--- a/kafka-manager-console/src/container/modal/admin/user.ts
+++ b/kafka-manager-console/src/container/modal/admin/user.ts
@@ -24,26 +24,111 @@ export const showApplyModal = (record?: IUser) => {
          value: +item,
        })),
        rules: [{ required: true, message: '请选择角色' }],
-      }, {
-        key: 'password',
-        label: '密码',
-        type: FormItemType.inputPassword,
-        rules: [{ required: !record, message: '请输入密码' }],
-      },
+      }, 
+      // {
+      //   key: 'password',
+      //   label: '密码',
+      //   type: FormItemType.inputPassword,
+      //   rules: [{ required: !record, message: '请输入密码' }],
+      // },
    ],
    formData: record || {},
    visible: true,
    title: record ? '修改用户' : '新增用户',
    onSubmit: (value: IUser) => {
      if (record) {
-        return users.modfiyUser(value).then(() => {
-          message.success('操作成功');
-        });
+        return users.modfiyUser(value)
      }
      return users.addUser(value).then(() => {
        message.success('操作成功');
      });
    },
  };
+  if(!record){
+   let formMap: any = xFormModal.formMap
+    formMap.splice(2, 0,{
+        key: 'password',
+        label: '密码',
+        type: FormItemType.inputPassword,
+        rules: [{ required: !record, message: '请输入密码' }],
+      },)
+  }
  wrapper.open(xFormModal);
 };
+
+// const handleCfPassword = (rule:any, value:any, callback:any)=>{
+//   if()
+// }
+export const showApplyModalModifyPassword = (record: IUser) => {
+  const xFormModal:any = {
+    formMap: [
+      // {
+      //   key: 'oldPassword',
+      //   label: '旧密码',
+      //   type: FormItemType.inputPassword,
+      //   rules: [{ 
+      //     required: true, 
+      //     message: '请输入旧密码',
+      //   }]
+      // },
+      {
+        key: 'newPassword',
+        label: '新密码',
+        type: FormItemType.inputPassword,
+        rules: [
+          { 
+            required: true, 
+            message: '请输入新密码',
+          }
+        ],
+        attrs:{
+          onChange:(e:any)=>{
+            users.setNewPassWord(e.target.value)
+          }
+        }
+      }, 
+      {
+        key: 'confirmPassword',
+        label: '确认密码',
+        type: FormItemType.inputPassword,
+        rules: [
+          { 
+            required: true, 
+            message: '请确认密码',
+            validator:(rule:any, value:any, callback:any) => {
+              // 验证新密码的一致性
+              if(users.newPassWord){
+                if(value!==users.newPassWord){
+                  rule.message = "两次密码输入不一致";
+                  callback('两次密码输入不一致')
+                }else{
+                  callback()
+                }
+              }else if(!value){
+                rule.message = "请确认密码";
+                callback('请确认密码');
+              }else{
+                callback()
+              }
+            },
+          }
+        ],
+      },
+    ],
+    formData: record || {},
+    visible: true,
+    title: '修改密码',
+    onSubmit: (value: IUser) => {
+      let params:any = {
+        username:record?.username,
+        password:value.confirmPassword,
+        role:record?.role,
+      }
+      return users.modfiyUser(params).then(() => {
+          message.success('操作成功');
+      });
+    },
+  }
+  wrapper.open(xFormModal);
+};
+
--- a/kafka-manager-console/src/container/modal/admin/version.ts
+++ b/kafka-manager-console/src/container/modal/admin/version.ts
@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { notification } from 'component/antd';
-import { IUploadFile, IConfigure } from 'types/base-type';
+import { notification, Select } from 'component/antd';
+import { IUploadFile, IConfigure, IConfigGateway } from 'types/base-type';
 import { version } from 'store/version';
 import { admin } from 'store/admin';
 import { wrapper } from 'store';
@@ -97,8 +97,8 @@ const updateFormModal = (type: number) => {
    formMap[2].attrs = {
      accept: version.fileSuffix,
    },
-    // tslint:disable-next-line:no-unused-expression
-    wrapper.ref && wrapper.ref.updateFormMap$(formMap, wrapper.xFormWrapper.formData, true);
+      // tslint:disable-next-line:no-unused-expression
+      wrapper.ref && wrapper.ref.updateFormMap$(formMap, wrapper.xFormWrapper.formData, true);
  }
 };

@@ -157,8 +157,8 @@ export const showModifyModal = (record: IUploadFile) => {

 export const showConfigureModal = async (record?: IConfigure) => {
  if (record) {
-    const result:any = await format2json(record.configValue);
-    record.configValue = result.result;
+    const result: any = await format2json(record.configValue);
+    record.configValue = result.result || record.configValue;
  }
  const xFormModal = {
    formMap: [
@@ -193,10 +193,69 @@ export const showConfigureModal = async (record?: IConfigure) => {
        return admin.editConfigure(value).then(data => {
          notification.success({ message: '编辑配置成功' });
        });
+      } else {
+        return admin.addNewConfigure(value).then(data => {
+          notification.success({ message: '新建配置成功' });
+        });
+      }
+    },
+  };
+  wrapper.open(xFormModal);
+};
+
+export const showConfigGatewayModal = async (record?: IConfigGateway) => {
+  const xFormModal = {
+    formMap: [
+      {
+        key: 'type',
+        label: '配置类型',
+        rules: [{ required: true, message: '请选择配置类型' }],
+        type: "select",
+        options: admin.gatewayType.map((item: any, index: number) => ({
+          key: index,
+          label: item.configName,
+          value: item.configType,
+        })),
+        attrs: {
+          disabled: record ? true : false,
+        }
+      }, {
+        key: 'name',
+        label: '配置键',
+        rules: [{ required: true, message: '请输入配置键' }],
+        attrs: {
+          disabled: record ? true : false,
+        },
+      }, {
+        key: 'value',
+        label: '配置值',
+        type: 'text_area',
+        rules: [{
+          required: true,
+          message: '请输入配置值',
+        }],
+      }, {
+        key: 'description',
+        label: '描述',
+        type: 'text_area',
+        rules: [{ required: true, message: '请输入备注' }],
+      },
+    ],
+    formData: record || {},
+    visible: true,
+    isWaitting: true,
+    title: `${record ? '编辑配置' : '新建配置'}`,
+    onSubmit: async (parmas: IConfigGateway) => {
+      if (record) {
+        parmas.id = record.id;
+        return admin.editConfigGateway(parmas).then(data => {
+          notification.success({ message: '编辑配置成功' });
+        });
+      } else {
+        return admin.addNewConfigGateway(parmas).then(data => {
+          notification.success({ message: '新建配置成功' });
+        });
      }
-      return admin.addNewConfigure(value).then(data => {
-        notification.success({ message: '新建配置成功' });
-      });
    },
  };
  wrapper.open(xFormModal);
--- a/kafka-manager-console/src/container/modal/app.tsx
+++ b/kafka-manager-console/src/container/modal/app.tsx
@@ -29,7 +29,7 @@ export const showEditModal = (record?: IAppItem, from?: string, isDisabled?: boo
        rules: [{
          required: isDisabled ? false : true,
          message: '应用名称只支持中文、字母、数字、下划线、短划线，长度限制在3-64字符',
-          pattern: /[\u4e00-\u9fa5_a-zA-Z0-9_-]{3,64}/,
+          pattern: /[\u4e00-\u9fa5_a-zA-Z0-9_-]{3,64}$/,
        }],
        attrs: { disabled: isDisabled },
      }, {
@@ -85,7 +85,7 @@ export const showEditModal = (record?: IAppItem, from?: string, isDisabled?: boo
    ],
    formData: record,
    visible: true,
-    title: isDisabled ? '详情' : record ? '编辑' : <div><span>应用申请</span><a className='applicationDocument' href="###" target='_blank'>应用申请文档</a></div>,
+    title: isDisabled ? '详情' : record ? '编辑' : <div><span>应用申请</span><a className='applicationDocument' href="https://github.com/didi/Logi-KafkaManager/blob/master/docs/user_guide/resource_apply.md" target='_blank'>资源申请文档</a></div>,
    // customRenderElement: isDisabled ? '' : record ? '' : <span className="tips">集群资源充足时，预计1分钟自动审批通过</span>,
    isWaitting: true,
    onSubmit: (value: IAppItem) => {
--- a/kafka-manager-console/src/container/modal/cluster.tsx
+++ b/kafka-manager-console/src/container/modal/cluster.tsx
@@ -29,7 +29,7 @@ export const showCpacityModal = (item: IClusterData) => {
        key: 'description',
        label: '申请原因',
        type: 'text_area',
-        rules: [{ required: true, pattern: /^.{5,}.$/, message: '请输入至少5个字符' }],
+        rules: [{ required: true, pattern: /^.{4,}.$/, message: '请输入至少5个字符' }],
        attrs: {
          placeholder: '请输入至少5个字符',
        },
@@ -44,12 +44,12 @@ export const showCpacityModal = (item: IClusterData) => {
        type: value.type,
        applicant: users.currentUser.username,
        description: value.description,
-        extensions: JSON.stringify({clusterId: item.clusterId}),
+        extensions: JSON.stringify({ clusterId: item.clusterId }),
      };
      cluster.applyCpacity(cpacityParams).then(data => {
        notification.success({
          message: `申请${value.type === 5 ? '扩容' : '缩容'}成功`,
-         });
+        });
        window.location.href = `${urlPrefix}/user/order-detail/?orderId=${data.id}&region=${region.currentRegion}`;
      });
    },
--- a/kafka-manager-console/src/container/modal/expert.tsx
+++ b/kafka-manager-console/src/container/modal/expert.tsx
@@ -20,14 +20,14 @@ export interface IRenderData {
 }

 export const migrationModal = (renderData: IRenderData[]) => {
- const xFormWrapper = {
+  const xFormWrapper = {
    type: 'drawer',
    visible: true,
    width: 1000,
    title: '新建迁移任务',
-    customRenderElement: <WrappedDataMigrationFormTable data={renderData}/>,
+    customRenderElement: <WrappedDataMigrationFormTable data={renderData} />,
    nofooter: true,
    noform: true,
  };
- wrapper.open(xFormWrapper as IXFormWrapper);
+  wrapper.open(xFormWrapper as IXFormWrapper);
 };
--- a/Show More
+++ b/Show More