跳到主要内容

· 阅读需 6 分钟

Rainbond 集群中,每个团队对应于底层 Kubernetes 的一个 Namespace ,由于之前使用的底层网络无法进行 Namespace 级别的网络管理,所以在 Rainbond 同一集群下的不同团队间,所以组件可以自由的进行互相访问,用户无法对此做出任何限制,这也导致了底层网络的安全隐患一直存在。现在由 cilium 提供网络服务的 Kubernetes 集群可以很好的解决这一问题,用户可以根据自己的需求,制定针对每个团队、每个组件的网络策略,加强底层网络管理,实现网络层的安全把控。

使用 cilium 作为 Kubernetes 网络服务

  • 使用从主机安装时,修改 network.plugin 值为 none

  • 安装 helm

wget https://goodrain-pkg.oss-cn-shanghai.aliyuncs.com/pkg/helm && chmod +x helm && mv helm /usr/local/bin/
  • 部署 cilium
helm repo add cilium https://helm.cilium.io/
helm install cilium cilium/cilium --version 1.11.2 --namespace kube-system --set operator.replicas=1

kubectl get pods --all-namespaces -o custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTNETWORK:.spec.hostNetwork --no-headers=true | grep '<none>' | awk '{print "-n "$1" "$2}' | xargs -L 1 -r kubectl delete pod

  • 验证 cilium

下载 cilium 命令行工具

curl -L --remote-name-all https://github.com/cilium/cilium-cli/releases/latest/download/cilium-linux-amd64.tar.gz{,.sha256sum}
sha256sum --check cilium-linux-amd64.tar.gz.sha256sum
sudo tar xzvfC cilium-linux-amd64.tar.gz /usr/local/bin
rm cilium-linux-amd64.tar.gz{,.sha256sum}
  • 确认状态
$ cilium status --wait
/¯¯\
/¯¯\__/¯¯\ Cilium: OK
\__/¯¯\__/ Operator: OK
/¯¯\__/¯¯\ Hubble: disabled
\__/¯¯\__/ ClusterMesh: disabled
\__/

DaemonSet cilium Desired: 2, Ready: 2/2, Available: 2/2
Deployment cilium-operator Desired: 2, Ready: 2/2, Available: 2/2
Containers: cilium-operator Running: 2
cilium Running: 2
Image versions cilium quay.io/cilium/cilium:v1.9.5: 2
cilium-operator quay.io/cilium/operator-generic:v1.9.5: 2
  • 测试网络联通性(国内服务器测试时,涉及到外部网络的测试可能会失败,不影响正常使用)
$ cilium connectivity test
ℹ️ Monitor aggregation detected, will skip some flow validation steps
[k8s-cluster] Creating namespace for connectivity check...
(...)
---------------------------------------------------------------------------------------------------------------------
📋 Test Report
---------------------------------------------------------------------------------------------------------------------
69/69 tests successful (0 warnings)

设置团队网络隔离

Cilium 的网络隔离策略遵循白名单机制,在不创建网络策略的情况下,对于网络不作任何限制,在为指定类型的 pod 集合创建网络策略后,除策略中允许的访问地址外,其它请求都会被拒绝。

  • 前期准备

    • 创建两个开发团队和测试团队,英文名称设置为 dev 和 test
    • 在开发团队和测试团队下创建 nginx-dev 和 nginx-test 组件,开启对内端口,内部域名分别设置为 nginx-dev 和 nginx-test
    • 在开发和测试团队下创建客户端组件
  • 不做任何限制

    在不做限制的情况下,各个团队之间的所有服务均可以自由通信,不受任何特殊限制

  • 限制只允许本团队内组件互相访问,隔绝其它团队访问

    在实际生产中,一个集群内部可能会同时部署开发、测试、生产等多个团队,基于安全性的考虑,需要对每个的团队做出网络隔离,禁止其它团队可以对其进行访问,下面以开发团队为例说明如何限制不允许其它团队对其访问。

  • Cilium 网络策略文件(dev-ingress.yaml)
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
name: "dev-namespace-ingress"
spec:
endpointSelector:
matchLabels:
"k8s:io.kubernetes.pod.namespace": dev
ingress:
- fromEndpoints:
- matchLabels:
"k8s:io.kubernetes.pod.namespace": dev
  • 创建策略
kubectl create -f dev-ingress.yaml -n dev
  • 确认策略
$ kubectl get CiliumNetworkPolicy -A
NAMESPACE NAME AGE
dev dev-namespace-ingress 39s
  • 测试效果

  • 设置开发团队下的 nginx-dev 组件只允许测试团队下的组件访问

    在某些情况下,一些组件的安全要求会更为严格,可能只会允许本团队内符合要求的部分组件进行访问,下面以 nginx-dev 为例说明如何限制仅允许部分组件进行访问。

  • Cilium 网络策略文件(nginx-dev-ingress0.yaml)
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
name: "nginx-dev-ingress"
spec:
endpointSelector:
matchLabels:
name: grc156cb
ingress:
- fromEndpoints:
- matchLabels:
name:
  • 创建策略
kubectl create -f nginx-dev-ingress0.yaml -n dev
  • 确认策略
$ kubectl get CiliumNetworkPolicy -A
NAMESPACE NAME AGE
dev nginx-dev-ingress0 85s
  • 测试效果

  • 设置开发团队允许本团队下组件访问的同时,允许开发团队下的 nginx-dev 组件被测试团队中任意组件访问

    在设置了团队网络隔离的情况下,有时候需要临时开放一些组件给其它团队访问以便进行调试,下面以 nginx-dev 组件为例说明如何在设置网络隔离的情况下开放外部团队的访问权限。

  • Cilium 网络策略文件(nginx-dev-ingress1.yaml)
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
name: "nginx-dev-ingress1"
spec:
endpointSelector:
matchLabels:
name: grc156cb
ingress:
- fromEndpoints:
- matchLabels:
"k8s:io.kubernetes.pod.namespace": test
  • 创建策略
kubectl create -f dev-ingress.yaml -n dev
kubectl create -f nginx-dev-ingress.yaml -n dev
  • 确认策略
$ kubectl get CiliumNetworkPolicy -A
NAMESPACE NAME AGE
dev dev-namespace-ingress 19s
dev nginx-dev-ingress1 12s
  • 测试效果

· 阅读需 5 分钟
信息

当前文档描述如何通过云原生应用管理平台 Rainbond 一键安装高可用 Nacos 集群。这种方式适合不太了解 Kubernetes、容器化等复杂技术的用户使用,降低了在 Kubernetes 中部署 Nacos 的门槛。

Rainbond 与 Nacos 的结合

Rainbond 是一款易于使用的开源云原生应用管理平台。借助于它,用户可以在图形化界面中完成微服务的部署与运维。借助 Kubernetes 和容器化技术的能力,将故障自愈、弹性伸缩等自动化运维能力赋能给用户的业务。

Rainbond 内置原生 Service Mesh 微服务框架,同时与 Spring Cloud、Dubbo 等其他微服务框架也有很好的整合体验。故而大量的 Rainbond 用户也可能是 Nacos 微服务注册中心的用户。这类用户不必再关心如何部署 Nacos 集群,Rainbond 团队将 Nacos 制作成为可以一键部署的应用模版,供开源用户免费下载安装。这种安装方式极大的降低了用户使用 Nacos 集群的部署负担,目前支持 1.4.2 与 2.0.4 版本。

关于应用模版

应用模版是面向 Rainbond 云原生应用管理平台的安装包,用户可以基于它一键安装业务系统到自己的 Rainbond 中去。无论这个业务系统多么复杂,应用模版都会将其抽象成为一个应用,裹挟着应用内所有组件的镜像、配置信息以及所有组件之间的关联关系一并安装起来。

前提条件

  • 部署好的 Rainbond 云原生应用管理平台,快速体验版本 可以在个人 PC 环境中以启动一个容器的代价运行。

  • 互联网连接。

快速开始

  • 访问内置的开源应用商店

选择左侧的 应用市场 标签页,在页面中切换到 开源应用商店 标签页,搜索关键词 nacos 即可找到 Nacos-cluster 应用。

nacos-1

  • 一键安装

点击 Nacos-cluster 右侧的 安装 可以进入安装页面,填写简单的信息之后,点击 确定 即可开始安装,页面自动跳转到拓扑视图。

nacos-2

参数说明:

选择项说明
团队名称用户自建的工作空间,以命名空间隔离
集群名称选择 Nacos 被部署到哪一个 K8s 集群
选择应用选择 Nacos 被部署到哪一个应用,应用中包含有若干有关联的组件
应用版本选择 Nacos 的版本,目前可选版本为 1.4.2、2.0.4

等待几分钟后,Nacos 集群就会安装完成,并运行起来。

nacos-3

  • 测试

需要执行服务注册的其他微服务组件,可以在建立面向 Nacos 的依赖关系后,使用 ${NACOS_HOST}:${NACOS_PORT} 来连接到 Nacos 集群。

  • 服务注册

    curl -X PUT "http://${NACOS_HOST}:${NACOS_PORT}/nacos/v1/ns/instance?serviceName=nacos.naming.serviceName&ip=20.18.7.10&port=8080"
  • 服务发现

    curl -X GET "http://${NACOS_HOST}:${NACOS_PORT}/nacos/v1/ns/instance/list?serviceName=nacos.naming.serviceName"
  • 发布配置

    curl -X POST "http://${NACOS_HOST}:${NACOS_PORT}/nacos/v1/cs/configs?dataId=nacos.cfg.dataId&group=test&content=helloWorld"
  • 获取配置

    curl -X GET "http://${NACOS_HOST}:${NACOS_PORT}/nacos/v1/cs/configs?dataId=nacos.cfg.dataId&group=test"

高级特性

  • 一键安装而来的 Nacos 集群中包含 3 个实例,并且通过初始化插件自动完成自组集群并选举的操作。

nacos-4

  • 默认集成了 Mysql 作为数据源。在 Nacos-server-2.0.4 组件的环境配置中配置如下环境变量,可以切换到其他外部数据源。
名称必要描述
MYSQL_SERVICE_HOSTY数据库地址
MYSQL_SERVICE_PORTY数据库端口
MYSQL_SERVICE_USERY数据库用户名
MYSQL_SERVICE_PASSWORDY数据库密码
MYSQL_SERVICE_DB_NAMEY数据库名
  • 默认生成了 Nacos-server-2.0.4 的数据持久化目录。

nacos-5

  • 默认配置了 Nacos-server-2.0.4 的健康检查机制,保障实例故障时自动下线,恢复后自动上线。

nacos-6

· 阅读需 7 分钟

OpenVSCode 是一款基于Web 界面的在线IDE 代码编辑器,只需要PC端存在浏览器即可使用,更轻量,高效,简洁,其基础功能完全继承了微软出品的 VS Code ,可以通过安装扩展的方式继续加强代码编辑能力。Rainbond 开源应用商店推出的 OpenVSCode 预安装了 gitlab-workflow 扩展用于对接私有化代码仓库 Gitlab,同时预装了常见语言运行环境(目前版本集成了Golang , Node.js , python , java ),可以在 Terminal 终端中快速调试业务代码。

Rainbond 有能力快速搭建一体化开发环境,通过对接代码仓库 webhook 机制,完成业务从代码开始,到最终上线的全流程。通过纳入 OpenVSCode 云端 IDE,可以将 Rainbond 一体化开发体系全部托管于云端,开发人员只需要一个浏览器,即可完成代码从编辑到上线的全流程。

为了实现上述的目标,本文会按照操作顺序逐次讲解:

  • 一键安装 OpenVSCode 和 Gitlab

借助 Rainbond 内置的开源应用商店,一键安装 OpenVSCode 和 Gitlab ,是搭建一体化开发体系最快捷的方式。

  • OpenVSCode 对接 Gitlab

借助 OpenVSCode 自带的扩展机制,完成与 Gitlab 的对接,可以获取 Gitlab 中的代码仓库。

  • 编码与调试

在 OpenVSCode 的帮助下,基于浏览器完成各种有关编码与调试的高级操作。

  • Gitlab 对接 Rainbond

通过 Oauth2.0 协议打通 Rainbond 与 Gitlab,方便地将 Gitlab 中的项目部署到 Rainbond 中去,并自动配置 Webhook 。

  • 代码提交触发自动构建

验证整个场景的效果,从 OpenVSCode 提交代码后,完成 Rainbond 上部署项目的自动发布上线。


一键安装 OpenVScode 和 Gitlab

一体化开发体系中所引用的 OpenVSCode 和 Gitlab 都已经加入 Rainbond 开源应用商店,供用户一键安装部署。

在开源应用商店中搜索,点击安装即可一键部署 Gitlab 应用,注意选择 14.8.2 版本:

在开源应用商店中搜索,点击安装即可一键部署 OpenVSCode 应用,目前提供 1.64.2 版本:

整体拓扑:


OpenVSCode 对接 Gitlab

Rainbond 提供的 OpenVSCode 默认集成了 Gitlab-workflow 扩展,该扩展为 OpenVSCode 提供了对接 Gitlab 代码仓库的能力,开发人员可以直接查看 Gitlab 中托管的代码仓库,并一键克隆到工作空间中。

  • OpenVSCode对接Gitlab仓库

    • 通过对接代码仓库,可以更加快速的拉取,提交代码,并且可以通过IDE进行代码的调试功能

    • 填写 Gitlab 对应的 URL(如果是平台部署的 Gitlab 则为http访问的域名) 以及 token即可

    • 对接成功以后,可以直接克隆仓库代码在终端进行编码、调试、推送等功能。

  • Gitlab 获取 Token

    • 在GitLab中,单击右上角并选择“首选项”在左侧边栏中。选择访问令牌,然后选择“添加个人访问令牌”
    • 权限:api , read_user

编码与调试

完成 OpenVSCode 和 Gitlab 的对接后,就可以直接读取 Gitlab 中的项目进行克隆操作。

根据开发语言的不同,可以在线安装各种开发语言的扩展,提升编辑代码的便利性。

编辑代码的体验和本地 IDE 并无二致。

打开 Terminal 之后,可以在命令行界面进行操作,OpenVSCode 默认集成了 maven 构建工具,方便构建 Jar 包进行测试。

构建完成后的下一步,可以直接在 Terminal 中启动项目。

被调试的项目启动后监听 5000 端口,开发人员只需要为 OpenVSCode 开启 5000 端口的对外服务,即可访问到调试中的服务了。


Gitlab 对接 Rainbond

完成编码与调试后,开发人员的业务进入了部署阶段。为了使整个流程的自动化程度更高,开发人员可以将 Gitlab 和 Rainbond 打通。

Gitlab 与 Rainbond 之间能够利用 Oauth2 协议打通单点登录流程,方便用户在 Rainbond 界面内直接选择 gitlab 中的仓库进行代码的部署,并自动配置 webhook,完成代码 commit 之后的自动构建。

配置以及使用方法参见以往文章:

GitLab和Rainbond整合实现一体化开发环境

完成 Gitlab 与 Rainbond 的对接后,可以在 Rainbond 界面中选择 Gitlab 中的项目进行部署。

打开是否开启自动构建的开关,可以自动配置 Gitlab 的 Webhook ,Gitlab 一旦接收到指定的推送信息,就会触发 Rainbond 对当前服务组件的自动构建。


代码提交触发自动构建

修改项目文件提交时 Commit 信息添加关键字 @deploy ,提交成功以后,rainbond会自动触发自动构建。

自动更新效果展示

· 阅读需 2 分钟

简介

KnowStreaming 是一套云原生的Kafka管控平台,脱胎于众多互联网内部多年的Kafka运营实践经验,专注于Kafka运维管控、监控告警、资源治理、多活容灾等核心场景。在用户体验、监控、运维管控上进行了平台化、可视化、智能化的建设,提供一系列特色的功能,极大地方便了用户和运维人员的日常使用,让普通运维人员都能成为Kafka专家。

快速部署 KnowStreaming

在 Rainbond 的平台管理 -> 应用市场 -> 开源应用商店中搜索 KnowStreaming 并一键安装。

安装完成后,通过 Rainbond 默认提供的域名访问 KnowStreaming-UI,默认密码:admin/admin

安装 Kafka 集群并通过 KnowStreaming 对接管理

安装 Kafka 集群

在 Rainbond 的平台管理 -> 应用市场 -> 开源应用商店中搜索 kafka 并一键安装。安装到与 KnowStreaming 同一个应用下。

建立依赖关系

进入 KnowStreaming 应用视图,切换到 编排模式,将 Manager-KnowStreaming 组件连接到 kafkazookeeper

管理 Kafka 集群

访问 KnowStreaming-UI 并对接 Kafka 集群:

  • Bootstrap Servers: 进入 Kafka 组件内 -> 端口,复制访问地址。
  • Zookeeper: 进入 zookeeper 组件内 -> 端口,复制访问地址。

对接完成后的效果如下:

· 阅读需 21 分钟

Rainbond 这款产品一直致力于打通企业应用交付的全流程,这个流程中不可或缺的一环是企业应用的不断升级、迭代。Rainbond 特有的能力,是可以将囊括多个服务组件的企业应用系统进行打包,并执行一键安装、升级以及回滚的操作。上述的内容仅仅解决了应用程序本身的版本控制问题。企业应用的升级迭代流程想要完全实现自动化,还需要能够自动处理数据库表结构(Schema)的版本控制。经过不断的探索,Rainbond 首先在源码构建领域借助业界领先的 Liquibase 集成了云原生时代的数据库 Schema 版本管理的能力。

Schema版本管理难题

数据库表结构(Schema)定义了数据表(Table)的名字,以及每一个数据表中所包含的数据列(Column)的名字、属性等信息。它描述了一个数据库所拥有的框架,记录在数据库中的数据都需要遵循 Schema 里的定义。

区别于应用程序自身的升级,Schema 版本管理问题,本质上是一种持久化数据的升级,这一特征伴随着两个疑问:

  • 持久化数据如何升级:云原生时代的交付,已经无法跳脱出容器化、平台化的特征。各大云原生平台在进行软件交付过程中,都不会轻易将持久化数据纳入版本控制体系中去。原因很简单,每个交付环境中的数据都是不同的,升级过程中很难抉择持久化数据的统一版本管理方案。
  • 哪些持久化数据需要升级:既然难以抉择持久化数据的统一版本管理方案,那么退而求其次,是否可以优先选择必要的持久化数据进行版本管理。缩小范围之后,就突出了数据库表结构这一特殊持久化数据类型。其版本管理的必要性是显而易见的,应用程序本身从V1版本升级到了V2版本,那么对应的数据库表结构也需要增加必要的新表、新列。

这两个疑问引出了本文的主旨:在企业级软件交付领域,如何合理的在每次升级的过程中处理数据库表结构(Schema)的版本控制?

传统软件交付领域,在 Schema 版本管理方面有两种主流的解决方案:

  • 人工处理:这是最基础的 Schema 版本管理方式。现场交付人员不仅需要处理应用程序的升级流程,也直接操作数据库,完成 Schema 的升级。这种方法最直接,但是无法自动化处理的流程都具有一些通病:低效、易错。
  • 代码处理:这是一种进阶的方式。通过在应用程序内部引入第三方库,来进行 Schema 的版本管理。这一操作已经可以免除交付现场的人工处理流程,交付人员只需要将应用程序进行更新,程序本身会连接到数据库,对 Schema 作出自动化的变更。这种方式的自动化程度已经可以满足要求,但是也具有引入第三方库的通病:技术成本提升、侵入性、与语言或框架绑定。

云原生时代的解决思路

云原生时代,应用程序的使用者、交付者都希望通过所选用的平台来赋能自己的应用程序。在本文探讨的领域中,这种期待可以具体的描述为:借助平台能力,以无侵入的方式,将 Schema 版本管理能力赋予应用,使得应用在进行一键升级时, Schema 也自动完成升级。

Rainbond 作为一款云原生应用管理平台,也在不断探索为应用赋能之道。在 Schema 版本管理领域,实现了在源码构建过程中集成 Schema 版本管理的能力。应用本身不需要改动任何代码,仅仅需要将两种类型的文件放进代码根目录下的指定目录下即可。这两种文件分别是:定义了数据库实例连接地址的配置文件,升级 Schema 所使用的 Sql 脚本文件。

关于源码构建

源码构建功能,本身就是一种 Rainbond 对应用的赋能。云原生时代,应用都在向容器化的方向迈进。容器化的过程中看似无法免除 Dockerfile 的编写,实则不然。源码构建功能可以直接对接源代码,将其编译成为可运行的容器镜像。整个过程不需要开发人员的介入,提供代码仓库地址即可,极大的降低了开发人员的技术负担。

在源码构建的流程中,以无侵入的方式集成了很多能力。比如通过纳入 Pinpoint-agent 的方式集成 APM 能力。再比如通过纳入 jmx-exporter 的方式集成自定义业务监控能力。今天重点描述的,是通过纳入 Liquibase 的方式,集成 Schema 版本控制能力。

关于Liquibase

Liquibase 是一款专门用于数据库表结构版本控制的 CI/CD 工具。从 2006 年开始,Liquibase 团队一直致力于让数据库变更管理更简单,尤其是在敏捷软件开发领域。这一工具基于 Apache 2.0 协议开源。

经过长期的迭代,Liquibase 已经非常成熟可靠,通过 sql、yaml、xml、json 在内的多种文件格式,开发人员可以快速的定义出符合 Liquibase 风格的数据库表结构变更文件,这种文件被称之为 changelog。基于 changelog 中的定义,Liquibase 可以非常方便的在多个变更操作版本之间升级与回滚。

Liquibase 提供多种方式供开发人员交互,包括一种通用的命令行操作模式,源码构建通过命令行形式集成 Liquibase 的 Schema 版本管理能力。

代码定义的Schema版本控制能力

Rainbond 源码构建推崇代码定义各种能力。对于 Schema 版本控制能力而言,也是通过代码仓库中的指定文件来定义的,我们可以简要的称之为 Schema As Code,这种代码定义能力的实践,要求每一次 CI 工作都由一个代码仓库地址开始,比如 Git。对于每一个数据库实例来说,通过指定目录下的配置文件和 changelog 来定义数据库表结构版本。默认情况下,是指代码根目录下的 Schema目录。

下面是一个代码结构示例,Rainbond 官方同时提供了一份完整的代码示例 java-maven-demo :

.
├── Procfile
├── README.md
├── Schema
│   ├── changelog.sql # 定义数据库表结构
│   └── mysql.properties # 定义数据库实例连接信息
├── pom.xml
└── src

Schema 目录下的 mysql.propertieschanglog.sql文件定义了如何进行 Schema 版本控制。

mysql.properties 定义了数据库实例的连接方式,以及所引用的 changelog 文件地址。

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://${MYSQL_HOST}:${MYSQL_PORT}/${MYSQL_DATABASE}?createDatabaseIfNotExist=true&characterEncoding=utf8
username=${MYSQL_USER}
password=${MYSQL_PASSWORD}
changeLogFile=changelog.sql

最简化定义项包括:

  • driver:指定使用的 jdbc 驱动,源码构建中集成的驱动支持mysql、mariadb、mssql、mongo、postgresql、sqlite等常见类型数据库。
  • url:定义数据库连接地址,可以通过 jdbc 的标准写法来预创数据库实例。
  • username&password:定义数据库实例的登录凭据。
  • changeLogFile:定义该数据库实例表结构变更文件的路径。

源码构建过程中,会遍历识别 Schema 目录下的所有 properties 文件,并在启动时处理每一个数据库实例的 Schema 版本控制流程。通过配置文件的组合,在以下各种常见场景中都可以很好的工作。

  • 单个数据库实例
  • 多个相同类型数据库实例,比如应用同时连接了多个 mysql
  • 多个不同类型数据库实例,比如应用同时连接了mysql、mongo
  • 同个数据库中的多个数据库实例,比如应用同时使用同个 mysql 中的多个库实例

changlog 的最佳实践

changelog 文件,是管理 Schema 的关键所在。以下是一个示例:

-- liquibase formatted sql
-- changeset guox.goodrain:1
create table person (
id int primary key,
name varchar(50) not null,
address1 varchar(50),
address2 varchar(50),
city varchar(30)
);
-- rollback drop table person;
-- changeset guox.goodrain:2
create table company (
id int primary key,
name varchar(50) not null,
address1 varchar(50),
address2 varchar(50),
city varchar(30)
);
-- rollback drop table company;

推荐使用 sql 类型的 changelog 文件来定义 Schema 版本,因为这最符合开发人员的习惯。

changlog 文件通过注释来定义一些行为。常见如下:

# 定义 changelog 文件的格式,这是每一个 changelog 文件的开头项
-- liquibase formatted sql
# 定义变更集,后面跟随的,是开发人员姓名,以及变更集的序号,这个序号很重要,建议使用有序数字来定义
-- changeset guox.goodrain:1
# 定义回滚操作,每一个变更集都应该定义与之对应的回滚操作,这使得在变更出现问题时,快速回滚到指定版本的变更集
-- rollback drop table staff;

Liquibase 官方提出了一系列的最佳实践,有一些最佳实践应该作为开发人员的默认行为。

  • 每个变更集仅包含一个变更,通过细化数据库表结构的变更版本,这可以防止失败的自动提交语句使数据库处于意外状态。
  • changeset 的 ID,选择有序且独一无二的数列,或者对开发者友好的名字。
  • 让版本永远可回滚,为每一个 changeset 设置合理的回滚操作。

有关于 mysql.propertieschanglog.sql 文件的写法,更多的特性请参考 liquibase 文档 ,这些特性都可以被源码构建所继承。

Schema生命周期流程

1. 构建流程

执行正常的源码构建流程时,会自动识别代码根目录下的 Schema 目录,准备 Schema 版本管理所需要的基础环境,包括 jre 和 Liquibase 工具包。

构建日志会有以下提示:

2. 启动流程

完成构建流程后,服务组件会自动进入启动过程中, Rainbond 平台会根据代码中定义好的配置文件,针对每一个数据库实例,进行自动升级处理。

处理过程中,在服务组件的日志中的头部位置,会打印相关的记录:

上图中演示了针对同一个 mysql 数据库中的多个库实例进行表结构的升级操作。对于空的库实例而言,这也相当于一次初始化的操作。

在示例中,Rainbond 分别向应用所连接的同个 mysql 数据库中的两个库实例(分别名为 Initialize anotherdb)进行了表结构初始化操作,分别创建了表companyperson 以及 another_companyanother_person。在数据库组件的 Web终端登录后,可以验证:

3. 发布到组件库

Rainbond 特有的发布机制,可以将业务组件和数据库组件统一发布为一个应用模版。方便在不同的环境中一键安装交付。通过应用模版交付的应用,依然具有 Schema 版本控制的能力。全新安装的应用模版,其数据库也会被初始化为上述状态。在这里,我们称发布的应用为源应用,由应用模版安装而来的应用为已交付应用。

4. 代码更新

当开发人员持续迭代业务系统的时候,Schema 也随之改动,假定新版本的业务系统,要求 Initialize 新增表 staff,并为已有的 person 表添加一个新的列 country。那么开发人员应该为对应的 changelog.sql 文件新增以下内容,并和新的业务代码一并提交,保证业务代码和 Schema 保持一致。

-- changeset other.goodrain:3
alter table person add column country varchar(2);
create table staff (
id int primary key,
name varchar(50) not null,
address1 varchar(50),
address2 varchar(50),
city varchar(30)
);
-- rollback drop table staff;
-- rollback alter table person drop column country;

在源应用处点击构建,Rainbond 会拉取最新的代码,更新业务应用的同时,为 Schema 进行升级。

构建过程中没有任何变化,但是在启动过程中,针对更新的 Initialize 和保持原状的 anotherdb 库实例,Rainbond 给出两种不同的处理:

5. 基于应用模版的升级

源应用有了新的版本,已交付应用也应随之有变更。首先,应用模版需要有一个更新的版本,重复发布流程,定义更高的版本号即可。已交付应用可以根据 Rainbond 的提示,一键升级到更新后的版本。

6. 验证

登录已交付应用的数据库组件中,可以查看对应的 Schema 变化。

7. 回滚

数据库表结构的回滚操作是一个很严肃的问题。本着数据库表结构只增不减的原则,已经生效的 Schema 不会随着已交付应用的一键回滚而有任何变动。如果一定要进行回滚,则需要运维人员登录业务组件的 Web终端手动操作。

需要注意的是回滚的顺序:数据库表结构应该先于应用程序回滚。这是由于一旦应用程序回滚完成, changlog 文件本身也回滚到了上个版本,无法再进行数据库表结构的回滚。

执行以下命令,可以根据指定的配置文件,对数据库表结构进行回滚操作,回滚幅度以 1 个 changeset 为单位。

cd Schema/
liquibase rollbackCount 1 --defaults-file=mysql.properties

鉴于回滚后的业务组件一旦重启或更新,就会比对 changelog 文件后重新升级 Schema,所以在执行回滚操作后,务必添加环境变量 ALLOW_SCHEMA_UPDATE=false 来禁用 Schema 版本管理控制功能,直到新版本应用模版的升级。

常见问题

  1. 如何在 *.properties 配置文件中合理的定义所有数据库实例的连接地址和凭据?

使用环境变量来代替 *.properties 配置文件中的数据路实例连接地址和凭据信息,定义方式详见文中的示例。Rainbond 源码构建过程中,会拾取运行环境中的所有环境变量,对目标配置文件进行渲染,所以对于环境变量的命名并不重要,只需要保证定义的环境变量会在最终交付环境中生成即可。无论环境变量来自于自定义的环境配置还是 Rainbond 独有的连接信息机制。

  1. 执行回滚操作失败?

回滚如何操作,定义在 changlog 文件中。务必保证每一个 changeset 都有对应的回滚策略,方可保证每次回滚都得到正确的结果。

  1. 执行 Schema 升级的过程中报错:!! Failed to check the database status. Check /app/Schema/xxx.properties.log

每一次执行 Schema 变更的过程中,都会先进行检查,包括数据库实例地址的连通性、changelog 文件的可执行性。如果检查不通过,则不会对数据库作出任何操作,但是检查的结果会记录在日志文件中,可以登录 Web 终端,查看提示中的日志文件内容。

  1. 老用户如何获取 Schema 版本控制功能?

这一功能和 Rainbond 的版本脱离,所以老用户可以通过更新源码构建相关组件来获取这一能力。执行以下一组命令即可:

# 以下命令在 Rainbond 集群内任意节点执行;如果你使用 dind-allinone 版本,则应该在 rainbond-allinone 容器中执行
hubpassword=$(kubectl get rainbondcluster -o yaml -n rbd-system | grep password | awk '{print $2}')
docker login --username=admin --password=${hubpassword} goodrain.me
images=(builder runner)
for image in ${images[@]}
do
docker pull registry.cn-hangzhou.aliyuncs.com/goodrain/${image}:v5.5.0-release
docker tag registry.cn-hangzhou.aliyuncs.com/goodrain/${image}:v5.5.0-release goodrain.me/${image}
docker push goodrain.me/${image}
done

Liquibase https://www.liquibase.com

java-maven-demo https://gitee.com/rainbond/java-maven-demo

· 阅读需 6 分钟

Prometheus 社区开发了 JMX Exporter 用于导出 JVM 的监控指标,以便使用 Prometheus 来采集监控数据。当您的 Java 应用部署在Rainbond上后

可通过本文了解部署在 Rainbond 上的 Java 应用如何使用 JMX Exporter 暴露 JVM 监控指标。

JMX Exporter 简介

Java Management Extensions,JMX 是管理 Java 的一种扩展框架,JMX Exporter 基于此框架读取 JVM 的运行时状态。JMX Exporter 利用 Java 的 JMX 机制来读取 JVM 运行时的监控数据,然后将其转换为 Prometheus 可辨识的 metrics 格式,让 Prometheus 对其进行监控采集。

JMX Exporter 提供 启动独立进程JVM 进程内启动(in-process)两种方式暴露 JVM 监控指标:

启动独立进程

JVM 启动时指定参数,暴露 JMX 的 RMI 接口。JMX Exporter 调用 RMI 获取 JVM 运行时状态数据,转换为 Prometheus metrics 格式,并暴露端口让 Prometheus 采集。

JVM 进程内启动(in-process)

JVM 启动时指定参数,通过 javaagent 的形式运行 JMX Exporter 的 jar 包,进程内读取 JVM 运行时状态数据,转换为 Prometheus metrics 格式,并暴露端口让 Prometheus 采集。

官方不建议使用 启动独立进程 方式,该方式配置复杂且需单独的进程,进程本身的监控又引发了新的问题。本文以 JVM 进程内启动(in-process)方式为例,在 Rainbond 中使用 JMX Exporter 暴露 JVM 监控指标。

在 Rainbond 上使用 JMX Exporter

Rainbond上对于构建类型不同的组件有不同的处理方式,如下

通过源码构建的Java应用

自V5.3版本后通过 Rainbond 源码构建的 JAVA 应用,默认都会将 JMX Exporter 打包,用户使用时只需添加环境变量开启即可。

  1. 为 JAVA 服务组件添加一个指定的环境变量 ES_ENABLE_JMX_EXPORTER = true ,即可开启 jmx_exporter

  2. 在 JAVA 服务组件的端口管理处添加一个 5556 端口,这是 jmx_exporter 默认监听的端口。

通过镜像构建的Java应用

对于镜像或应用市场构建的应用,可以使用初始化类型的插件实现注入 jmx_agent

往期文章中详细讲解过其实现原理,可以参考:Rainbond通过插件整合SkyWalking,实现APM即插即用 Agent插件实现原理部分

  • 构建 jmx_exporter 插件

进入团队 -> 插件 -> 新建插件,创建初始化类型插件,源码地址:https://github.com/goodrain-apps/jmx_exporter.git

插件构建成功后即可使用,为 JAVA 服务组件开通此插件即可。

  • 挂载存储

为 JAVA 服务组件挂载存储 /tmp/agent,使其可以与插件共享存储。

通过共享存储,初始化插件将所需的配置文件以及 Agent 放在共享存储中供主服务使用,实现服务无侵入。

  • 添加环境变量

为 JAVA 服务组件添加环境变量 JAVA_OPTS = -javaagent:/tmp/agent/jmx_prometheus_javaagent-0.16.1.jar=5556:/tmp/agent/prometheus-jmx-config.yaml

可挂载配置文件 /tmp/agent/prometheus-jmx-config.yaml 替换现有的配置文件。

  • 添加端口

在组件的端口管理处,添加新的端口 5556

最后更新组件即可生效。

添加应用监控点

应用监控是基于 rbd-monitor 实现,当我们添加了监控点后就相当于创建了一个 servicemonitor

进入组件内 -> 监控 -> 业务监控 -> 管理监控点,新增监控点,填写以下信息:

  • 配置名:自定义

  • 收集任务名称:自定义

  • 收集间隔时间:10秒

  • 指标路径:/metrics

  • 端口号:选择 jmx_exporter 端口

添加完后更新组件使其生效。

添加监控图表

接下来就可以添加一个监控图表,来展示 JAVA 服务组件中 JVM 的指标行:

点击业务监控面板上方的 添加图表

输入新的标题,以及对应的查询条件 jvm_memory_bytes_used 后,点击 查询。如果正常返回图表,则说明查询条件是正确的。标题的定义尽量清晰明了,并在有必要的情况下明确单位。

更多指标可参考 官方文档

扩展Grafana

可通过grafana 展示,以下简述操作步骤:

  1. 获取 rbd-monitor 服务 CLUSTER IP
$ kubectl get svc -l name=rbd-monitor -n rbd-system

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
rbd-monitor ClusterIP 10.43.112.131 <none> 9999/TCP 13d
  1. 在平台上添加第三方服务,填写 rbd-monitor 服务的 CLUSTER IP
  2. 从开源应用商店安装 Grafana并添加依赖。
  3. 进入Grafana,Configuration -> Add Data Source -> URL为 http://127.0.0.1:9999 ,导入 JVM dashboard ID 8878 ,通过Grafana面板展示应用监控信息。

jmx_export 插件Github https://github.com/goodrain-apps/jmx_exporter.git

jmx_export 官方 https://github.com/prometheus/jmx_exporter.git

jvm dashboard https://grafana.com/grafana/dashboards/8878

· 阅读需 6 分钟

Locust 是一种易于使用、可编写脚本且可扩展的性能测试工具。并且有一个用户友好的 Web 界面,可以实时显示测试进度。甚至可以在测试运行时更改负载。它也可以在没有 UI 的情况下运行,使其易于用于 CI/CD 测试。

Locust 使运行分布在多台机器上的负载测试变得容易。Locust 基于事件(gevent),因此可以在一台计算机上支持数千个并发用户。与许多其他基于事件的应用程序相比,它不使用回调。相反,它通过gevent使用轻量级进程。并发访问站点的每个Locust(蝗虫)实际上都在其自己的进程中运行(Greenlet)。这使用户可以在Python中编写非常有表现力的场景,而不必使用回调或其他机制。

快速部署Locust

Locust 应用已发布到 开源应用商店,搜索 locust 安装最新2.5.1版本即可。

安装完成后,您将会得到一个Locust主从集群,其中,master组件负责提供UI界面,和并发任务的调度;slave组件负责执行并发任务,slave组件同时支持横向伸缩,当产生的测试并发达到一定的限额时,只需扩展 slave 组件实例即可,例如:

如何使用

Locust_Master 提供了一个基于WEB-UI的图形化管理界面,首次登陆,会提示输入一些信息:

默认用户密码:locust locust,可配置 Locust_Master 组件的环境变量 LOCUST_WEB_AUTH进行修改。

Number of users 填写模拟的并发用户数量,经过测试,单个slave实例可以轻松提供上千个用户并发的压力。

Spawn rate 填写蝗虫的孵化率,即每秒产生多少用户。

Host 填写想要压测的站点地址。

当Host以及用户,并发量定义完毕以后,还需要去定义一下测试用例,即用户访问Host之后的行为,Locust是通过一个名为 /locustfile.py 的Python脚本来定义用户行为,在Rainbond平台的 Locust_Master 组件内 环境配置 -> 配置文件设置 进行编辑修改。

代码示例如下:

from locust import HttpUser, task, between

class MyUser(HttpUser):
wait_time = between(5, 15)

@task(2)
def index(self):
self.client.get("/")

@task(1)
def about(self):
self.client.get("/docs/")

这个脚本将按照顺序模仿以下行为:

  1. 请求Host的 / 路径两次
  2. 请求Host的 /docs/ 路径一次
  3. 每次执行任务之间,间隔5-15秒

之所以要这么设计的原因,是Locust的设计者们认为,真正的用户行为,不会像脚本一样接连不断的执行完所有的请求然后退出。更多的情况是,用户做完一件事后,会停顿一会,比如读读说明,思考下一步要干嘛。所以会在每个步骤之间留下一个随机时长的空白期。这种假设实际上更符合用户实际行为。

这个文件,将会以配置文件的方式挂载到 locust_master 组件上,并且共享挂载给所有的locust_slave组件。这意味着,如果你想要更改这个文件的内容,只需要去编辑 locust_master 组件中,环境配置下所挂载的配置文件即可。然后更新整个 Locust 集群即可生效。

结果分析

借助Locust提供的WEB-UI界面,我们可以非常方便的分析压力测试结果。

Statistics页面,将向我们展示所有被压测接口的汇总报告。结果包括:

Type 请求类型;
Name 请求路径;
Requests 请求总数;
Fails 失败次数;
Median 中位数响应时间;
90%ile 90%请求响应时间;
Average 平均响应时间;
Min 最小响应时间;
Max 最大响应时间;
Average size 请求的平均大小;
Current PRS 当前吞吐率;
Current Failures 当前错误率;

Charts页面将主要结果绘制成为随时间变化的图表,能够在趋势上给予用户指引。

除了这些之外,还有几项值得关注的值会在最上面一排全局展示,包括当前请求的主机域名、当前产生的并发用户数量、slave节点数量、当前所有请求接口的总吞吐率、错误率。以及停止测试的按钮。

其它的几个页面会提供:

Failures 请求失败的接口及失败原因;
Expections 测试中意外的错误以及错误原因
Download Data csv格式的测试数据下载地址
Workers 所有slave实例的信息

更多教程请参考Locust官方文档

· 阅读需 12 分钟

现有的 ServiceMesh 框架有很多,如 Istio、linkerd等。对于用户而言,在测试环境下,需要达到的效果是快、开箱即用。但在生产环境下,可能又有熔断、延时注入等需求。那么单一的 ServiceMesh 框架无法同时满足用户不同的需求。

在之前的 Rainbond 版本中,Rainbond 支持了多种不同的应用治理模式,作为应用级的插件,实现了Istio 治理模式的切换。

本文将对Rainbond 实现Istio治理模式进行原理解析。

基本原理

动态准入控制

首先我们需要了解一个知识,Istio 是如何实现自动注入的。实际上,Istio、linkerd 等不同的 ServiceMesh 框架都使用到了 Kubernetes 中的一个非常重要的功能,叫作 Dynamic Admission Control,也叫作:Initializer。

这个功能会在 API 对象创建之后会被立刻调用到。在 API 对象被正式处理前,完成一些初始化的准备工作。所以在部署了 Istio 控制平面以后,当你提交了 API 对象的 Yaml 文件,会被 Istio 的准入控制器捕获,完成一些 PATCH 操作,比如加上对应的 Sidecar 容器字段。最终将这个 PATCH 过后的 API 对象交给 Kubernetes 处理。接下来就详细介绍下 ServiceMesh 框架的注入机制。

如何自动注入

用户需要先在集群中部署 Istio 的控制平面。它会包含一个用来为 Pod 自动注入 Envoy 容器的 Initializer。 首先, Istio 会将 Envoy 容器本身的定义,以 ConfigMap 的方式保存在 Kubernetes 当中。当 Initializer 的控制器,通过 Admission-Webhooks 监听到符合规则【此处指对应的 Annoations】的 API 对象被创建后,读取对应的 ConfigMap 获取到 Envoy 容器的配置。并将相关的字段,自动添加到用户提交的 Pod 的 API 对象里。详见下图和说明。

上图为提交yaml文件到Kubernetes集群后,集群所做的处理,大概分为以下几步:

  1. Yaml 文件提交到 APIServer,APIServer 会过滤这个请求,并完成一些前置性的工作,比如授权、超时处理、审计等。

  2. APIServer 会找到该 Pod 对应的类型定义,如果存在,则会将这个 Pod 转换为对象。

  3. 接下来进行 Admission 操作,Admission 操作是在创建之后会被立刻调用到的一组代码,它可以完成一些初始化操作,比如在对象创建前加上某些 Labels,但是由于它本身是被编译到 APIServer 中的,所以用户修改后,需要重新编译并重启 APIServer。幸运的是:Kubernetes 提供了一种“热插拔”式的 Admission 机制,即 Initializer。

  4. 目前 istio、linkerd 等项目均实现了 Initializer 机制,也就是说,当提交的 Yaml 文件包含其指定的Annoations 字段时,那么它们部署的准入控制器则会捕获到对应的 API 对象,在这个阶段为 Pod 进行初始化操作,即添加上 Sidecar 容器的相关配置。

  5. 接下来会进行 Validation,验证 API 对象的字段是否合法。

  6. 验证完毕后,会将对应的信息保存到etcd中,一次API对象的创建就此完成。

扩展应用治理模式

在了解了现有的 ServiceMesh 框架的注入机制后,我们就可以基于此开发 Rainbond 的应用级插件,用于扩展应用的治理能力。我们知道由于现有的 ServiceMesh 框架大多采用了标准的 Initializer 实现。所以我们只需要完成以下两步即可。

  1. 部署对应 ServiceMesh 框架的 Initializer 控制器,通常情况下意味着部署它们的控制平面,此处基于 Rainbond 已有的对接 helm 商店的功能,可以方便的进行部署。

  2. 实现基于应用的数据平面的注入。

Istio治理模式的开发

接下来以 Istio 治理模式的开发为例,详细介绍如何自行扩展应用的治理能力。

前端展示支持 Istio 应用治理模式:

Rainbond 主要分为两层,即业务层和数据中心层,具体可参考 Rainbond 技术架构 。

rainbond-ui 为业务层的前端项目,首先需要支持 Istio 治理模式,由于 Rainbond 是以应用为中心的应用管理平台,所以 Istio 治理模式也是针对应用来说的。

如下图所示:在应用页面,可以切换治理模式。我们需要在这里增加 Istio 治理模式。

治理模式有效性校验

Initializer 的机制决定了,需要有一个准入控制器,去处理符合条件的 API 对象。通常情况下准入控制器包含在对应 ServiceMesh 框架的控制平面中。

所以我们在切换治理模式时,需要去校验集群中是否已经部署过对应 ServiceMesh 框架的控制平面,这一步应该在切换时进行校验。如果未部署对应的控制平面,则不具有对应的治理能力。也就不能切换。

根据 Rainbond 技术架构 ,我们可以知道,rainbond-console 属于业务层的后端。它需要与数据中心端进行通信,才能获取集群的状态。因此在 rainbond-console 和 rainbond 这两个项目中,都需要对治理模式的有效性进行校验。

rainbond-console 对治理模式有效性的校验

参考如下代码,类 GovernanceModeEnum 定义了支持的治理模式。首先我们需要在治理模式这里增加 ISTIO_SERVICE_MESH,用于在业务层判断治理模式是否有效。当此处校验通过后,我们需要请求数据中心端的接口,检测此种治理模式是否已安装了对应的控制平面。

/console/enum/app.py

class GovernanceModeEnum(AutoNumber):
BUILD_IN_SERVICE_MESH = ()
KUBERNETES_NATIVE_SERVICE = ()
ISTIO_SERVICE_MESH = ()

@classmethod
def choices(cls):
return [(key.value, key.name) for key in cls]

@classmethod
def names(cls):
return [key.name for key in cls]

rainbond 对治理模式有效性的校验

在接收到来自业务端的校验请求时,我们需要检测在该集群是否已部署了对应的 ServiceMesh 框架的控制平面。参考如下代码,由于部署 Istio 控制平面后,在每个命名空间下都可以查看到 istio-ca-root-cert这个 ConfigMap,所以我们这里使用该 ConfigMap 作为判断 Istio 控制平面部署的依据。 当确认 Istio 控制平面已安装后,我们返回给业务端结果。最终完成切换。

/api/handler/app_governance_mode/adaptor/istio.go

func (i *istioServiceMeshMode) IsInstalledControlPlane() bool {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cmName := os.Getenv("ISTIO_CM")
if cmName == "" {
cmName = "istio-ca-root-cert"
}
_, err := i.kubeClient.CoreV1().ConfigMaps("default").Get(ctx, cmName, metav1.GetOptions{})
if err != nil {
return false
}
return true
}

实现基于应用的数据平面的注入

仅仅完成治理模式的切换还不够,我们需要让 Istio 的控制平面为指定的应用注入 Sidecar,即数据平面。Rainbond 自身通过 Worker 组件将 Rainbond-Application Model 进行实例化转化为 Kubernetes 资源模型。控制应用的生命周期。

因此,我们需要在 Worker 组件转化资源时,自动为用户完成对应用的注入。参考 Istio 注入策略。我们可以发现 Istio 依赖于 Label "sidecar.istio.io/inject": "true" 完成注入。而在 Rainbond的代码中,我们可以看到如下代码。这是将 Rainbond 的应用模型转化为 Deployment 的部分代码。在这里,我们为 Deployment 添加了对应的 injectLabels。

有了这些初始化操作。当 API 对象被创建出来时,便会被 Istio 的准入控制器处理,完成数据平面的注入。

/worker/appm/conversion/service.go

func initBaseDeployment(as *v1.AppService, service *dbmodel.TenantServices) {
as.ServiceType = v1.TypeDeployment
... ...
injectLabels := getInjectLabels(as)
deployment.Labels = as.GetCommonLabels(
deployment.Labels,
map[string]string{
"name": service.ServiceAlias,
"version": service.DeployVersion,
},
injectLabels)
... ...
as.SetDeployment(deployment)
}

func getInjectLabels(as *v1.AppService) map[string]string {
mode, err := governance_mode.NewAppGoveranceModeHandler(as.GovernanceMode, nil)
if err != nil {
logrus.Warningf("getInjectLabels failed: %v", err)
return nil
}
injectLabels := mode.GetInjectLabels()
return injectLabels
}

对于不同的应用治理模式,我们可以参考 应用治理模式扩展 的代码。实现如下接口,便可以完成应用下治理模式的切换和注入。

其中IsInstalledControlPlane这个接口的实现在前面已经体现。它主要用于判断控制平面是否已完成安装,可以正常使用。而 GetInjectLabels则主要用于 Worker 组件转化应用模型为 Kubernetes 资源时,添加上指定的 Labels,以便被部署的准入控制器处理。

/api/handler/app_governance_mode/adaptor/app_governance_mode.go

type AppGoveranceModeHandler interface {
IsInstalledControlPlane() bool
GetInjectLabels() map[string]string
}

总结

本文我们主要介绍了应用治理模式的注入机制和开发,用户可以通过查阅需要注入的 ServiceMesh 插件官方文档,通过以上两步完成应用下治理模式的切换。使应用获得不同的治理能力。

· 阅读需 8 分钟

ELK 是三个开源项目的首字母缩写:Elasticsearch、Logstash 和 Kibana。但后来出现的 FileBeat 可以完全替代 Logstash的数据收集功能,也比较轻量级。本文将介绍 EFK: Elasticsearch、Filebeat 和 Kibana

前言

ELK 是三个开源项目的首字母缩写:Elasticsearch、Logstash 和 Kibana。但后来出现的 FileBeat 可以完全替代 Logstash的数据收集功能,也比较轻量级。本文将介绍 EFK: Elasticsearch、Filebeat 和 Kibana

Elasticsearch:分布式搜索和分析引擎,具有高可伸缩、高可靠和易管理等特点。基于 Apache Lucene 构建,能对大容量的数据进行接近实时的存储、搜索和分析操作。通常被用作某些应用的基础搜索引擎,使其具有复杂的搜索功能;

Kibana:数据分析和可视化平台。与 Elasticsearch 配合使用,对其中数据进行搜索、分析和以统计图表的方式展示;

Filebeat:Filebeat 是一个轻量级的传送器,用于转发和集中日志数据。Filebeat 作为代理安装在您的服务器上,监控您指定的日志文件或位置,收集日志事件,并将它们转发到 Elasticsearch 或 Logstash 以进行索引。

通过本文了解如何将运行在 Rainbond 上的应用,通过开启 FileBeat 插件的方式收集应用日志并发送到 Elasticsearch 中。

整合架构

在收集日志时,需要在应用中启用 FileBeat 插件进行收集,FileBeat收集日志有三种方式:

  1. 指定日志路径
  2. 收集所有容器日志
  3. 指定 Label 自动发现

本文使用 指定日志路径进行收集,这种方式我们可以自定义收集日志的规则等。

我们将 FileBeat 制作成 Rainbond 的 一般类型插件 ,在应用启动之后,插件也随之启动并自动收集日志发送至 Elasticsearch,整个过程对应用容器无侵入,且拓展性强。对接其他日志收集也可以用类似方式,用户通过替换插件实现对接不同的日志收集工具。

下图展示了在Rainbond使用FileBeat插件收集应用日志并发送到 Elasticsearch 的结构。

image-20211223162213573

插件实现原理解析

Rainbond插件体系是相对于Rainbond应用模型的一部分,插件主要用来实现应用容器扩展运维能力。由于运维工具的实现有较大的共性,因此插件本身可以被复用。插件必须绑定到应用容器时才具有运行时状态,用以实现一种运维能力,比如性能分析插件、网络治理插件、初始化类型插件。

具有运行时的插件的运行环境与所绑定的组件从以下几个方面保持一致:

  • 网络空间 这个一个至关重要的特性,网络空间一致使插件可以对组件网络流量进行旁路监听和拦截,设置组件本地域名解析等。
  • 存储持久化空间 这个特性使得插件与组件之间可以通过持久化目录进行文件交换。
  • 环境变量 这个特性使得插件可以读取组件的环境变量。

在制作 FileBeat 插件的过程中,使用到了 一般类型插件,可以理解为一个POD启动两个 Container,Kubernetes原生支持一个POD中启动多个 Container,但配置起来相对复杂,在Rainbond中通过插件实现使用户操作简单。

通过Rainbond 应用商店一键安装 EK

我们已将 elasticsearch + Kibana 制作为应用并发布至应用市场,用户可基于开源应用商店一键安装。

  1. 安装 Rainbond
  2. 在开源应用商店搜索 elasticsearch,点击安装即可一键安装;

image-20211223163856435

image-20211223164246240

  1. elasticsearch 默认启用了 xpack 安全模块来保护我们的集群,所以我们需要一个初始化的密码。我们进入 elasticsearch Web终端执行如下所示的命令,Web终端内运行 bin/elasticsearch-setup-passwords 命令来生成默认的用户名和密码:
bin/elasticsearch-setup-passwords 参数
auto 自动生成
interactive 手动填写
  1. 进入 Kibana 组件的环境变量中,修改默认连接 elasticsearch的环境变量 ELASTICSEARCH_PASSWORD

收集应用日志

使用 Nginx 作为本文的演示应用,在Rainbond上使用镜像创建组件,

  • 镜像地址:nginx:latest
  • 挂载存储:/var/log/nginx,将Nginx日志持久化,Filebeat插件可读取到该日志文件。

制作 FileBeat 插件

在Rainbond团队界面点击插件后进入插件界面,点击新建插件,创建一般类型插件。

  • 镜像地址:docker.elastic.co/beats/filebeat:7.15.2
  • 其他自定义即可。

image-20211223165325136

创建插件并构建,构建成功后我们在 Nginx组件的插件中开通 FileBeat 插件。

在Nginx组件的环境配置中,添加 FileBeat 配置文件 如下,更多配置可参考 官方文档

  • 配置文件挂载路径:/usr/share/filebeat/filebeat.yml
  • 配置文件权限:644
filebeat.inputs:
- type: log
paths:
- /var/log/nginx/*.log
output.elasticsearch:
hosts: '127.0.0.1:9200'
username: "elastic"
password: "elastic"

建立依赖关系

将 Nginx 与 elasticsearch 建立依赖关系,使其能通过 127.0.0.1地址与 elasticsearch 通信,更新Nginx组件使依赖生效。

访问Kibana

Kibana默认已汉化

  1. 点击 Stack Management > 索引管理,可看到我们的 filebeat 索引已存在。

  2. Stack Management > 索引模式,创建 filebeat 索引模式。

  3. Discover 页面即可看到日志信息。

image-20211223180227267

总结

基于Rainbond的插件机制与 EFK 结合,使用户可以快速的通过EFK收集应用日志进行分析,并且可灵活的将插件 FileBeat 替换为 Logstash

除此之外,Rainbond的插件机制具有开放性,通过插件机制对应用治理功能进行扩展,例如网络治理类、数据备份类插件,在对原应用逻辑无侵入的情况下,能够通过网络治理类插件对服务的性能进行分析,对接ELK等日志收集系统;对于数据库等组件而言,使用备份插件对数据进行备份。

· 阅读需 3 分钟

1.MaxKey简介

业界领先的身份管理和认证产品

MaxKey单点登录认证系统谐音为马克思的钥匙,寓意是最大钥匙,业界领先的企业级IAM身份管理和认证产品,国内开源IAM第一品牌

  • 统一认证和单点登录,简化账号登录过程,保护账号和密码安全,对账号进行统一管理。
  • 提供简单、标准、安全和开放的用户身份管理(IDM)、身份认证(AM)、单点登录(SSO)、资源管理和权限管理(RBAC)等.
  • 标准安全策略包括密码策略,访问策略;事后安全审计,对用户全生命周期审计、访问行为记录追溯审计、安全合规审计、安全风险预警。

2.通过Rainbond应用商店快速安装MaxKey

  • 在开源应用商店中搜索 MaxKey,点击安装

  • 部署完成后的拓扑图。

  • maxkey-web-maxkey 是认证服务,maxkey-web-mgt 是管理服务。

    账号密码均是:admin maxkey

3.MaxKey能做什么

  • MaxKey是认证平台,可将公司内部的服务平台对接至MaxKey,进行统一登录。比如可以将公司内部的 GitLab 禅道 Jenkins 等支持单点登录协议的服务平台。
  • 本文将通过对接 禅道 实现统一登录。

通过Rainbond应用商店快速安装禅道

  • 在开源应用商店中搜索 禅道,点击进行安装。

  • 安装完成后,访问 禅道 进行初始化设置。

    Mysql密码在组件的依赖中获取。

  • 进入禅道后,点击 后台 > 二次开发 > 应用 > 添加应用。

    • 名称:自定义
    • 代号:maxkey
    • 免密登录:开启
    • IP:无限制

配置MaxKey实现统一登录

  • 进入MaxKey管理服务中,进入应用管理页,编辑 禅道项目管理,进入编辑页面。
  • 需修改:
    • 登录地址:禅道登录地址
    • 秘钥:填写上一步在禅道中添加应用时的秘钥

  • 进入 MaxKey认证服务中,点击禅道项目管理,即可跳转至禅道页面并自动登录。

· 阅读需 6 分钟

Rainbond 作为一款云原生应用管理平台,天生带有引导南北向网络流量的分布式网关 rbd-gateway。区别于一般的 Ingress 配置中,用户需要自行定义域名的使用体验,Rainbond 的网关策略可以一键自动生成域名访问策略,用户通过这个域名可以立刻访问到部署在 Rainbond 上的业务系统。这个使用体验在开发测试场景下非常友好,这篇文章详解了这一机制到底是如何实现的。

Gateway 与 Ingress

Rainbond 团队开发了高性能分布式网关组件 rbd-gateway,作为集群内部的 Ingress Controller 处理集群南北流量。它同时支持 L4 和 L7 层协议,以及一键开启 WebSocket 等高级功能。在使用它的时候,一个细节功能点非常好用,就是可以一键生成一个可以被访问的域名地址。

image-20211202142555295

这个域名的格式详解如下:

http://<servicePort>.<service_alias>.<tenant_name>.17a4cc.grapps.cn/

- servicePort: 访问策略对应的目标端口名称
- service_alias: 当前服务组件的别名
- tenant_name: 当前团队的别名
- .17a4cc.grapps.cn: 当前集群的泛解析域名

实际上,这一条路由规则,是由 Kubernetes 中对应的 ingress 和 service 所定义的。整个访问链路可以归纳为下图:

开启 对外服务 开关,相当于自动生成了以下资源:

apiVersion: v1
kind: Service
metadata:
labels:
creator: Rainbond
event_id: ""
name: gr49d848ServiceOUT
port_protocol: http
protocol: http
rainbond.com/tolerate-unready-endpoints: "true"
service_alias: gr49d848
service_port: "5000"
service_type: outer
tenant_name: 2c9v614j
name: service-8965-5000out
namespace: 3be96e95700a480c9b37c6ef5daf3566
spec:
clusterIP: 172.21.7.172
ports:
- name: tcp-5000
port: 5000
protocol: TCP
targetPort: 5000
selector:
name: gr49d848
sessionAffinity: None
type: ClusterIP
status:
loadBalancer: {}

---

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
annotations:
nginx.ingress.kubernetes.io/weight: "100"
generation: 1
labels:
creator: Rainbond
service_alias: gr49d848
tenant_name: 2c9v614j
name: 3cf8d6bd89250eda87ac127c49694a05
namespace: 3be96e95700a480c9b37c6ef5daf3566
spec:
rules:
- host: 5000.gr49d848.2c9v614j.17a4cc.grapps.cn
http:
paths:
- backend:
serviceName: service-8965-5000out
servicePort: 5000
path: /
status:
loadBalancer: {}

自动生成域名

对于大多数开发者而言,域名算是一种稀缺资源,如何为自己茫茫多的 Ingress rule 分配域名,是一件很令人头疼的事情。毕竟只有拥有了自己的域名时,才能够彻底掌控其解析的规则,避免无止境的修改 /etc/hosts 文件。

市面上绝大多数 Kubernetes 管理工具都可以用半自动的方式生成 Service 与 Ingress资源。这种半自动的方式特指让用户在图形化 UI 界面上,输入必要的信息后,由管理工具自行生成对应的 yaml 配置文件,并加载到 Kubernetes 中去。但是对于所配置的域名,鲜有工具可以做到如 Rainbond 一样的使用体验。

达成这一优秀体验的关键在于泛解析域名的使用。

对泛解析域名最简单明了的解释就是:符合 *.mydomain.com 这一规则的任意域名,都可以解析到同一个 IP 地址上去。在当下这一使用场景中,我们只需要将泛解析域名 *.17a4cc.grapps.cn 解析到 rbd-gateway 所在的服务器 IP 地址,就可以随意为 Ingress rule 配置符合规则的域名了。

Rainbond 在产品设计层面将 Ingress rule 和泛解析域名结合在了一起,自动为每个服务端口生成全局唯一的域名。并在集群安装时,自动向公网 DNS 服务器注册了解析记录,集群安装完毕之后,所生成的所有域名,都是可以被公网解析的,只要 PC 客户端可以使用公网 DNS 服务,就可以解析域名,并访问到指定的服务端口。

Rainbond 通过不同的三级域名 (比如当前场景中的 17a4cc)来区分不同的集群。这里涉及到关于泛解析域名的一个特点,子级域名的解析记录,优先级高于父级域名的解析记录。

===========================================
// 对两级泛解析域名注册解析记录
*.grapps.cn =解析记录注册=> 1.1.1.1
*.17a4cc.grapps.cn =解析记录注册=> 2.2.2.2
===========================================
===========================================
// 客户端解析结果
abc.grapps.cn =解析 IP 地址=> 1.1.1.1
abc.def.grapps.cn =解析 IP 地址=> 1.1.1.1
abc.17a4cc.grapps.cn =解析 IP 地址=> 2.2.2.2 // 优先使用 *.17a4cc.grapps.cn 的解析记录

· 阅读需 12 分钟

两年前Service Mesh(服务网格)一出来就受到追捧,很多人认为它是微服务架构的最终形态,因为它可以让业务代码和微服务架构解耦,也就是说业务代码不需要修改就能实现微服务架构,但解耦还不够彻底,使用还是不方便,虽然架构解耦了,但部署还没有解耦。

  • 无法根据不同环境或客户需要选择合适的Service Mesh框架。
  • 无法做到在开发环境不用学习和使用Service Mesh,生产环境按需开启。

插件式 Service Mesh架构实现思路

目前成熟的ServiceMesh框架也有许多,但是对于用户而言。并不存在万能的ServiceMesh框架,可以解决各种场景的问题。因此我们希望对于用户而言,他只需要关心自己的业务代码。而应用的治理能力,则可以通过不同的ServiceMesh框架进行拓展。用户的业务代码与ServiceMesh框架完全解耦。如下图所示。用户可以随时替换某个应用所使用的ServiceMesh架构。选择与业务最匹配的解决方案。

image-20211211180131913

基于以上思路,我们可以将istio、linkerd、dapr等微服务架构做成插件,开发过程中完全不需要知道Service Mesh框架的存在,只需要处理好业务的依赖关系,当交付到生产环境或客户环境,有些需要性能高、有些需要功能全、有些客户已经指定等各种差异化需求,根据环境和客户需要按需开启不同类型的插件即可,当Service Mesh框架有问题,随时切换。这样Service Mesh框架就变成赋能的工具,老的业务系统重新部署马上就能开启服务治理能力。

Rainbond就是基于上述思路实现的,当前版本已经实现了三个服务治理插件。

  • kubernetes 原生Service 模式
  • 基于envoy的Service Mesh模式
  • Istio服务治理模式

后面我们详细讲解Istio服务治理模式的使用过程。

使用Istio治理模式的实践

有了以上概念,我们可以来看看Rainbond如何与Istio结合。在Rainbond中,用户可以对不同的应用设置不同的治理模式,即用户可以通过切换应用的治理模式,来按需治理应用。这样带来的好处便是用户可以不被某一个ServiceMesh框架所绑定,且可以快速试错,能快速找到最适合当前业务的ServiceMesh框架。

安装Istio 控制面(control plane)

首先在切换到Istio治理模式时,如果未安装Istio的控制面,则会提示需要安装对应的控制面。因此我们需要安装Istio的控制面,控制面在一个集群中只需安装一次,它提供了统一的管理入口,用来管理工作在Istio治理模式下的服务。完成配置下发等功能。结合Rainbond现有的helm安装方式,我们可以便捷的安装好对应的组件。

1. 创建团队

在5.5.0版本中,我们支持了用户在创建团队时指定命名空间。由于默认helm安装的命名空间为 istio-system ,所以为了减少用户配置。我们首先需要创建出对应的团队。如下图所示。团队英文名对应的则是该团队在集群中的命名空间。此处填写 istio-system 。

image-20211212203716453

2. 对接商店

Rainbond支持基于helm直接部署应用,所以接下来对接Rainbond官方helm仓库,后续基于Helm商店部署Istio即可, 在应用市场页面,点击添加商店,选择helm商店,输入相关信息即可完成对接。

商店地址:https://openchart.goodrain.com/goodrain/rainbond

image-20211212203208140

3. 安装 Istio 控制面

商店创建完成后,即可看到对应的 helm 应用,目前Rainbond提供了 istio 1.11.4 版本的helm包,根据 Istio官方文档,该版本对Kubernetes集群的版本支持为 1.19, 1.20, 1.21, 1.22。

  • 安装 base 应用

    选择helm商店中的base应用进行部署,团队选择之前创建的命名空间为 istio-system 的团队。该应用包主要部署了Istio相关的集群资源和 CRD 资源。

    image-20211212204419466

  • 安装 istio-discovery 应用**

    同上述base应用一样,选择正确的团队。安装 istio-discovery 应用。有了这两个应用,就可以拥有 Istio 基础的治理能力了。

示例应用开启Istio治理模式

1. 切换治理模式

我们以SpringBoot后台管理系统 若依 为例,如下图所示,用户可以先从开源应用商店安装一个 若依SpringBoot 应用,版本选择3.6.0,点击治理模式切换,选择Istio治理模式。

image-20211212205811460

在点击切换为Istio治理模式后,会需要用户手动设置内部域名,此处的内部域名将会是该组件在Kubernetes集群中的service名称,在同一个团队下唯一。这里我们修改为可读性较高的内部域名。

image-20211212210008895

2. 修改配置文件

在这一步完成后,我们还需要进入 ruoyi-ui 挂载一个新的配置文件。这主要是因为默认情况下,ruoyi-ui 的配置文件 web.conf 中后端服务地址为 127.0.0.1,在之前使用 Rainbond 内置 ServiceMesh 模式时,由于 Rainbond 会获取到后端服务的地址,注入到 ruoyi-ui 内部, 赋予 ruoyi-ui 一个本地访问地址(127.0.0.1)访问后端服务。所以无需修改就能使用。

但使用 Istio 治理模式时,组件间通过内部域名进行通信,因此需要通过挂载配置文件的方式修改对应的代理地址,ruoyi-ui 的配置文件可以通过右上方的 Web终端 访问到容器中,复制 /app/nginx/conf.d/web.conf 这个文件的内容。修改代理地址后保存,如下图所示。之前我们设置了控制台的内部域名为 ruoyi-admin,所以这里替换为 ruoyi-admin

image-20211212211158509

3. 重启应用

在完成以上两步后,我们需要重启整个应用。在启动应用后,进入组件页面查看,应该可以看到每个组件都有一个类似的 Sidecar 容器,这就是Istio的数据面 (data plane),在应用切换为Istio治理模式以后,该应用下的所有组件都会自动注入对应的 Sidecar 容器,不需要用户额外设置。

至此,该应用已纳入Istio治理范围。用户如果需要对该应用有更多的配置,则可以参考 Istio官方文档 进行扩展。

image

通过Kiali监控和管理Istio

在之前的步骤中,我们使用 Istio 治理模式纳管了 若依 。接下来则带大家一起看看如何使用 Kiali 观测应用间的通信链路。在这一步中,用户需要有 kubectl 命令

1. 安装 prometheus

在Istio中,各个组件通过暴露HTTP接口的方式让Prometheus定时抓取数据(采用了Exporters的方式)。所以Istio控制平面安装完成后,需要在istio-system的命名空间中部署Prometheus,将Istio组件的各相关指标的数据源默认配置在Prometheus中。

同上述base应用一样,选择正确的团队,安装 Prometheus应用。

image-20211214112547510

2. 安装kiali

kiali提供可视化界面监控和管理Istio,能够展示服务拓扑关系,进行服务配置。

安装 kiali-operator 应用,同上述base应用一样,选择正确的团队。

安装过程将自动创建Service,通过Rainbond平台第三方组件的形式可将 kiali 的访问端口暴露出来。如下图所示:

image-20211212212924071

在端口界面添加访问端口,添加以后打开对外服务使用生成的网关策略即可进行访问。

image

kiali登录时需要身份认证token,使用以下命令获取token:

kubectl describe secret $(kubectl get secret -n istio-system | grep istiod-token |awk '{print $1}') -n istio-system

访问到kiali以后,在Applications一栏,选中应用所在的命名空间,就可以看到我们刚刚创建的应用。点击进入,可以看到如下的流量路线。

image-20211212213849724

在 Graph 一栏,也可以看到对应的应用内的流量请求。更多的配置及相关功能参考 Kiali官方文档image-20211212214035677

总结

本文简单介绍了在Rainbond中使用Istio治理模式的操作。以及Rainbond与Istio治理模式的结合。Rainbond为用户提供了一个可选的插件体系,使用户可以根据自己的需求选择不同的Service Mesh框架。在与Istio的结合上,我们主要为用户完成了指定应用数据平面的注入。用户也可以通过该机制扩展自己所需的ServiceMesh框架。后续文章我们将详细讲解如何制作插件,尽请关注。

· 阅读需 6 分钟

Rainbond是一体化的云原生应用管理平台,它提供“以应用为中心”的抽象,使用者不需要学习K8s和容器,平台将K8s和容器封装在内部,这种封装方式能极大提高使用的易用性和安装的便利性,但封装的内部组件如何替换是一个问题,本文将讲解如何使用Harbor替换掉Rainbond原有的默认镜像仓库。

Harbor简介

Harbor 是一个用于存储和分发Docker镜像的企业级Registry服务器,也是首个中国原创的云原生基金会(CNCF)的开源企业级DockerRegistry项目,通过添加一些企业必需的功能特性,例如安全、标识和管理等,扩展了开源Docker Distribution。作为一个企业级私有Registry服务器,Harbor提供了更好的性能和安全。提升用户使用Registry构建和运行环境传输镜像的效率。

通Harbor解决Rainbond镜像管理问题

​Rainbond之前默认使用的是Docker 提供的基础Registry,使用的过程中有很多问题,例如镜像安全性,镜像清理复杂麻烦等等问题,经过不断的调研,而Harbor不仅能解决这些问题,还能扩充很多镜像管理能力,Harbor 的功能主要包括四大类:多用户的管控(基于角色访问控制和项目隔离)、镜像管理策略(存储配额、制品保留、漏洞扫描、来源签名、不可变制品、垃圾回收等)、安全与合规(身份认证、扫描和CVE例外规则等)和互操作性(Webhook、内容远程复制、可插拔扫描器、REST API、机器人账号等)。

对接Harbor

​目前harbor支持两种形式对接Rainbond,一种是作为rainbond内部基础存储仓库,另外一种就是作为外部自定义镜像仓库。

  • Harbor作为Rainbond内部基础存储仓库,进行对接非常简单,只需要在初始化平台集群的时候进行自定义即可。

​Yaml文件的格式要求非常严格,避免大家在配置的时候出现问题,已把正确的yaml文件放在下面,复制就可以使用。

注意:一定修改仓库的名字,仓库的项目名称, 用户名,以及密码,不然会出现镜像上传失败的问题。

例:
apiVersion: rainbond.io/v1alpha1
kind: RainbondCluster
metadata:
name: rainbondcluster
namespace: rbd-system
spec:
imageHub:
domain: www.est.com/test
password: Harbor12345
username: admin
  • Harbor作为rainbond的外部仓库进行提供服务,是基于harbor以及rainbond的webhook功能,配置如下。
    • 保证组件已经开启了镜像仓库的webhook功能,且应用状态不是已关闭状态,并且需要将应用的 webhooks url 配置到目标镜像仓库的 webhooks 中

  • 目标镜像仓库里面,新建一个webhook,然后在 Endpoint 地址填写应用的 webhooks url,配置符合需求的触发事件类型即可

  • 通过Harbor实现镜像可视化存储管理,提高了工作的便利性。

  • 基于Rainbond进行构建的时候实现漏洞自动扫描,提高了安全管理。

  • 通过镜像自动清理的策略,合理利用存储,降低存储成本。

    • 推荐使用策略:应用到仓库匹配, 保留最近推送的3个 artifacts基于条件tags匹配基于条件 无 Tag
    • 推荐定时清理:自定义 cron : 0 0 0 1 /1 (秒,分,时,日,月,周)
  • 镜像是否被签名,漏洞的等级,也可以设置成为镜像安全策略之一,这样可以保证签名过的镜像或者漏洞等级低的镜像才可以被拉取。

整合后的整体流程

通过上面流程图可以看到,整个搭载配置的过程,用户可以自定义镜像源进行拉取镜像,经过Rainbond平台自动推送到Harbor镜像仓库里面,然后等镜像扫描完成以后在进行自动拉取,自动进行构建容器实例。