OpsAny社区版Kubernetes集群部署¶

OpsAny企业订阅版和企业解决方案版本提供Kubernetes集群部署的实施，社区版可以使用我们提供的文档和脚本进行自主集群部署。

我们提供使用Helm方式将OpsAny部署到Kubernetes集群中，你可以提前获取这些工具的相关知识。有关Helm的知识可以参考官方文档 https://helm.sh/zh/docs/。

Kubernetes集群部署OpsAny的主要流程如下：

掌握Kubernetes相关知识（不掌握，请不要部署）。
掌握Helm相关知识。
准备Kubernetes集群(版本要求>=1.20)、安装Helm并检查。
准备Nginx Ingress Controller、基于NFS的Storage Class。
逐个部署OpsAny社区版组件并检查。
登录OpsAny社区版并使用。

Tip

在开始操作之前我们有必要就以下内容达成一致，如不满足，请不要开始操作，毕竟时间是宝贵的：

仅支持域名访问，仅支持域名访问，仅支持域名访问（没有域名请勿基于Kubernetes部署）
任何一个步骤失败，请解决之后，才能继续往下操作，不然只会浪费时间。
对于Kubernetes不熟悉，建议直接放弃，选择更加简单的Docker容器部署版本。（你知道DaemonSet+NodeSector产生的效果吗？不知道就算是我们认为的不熟悉。）
OpsAny社区版K8S部署仅支持通过Ingress进行域名访问，请提前准备好域名，解析到Ingress Controller所在主机。(不理解？请不要部署！)

Kubernetes集群和部署主机准备¶

你需要自主准备一个Kubernetes集群，版本要求>=1.20，建议在云上购买相关的容器服务产品。如果是自有主机可以自行进行部署，参考文档：
- 使用kubeadm部署Kubernetes集群
- 使用SaltStack自动化部署Kubernetes集群
你需要准备一台部署主机，用于执行部署和安装的脚本，本文直接复用Kubernetes集群的Master节点主机。
请再次确认你已经掌握了Kubernetes的基础知识。再次确认Kuberntes版本>=1.20，小于此版本不兼容，无法完成安装部署。
请准备一个访问域名，用于配置Ingress，没有域名请不要开始。

安装kubectl并配置¶

建议在Kubernetes Master节点进行部署，可以免去安装和配置kubectl的步骤。

使用Kubernetes Master节点部署

无需安装kubectl，只需要部署helm即可。

1.部署Helm客户端

$ cd /usr/local/src
$ wget https://get.helm.sh/helm-v3.11.1-linux-amd64.tar.gz
$ tar zxf helm-v3.11.1-linux-amd64.tar.gz
$ mv linux-amd64/helm /usr/local/bin/

2.验证安装是否成功

$ helm version
version.BuildInfo{Version:"v3.2.4", GitCommit:"b29d20baf09943e134c2fa5e1e1cab3bf93315fa", GitTreeState:"clean", GoVersion:"go1.13.7"}

单独主机部署

1.安装kubectl客户端

# 请设置服务端相同版本的客户端版本
$ K8S_VERSION=1.20.11  
$ cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.tencent.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
EOF
$ yum install -y kubectl-${K8S_VERSION}

2.配置kubeconfig

如果是购买的公有云K8S集群，需要开启API Server外网访问，并下载kubeconfig文件，将外网IP地址替换到配置文件中。

$ mkdir -p ~/.kube/
$ vim ~/.kube/config

3.部署Helm客户端

$ cd /usr/local/src
$ wget https://get.helm.sh/helm-v3.11.1-linux-amd64.tar.gz
$ tar zxf helm-v3.11.1-linux-amd64.tar.gz
$ mv linux-amd64/helm /usr/local/bin/

4.验证Helm安装是否成功

$ helm version
version.BuildInfo{Version:"v3.2.4", GitCommit:"b29d20baf09943e134c2fa5e1e1cab3bf93315fa", GitTreeState:"clean", GoVersion:"go1.13.7"}

部署NFS文件共享¶

NFS用于保存OpsAny的共享数据，例如上传的脚本、文件、修改的自定义图片等。日常备份是需要备份这些数据的。如果你的集群已经用了其它的可以使用的Storage Class可以略过这个步骤。同时需要修改后续所有配置中对应的Storage Class名称即可。为了降低复杂度。请不要修改NFS共享路径，后续操作也以这个为主。

1.安装并配置NFS

# For CentOS
$ yum install -y nfs-utils rpcbind

# For Ubuntu
$ apt install -y nfs-server rpcbind

配置NFS

$ mkdir -p /data/k8s-nfs
$ vim /etc/exports
/data/k8s-nfs *(rw,sync,no_root_squash)

2.启动NFS并检查

# For CentOS
$ systemctl enable rpcbind nfs
$ systemctl start rpcbind nfs

# For Ubuntu
$ systemctl enable rpcbind nfs-server
$ systemctl start rpcbind nfs-server

# 请将192.168.56.11修改为你NFS主机的IP地址，
$ NFS_SERVER=192.168.56.11
$ showmount -e ${NFS_SERVER}
Export list for 192.168.56.11:
/data/k8s-nfs *
如果类似上面输出，说明NFS配置完毕。

进行部署环境初始化¶

部署环境初始化分为两个步骤： - 修改配置文件，将正确的配置写入配置文件。 - 执行脚本，利用配置文件中的配置，批量修改所有部署需要的配置文件。

配置安装环境¶

1.安装初始化使用的软件包

CentOS 7.x部署

# 请注意，如果整体复制粘贴执行，请仔细查看输出，偶尔因为网络原因会造成有些命令执行不成功，但是又没发现。
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum install -y git uuid wget mariadb jq python3 python3-pip python3-devel ntpdate
ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
ntpdate time1.aliyun.com
pip3 install -U pip setuptools -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
pip3 install requests==2.25.1 grafana-api==1.0.3 mysql-connector==2.2.9 SQLAlchemy==1.4.22 bcrypt==4.0.1 \
         -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

CentOS 8.x部署

# 请注意，如果整体复制粘贴执行，请仔细查看输出，偶尔因为网络原因会造成有些命令执行不成功，但是又没发现。
dnf -y install mariadb jq git uuid
systemctl enable --now docker
ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
pip3 install -U pip setuptools -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
pip3 install requests==2.25.1 grafana-api==1.0.3 mysql-connector==2.2.9 SQLAlchemy==1.4.22 bcrypt==4.0.1 \
         -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

Ubuntu部署

# 请注意，如果整体复制粘贴执行，请仔细查看输出，偶尔因为网络原因会造成有些命令执行不成功，但是又没发现。
# step 1: 安装必要的一些系统工具
sudo apt-get -y update
sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common
sudo apt-get -y install jq uuid wget mysql-client git ntpdate python3 python3-pip
ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
ntpdate time1.aliyun.com
pip3 install -U pip setuptools -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
pip3 install requests==2.25.1 grafana-api==1.0.3 mysql-connector==2.2.9 SQLAlchemy==1.4.22 bcrypt==4.0.1 \
         -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

2.克隆代码

Gitee

$ cd /opt && git clone --depth=1 https://gitee.com/unixhot/opsany-paas.git

Github

$ cd /opt && git clone --depth=1 https://github.com/unixhot/opsany-paas.git

3.修改配置文件

Step1: 从配置模板生成配置文件

# 从配置模版复制生成配置文件
$ cd /opt/opsany-paas/install && cp install-k8s.config.example install-k8s.config

Step2: 根据实际需求修改配置文件

如果使用了外部的MySQL、Redis、MongoDB需要修改数据库相关地址、用户名和密码，如果是全部使用当前K8S集群部署，仅需要修改下面配置即可。

$ vim install-k8s.config
# 请修改为访问OpsAny的域名，Kubernetes部署需要使用Ingress，所以仅支持域名！
DOMAIN_NAME=demo.opsany.com
# 为了降低复杂度，请不要修改INSTALL_PATH，后面所有操作都是用默认安装路径/data/opsany。

4.执行初始化脚本

初始化脚本的作用就是读取配置文件，然后修改Helm中的value.yaml和服务使用的配置文件，并创建NFS对应的挂载路径等。

# 此脚本会根据install-k8s.config中的配置，生成PaaS部署需要的所有配置文件到安装目录下的Kubernetes目录。
$ cd /opt/opsany-paas/install/
$ ./paas-k8s-install.sh install

创建存储和访问插件¶

1.创建Storage Class

OpsAny使用NFS作为默认的共享存储，用来存放用户上传的文件（uploads目录）、日志文件（logs目录）等。

Step1: 创建OpsAny专属namespace

$ kubectl create ns opsany

Step2: 使用helm安装nfs-subdir-external-provisioner。nfs.server为NFS的IP地址。nfs.path为共享路径

# 请将192.168.56.11修改为你NFS主机的IP地址，
$ NFS_SERVER=192.168.56.11
$ source install-k8s.config

# 安装NFS provisioner，用于StorageClass自动创建PV。
helm install nfs-provisioner ${INSTALL_PATH}/kubernetes/helm/opsany-base/nfs-subdir-external-provisioner \
    --set storageClass.name=nfs-sc-opsany \
    --set nfs.server=${NFS_SERVER} \
    --set nfs.path=/data/k8s-nfs \
    --set storageClass.defaultClass=true \
    --set image.repository=registry.cn-beijing.aliyuncs.com/opsany/nfs-subdir-external-provisioner \
    --set image.tag=v4.0.2 \
    -n opsany

Step3: 查看创建的Pod和Storage Class，后续存储使用的StorageClass全部使用名称：nfs-sc-opsany

# 需要等待Pod正常运行之后继续
$ kubectl get pod -n opsany
NAME                                               READY   STATUS    RESTARTS   AGE
nfs-subdir-external-provisioner-5679c5d797-prn7p   1/1     Running   0          67s

2.创建共享的uploads、logs、proxy的PV和PVC

$ sed -i "s/LOCAL_IP/${NFS_SERVER}/g" ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-nfs.yaml
$ sed -i "s/LOCAL_IP/${NFS_SERVER}/g" ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-proxy/templates/storage.yaml
$ kubectl apply -f ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-nfs.yaml -n opsany

3.部署Nginx Ingress控制器

如果你使用的是公有云产品。那么不需要使用Ingress，在后面的opsany-paas-openresty的过程中，将service的类型修改为LoadBalancer即可。反之需要部署Nginx Ingress Controller，作为访问入口。

# 请给需要部署Nginx Ingress Controller的主机正确的打上标签。
$ kubectl label node linux-node2.example.com edgenode=true

# 创建Ingress Controller，默认使用DaemonSet+NodeSeletor方式运行。
$ kubectl apply -f  ${INSTALL_PATH}/kubernetes/helm/opsany-paas/nginx-ingress.yaml

# 确保Ingress Controller正常运行后继续。
$ kubectl get pod -n ingress-nginx
NAME                                   READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-wpq2d   0/1     Completed   0          10d
ingress-nginx-admission-patch-kdgmr    0/1     Completed   0          10d
ingress-nginx-controller-f68tj         1/1     Running     0          10d

基于Helm部署OpsAny社区版¶

部署OpsAny基础服务¶

手工部署可以清晰的了解整个部署过程，以及涉及到的服务，最重要的是可以发现问题，及时处理。看似文档很长，因为有很大的篇幅是需要检查运行结果。注意必须等待创建的Pod Reday之后，才能继续下一步操作。

1.部署MySQL数据库

推荐你直接使用云RDS产品或者生产环境DBA管理的MySQL实例，这样可以跳过前两个步骤。

# Step1: 部署MySQL
$ helm install opsany-base-mysql ${INSTALL_PATH}/kubernetes/helm/opsany-base/mysql -n opsany
$ kubectl get pod -n opsany | grep "opsany-base-mysql-"

# Step2: 等待Pod状态Ready之后，进入Pod测试MySQL是否可以登录，输入k8s-install.config中配置的MySQL密码进行验证。
$ kubectl exec -it opsany-base-mysql-0 -n opsany -- /bin/bash
$ mysql -u root -p
> show databases;
> exit;
> exit

# Step3: 初始化数据库结构，会创建PaaS和SaaS平台的MySQL数据库。大约需要等待2分钟左右。
cd /opt/opsany-paas/install/
./paas-k8s-install.sh mysql

2.部署MongoDB数据库

推荐你直接使用云RDS产品或者生产环境DBA管理的MongoDB实例，这样可以跳过前两个步骤。

# Step1: 部署MongoDB
$ helm install opsany-base-mongodb ${INSTALL_PATH}/kubernetes/helm/opsany-base/mongodb -n opsany
$ kubectl get pod -n opsany | grep "opsany-base-mongodb-"

# Step2: 等待Pod状态Ready之后，进入Pod测试MongoDB是否可以登录，输入k8s-install.config中配置的MongoDB密码进行验证。
$ kubectl exec -it opsany-base-mongodb-0 -n opsany -- /bin/bash
$ mongosh -u root -p
> show databases;
> exit;
$ exit

# Step3: 初始化数据库结构，会创建SaaS平台使用的MongoDB数据库,大约需要等待1分钟左右。
$ cd /opt/opsany-paas/install/
$ ./paas-k8s-install.sh mongodb

3.部署Redis缓存

推荐你直接使用云RDS产品或者生产环境DBA管理的Redis实例。

# Step1: 部署Redis
$ helm install opsany-base-redis ${INSTALL_PATH}/kubernetes/helm/opsany-base/redis -n opsany
$ kubectl get pod -n opsany | grep "opsany-base-redis-"

# Step2: 等待Pod Ready之后，进入Pod测试Redis是否可以登录，如何你在配置文件修改了密码，请修改此处。
$ kubectl exec -it opsany-base-redis-master-0 -n opsany -- /bin/bash
$ redis-cli
127.0.0.1:6379> auth OpsAny2020
127.0.0.1:6379> info
127.0.0.1:6379> exit
exit

上面的步骤，已经部署了OpsAny需要的基础服务MySQL、MongoDB、Redis，请确保这些服务都正确运行后，再继续操作。如果有任何异常，请停止操作，不然往下操作没有意义！

$ kubectl get pod -n opsany
NAME                                                              READY   STATUS    RESTARTS   AGE
nfs-provisioner-nfs-subdir-external-provisioner-5d44f75dd4z98kf   1/1     Running   0          12m
opsany-base-mongodb-0                                             1/1     Running   0          4m12s
opsany-base-mysql-0                                               1/1     Running   0          6m52s
opsany-base-redis-master-0                                        1/1     Running   0          63s

部署OpsAny PaaS平台¶

1.部署Login服务

Login服务是负责统一登录的服务，直接访问PaaS服务的端口也会调整到Login进行登录。

# Step1: 查看Login服务配置文件修改是否正确，如果不正确，那么后面所有的配置也可能不正确，说明初始化配置有问题，请返回上一个章节。
$ cat ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-login/settings_production.py.login
请检查BK_COOKIE_DOMAIN和DATABASES中的PASSWORD配置十分正确即可。

# Step2: 使用Helm部署Login服务。
$ helm install opsany-paas-login ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-login/ -n opsany

# Step3: 等待到30-60秒后，查看Login服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-login-"

# Step4: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
$ LOGIN_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-login' | awk -F ' ' '{print $3}')
$ curl --head http://${LOGIN_SVC}:8003/healthz/

2.部署ESB服务

ESB是企业服务总线，依赖MySQL、Redis、PaaS服务、Login服务。

# Step1: 使用Helm部署ESB服务。
$ helm install opsany-paas-esb ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-esb/ -n opsany

# Step2: 等待到30-60秒后，查看ESB服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-esb-"

# Step3: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
$ ESB_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-esb' | awk -F ' ' '{print $3}')
$ curl --head http://${ESB_SVC}:8002/healthz/

3.部署Appengine服务

Appengine服务是PaaS平台中, 负责托管SaaS应用的后台服务模块，依赖MySQL、PaaS服务。

# Step1: 使用Helm部署AppEngine服务。
$ helm install opsany-paas-appengine ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-appengine/ -n opsany

# Step2: 等待到30-60秒后，查看AppEngine服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-appengine-"

# Step3: 测试访问，返回【HTTP/1.1 200 OK】为正常，5XX状态码为异常。
$ AppEngine_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-appengine' | awk -F ' ' '{print $3}')
$ curl --head http://${AppEngine_SVC}:8000/v1/healthz/

4.部署PaaS服务

PaaS服务是PaaS平台中的开发者中心及Web工作台的功能，使用MySQL数据库，依赖Login和AppEngine服务，监听8001端口。

# Step1: 使用Helm部署PaaS服务。
$ helm install opsany-paas-paas ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-paas -n opsany

# Step2: 等待到30-60秒后，查看PaaS服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-paas-"

# Step3: 测试访问，返回【HTTP/1.1 200 OK】为正常，4XX、5XX状态码为异常。
$ PAAS_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-paas' | awk -F ' ' '{print $3}')
$ curl --head http://${PAAS_SVC}:8001/healthz/

5.部署Gucad RDP代理

Gucad用于堡垒机通过RDP协议远程连接Windows远程桌面和堡垒机通过Telent远程连接网络设备。

# Step1: 使用Helm部署Gucad RDP服务。
$ helm install opsany-paas-guacd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-guacd -n opsany

# Step2: 等待到30-60秒后，查看Guacd服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-guacd-"

6.部署堡垒机WebSocket服务

Websocket服务用于堡垒机底层通信，如果服务故障，会导致堡垒机无法使用。

# Step1: 使用Helm部署WebSocket服务。
$ helm install opsany-paas-websocket ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-websocket/ -n opsany

# Step2: 等待到30-60秒后，查看WebSocket服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-websocket-"

7.部署OpsAny Grafana服务

OpsAny集成了Grafana用于可视化数据展示。

# Step1: 使用Helm部署Grafana服务。
$ helm install opsany-paas-grafana ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-grafana/ -n opsany

# Step2: 等待到30-60秒后，查看Proxy服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-grafana-"

# Step3: 测试访问，返回【HTTP/1.1 200 OK】为正常，5XX状态码为异常。
$ GRAFANA_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-grafana' | awk -F ' ' '{print $3}')
$ curl --head -k https://${GRAFANA_SVC}:8007/grafana/login

8.部署OpenResty服务

OpenResty是访问OpsAny的入口，所有请求经过OpenResty进行转发。

# Step1: 使用Helm部署OpenResty服务。
$ helm install opsany-paas-openresty ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/ -n opsany

# Step2: 等待到30-60秒后，查看AppEngine服务Pod状态是否为Running。
$ kubectl get pod -n opsany | grep "opsany-paas-openresty-"

# Step3: 测试访问，返回【HTTP/1.1 200 OK】为正常，5XX状态码为异常。
$ OpenResty_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-openresty' | awk -F ' ' '{print $3}')
$ curl --head http://{$OpenResty_SVC}

9.访问OpsAny PaaS平台并测试

截止目前，你已经逐步部署了OpsAny PaaS所需要的所有服务，现在可以打开浏览器，使用域名进行访问测试。请使用install-k8s.config中设置的DOMAIN_NAME进行访问。 - 访问地址：https://$DOMAIN_NAME/ - 默认用户名：admin
- 默认密码：admin

注意：请先不要修改密码，安装完毕SaaS平台后，会自动修改密码，请注意安装完成后的消息输出。

部署OpsAny SaaS平台¶

0.执行脚本，生成配置文件，如果执行失败，请不要继续做任何操作。

# 为各个SaaS生成配置文件
cd /opt/opsany-paas/install/
./saas-ce-k8s-install.sh install
source /opt/opsany-paas/install/install-k8s.config

1.部署统一权限-rbac

# Step1: 使用Helm部署rbac服务。
helm install opsany-saas-rbac ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-rbac/ -n opsany

# Step2: 等待到30-60秒后，查看rbac服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-rbac-"

$ Step3: 执行数据库创建
RBAC_POD=$(kubectl get pod -n opsany | grep opsany-saas-rbac | awk '{print $1}')
kubectl exec $RBAC_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/rbac/manage.py migrate --noinput && python /opt/opsany/rbac/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启workbench访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7001/opsany-saas-rbac:7001/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
RBAC_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-rbac' | awk -F ' ' '{print $3}')
curl --head http://${RBAC_SVC}:7001/o/rbac/healthz/

2.部署工作台-workbench

# Step1: 使用Helm部署workbench服务。
helm install opsany-saas-workbench ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-workbench/ -n opsany

# Step2: 等待到30-60秒后，查看workbench服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-workbench-"

# Step3: 执行数据库创建
WORKBENCH_POD=$(kubectl get pod -n opsany | grep opsany-saas-workbench | awk '{print $1}')
kubectl exec $WORKBENCH_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/workbench/manage.py migrate --noinput && python /opt/opsany/workbench/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启workbench访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7002/opsany-saas-workbench:7002/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code workbench

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
WORKBENCH_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-workbench' | awk -F ' ' '{print $3}')
curl --head http://${WORKBENCH_SVC}:7002/o/workbench/healthz/

3.部署资源平台-cmdb

# Step1: 使用Helm部署cmdb服务。 
helm install opsany-saas-cmdb ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-cmdb/ -n opsany 

# Step2: 等待到30-60秒后，查看cmdb服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-cmdb-"

# Step3: 执行数据库创建
CMDB_POD=$(kubectl get pod -n opsany | grep opsany-saas-cmdb | awk '{print $1}')
kubectl exec $CMDB_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/cmdb/manage.py migrate --noinput && python /opt/opsany/cmdb/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启cmdb访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7003/opsany-saas-cmdb:7003/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code cmdb

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
CMDB_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-cmdb' | awk -F ' ' '{print $3}')
curl --head http://${CMDB_SVC}:7003/o/cmdb/healthz/

4.部署管控平台-Control

# Step1: 使用Helm部署control服务。
helm install opsany-saas-control ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-control/ -n opsany

# Step2: 等待到30-60秒后，查看control服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-control-"

# Step3: 执行数据库创建
CONTROL_POD=$(kubectl get pod -n opsany | grep opsany-saas-control | awk '{print $1}')
kubectl exec $CONTROL_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/control/manage.py migrate --noinput && python /opt/opsany/control/manage.py createcachetable django_cache > /dev/null"

# Step4: 修改Openresty配置，开启control访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7004/opsany-saas-control:7004/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code control

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
CONTROL_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-control' | awk -F ' ' '{print $3}')
curl --head http://${CONTROL_SVC}:7004/o/control/healthz/

5.部署作业平台-job

# Step1: 使用Helm部署job服务。
helm install opsany-saas-job ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-job/ -n opsany

# Step2: 等待到30-60秒后，查看job服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-job-"

# Step3: 执行数据库创建
JOB_POD=$(kubectl get pod -n opsany | grep opsany-saas-job | awk '{print $1}')
kubectl exec $JOB_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/job/manage.py migrate --noinput && python /opt/opsany/job/manage.py createcachetable django_cache > /dev/null"

# Step4: 修改Openresty配置，开启job访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7005/opsany-saas-job:7005/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code job

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
JOB_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-job' | awk -F ' ' '{print $3}')
curl --head http://${JOB_SVC}:7005/o/job/healthz/

6.部署云管平台-cmp

# Step1: 使用Helm部署cmp服务。
helm install opsany-saas-cmp ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-cmp/ -n opsany

# Step2: 等待到30-60秒后，查看cmp服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-cmp-"

# Step3: 执行数据库创建
CMP_POD=$(kubectl get pod -n opsany | grep opsany-saas-cmp | awk '{print $1}')
kubectl exec $CMP_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/cmp/manage.py migrate --noinput && python /opt/opsany/cmp/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启cmp访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7007/opsany-saas-cmp:7007/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code cmp

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
CMP_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-cmp' | awk -F ' ' '{print $3}')
curl --head http://${CMP_SVC}:7007/o/cmp/healthz/

7.部署堡垒机-bastion

# Step1: 使用Helm部署bastion服务。
helm install opsany-saas-bastion ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-bastion/ -n opsany

# Step2: 等待到30-60秒后，查看bastion服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-bastion-"

# Step3: 执行数据库创建
BASTION_POD=$(kubectl get pod -n opsany | grep opsany-saas-bastion | awk '{print $1}')
kubectl exec $BASTION_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/bastion/manage.py migrate --noinput && python /opt/opsany/bastion/manage.py createcachetable django_cache > /dev/null"

# Step4: 修改Openresty配置，开启bastion访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7008/opsany-saas-bastion:7008/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code bastion

# Step6: 测试堡垒机访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
BASTION_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-bastion' | awk -F ' ' '{print $3}')
curl --head http://${BASTION_SVC}:7008/o/bastion/healthz/

# Step7: 测试Websocket访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
WEBSOCKET_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-websocket' | awk -F ' ' '{print $3}')
curl --head http://${WEBSOCKET_SVC}:8004/healthz/

8.部署基础监控-monitor

# Step1: 使用Helm部署monitor服务。
helm install opsany-saas-monitor ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-monitor/ -n opsany

# Step2: 等待到30-60秒后，查看monitor服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-saas-monitor-"

# Step3: 执行数据库创建
MONITOR_POD=$(kubectl get pod -n opsany | grep opsany-saas-monitor | awk '{print $1}')
kubectl exec $MONITOR_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/monitor/manage.py migrate --noinput && python /opt/opsany/monitor/manage.py createcachetable django_cache > /dev/null"

# Step4: 修改Openresty配置，开启monitor访问
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7006/opsany-saas-monitor:7006/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code monitor

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
MONITOR_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-monitor' | awk -F ' ' '{print $3}')
curl --head http://${MONITOR_SVC}:7006/o/monitor/healthz/

9.部署应用平台-devops

# Step1: 使用Helm部署devops服务。 
helm install opsany-saas-devops ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-devops/ -n opsany

# Step2: 等待到30-60秒后，查看devops服务Pod状态是否为Running。 
kubectl get pod -n opsany | grep "opsany-saas-devops-"

# Step3: 执行数据库创建
DEVOPS_POD=$(kubectl get pod -n opsany | grep opsany-saas-devops | awk '{print $1}')
kubectl exec $DEVOPS_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/devops/manage.py migrate --noinput && python /opt/opsany/devops/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启devops访问 
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7009/opsany-saas-devops:7009/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code devops

# Step6: 测试应用平台访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
DEVOPS_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-devops' | awk -F ' ' '{print $3}')
curl --head http://${DEVOPS_SVC}:7009/o/devops/healthz/

10.部署代码仓库-code

# Step1: 使用Helm部署code服务。 
helm install opsany-saas-code ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-code/ -n opsany

# Step2: 等待到30-60秒后，查看code服务Pod状态是否为Running。 
kubectl get pod -n opsany | grep "opsany-saas-code-"

# Step3: 执行数据库创建
CODE_POD=$(kubectl get pod -n opsany | grep opsany-saas-code | awk '{print $1}')
kubectl exec $CODE_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/code/manage.py migrate --noinput && python /opt/opsany/code/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启code访问 
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7010/opsany-saas-code:7010/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code code

# Step6: 测试代码仓库访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
CODE_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-code' | awk -F ' ' '{print $3}')
curl --head http://${CODE_SVC}:7010/o/code/healthz/

11.部署应用平台-pipeline

# Step1: 使用Helm部署pipeline服务。 
helm install opsany-saas-pipeline ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-pipeline/ -n opsany

# Step2: 等待到30-60秒后，查看pipeline服务Pod状态是否为Running。 
kubectl get pod -n opsany | grep "opsany-saas-pipeline-"

# Step3: 执行数据库创建
PIPELINE_POD=$(kubectl get pod -n opsany | grep opsany-saas-pipeline | awk '{print $1}')
kubectl exec $PIPELINE_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/pipeline/manage.py migrate --noinput && python /opt/opsany/pipeline/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启pipeline访问 
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7017/opsany-saas-pipeline:7017/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code pipeline

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
PIPELINE_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-pipeline' | awk -F ' ' '{print $3}')
curl --head http://${PIPELINE_SVC}:7017/o/pipeline/healthz/

12.部署应用平台-repo

# Step1: 使用Helm部署repo服务。 
helm install opsany-saas-repo ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-repo/ -n opsany

# Step2: 等待到30-60秒后，查看repo服务Pod状态是否为Running。 
kubectl get pod -n opsany | grep "opsany-saas-repo-"

# Step3: 执行数据库创建
REPO_POD=$(kubectl get pod -n opsany | grep opsany-saas-repo | awk '{print $1}')
kubectl exec $REPO_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/repo/manage.py migrate --noinput && python /opt/opsany/repo/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启repo访问 
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7020/opsany-saas-repo:7020/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code repo

# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
REPO_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-repo' | awk -F ' ' '{print $3}')
curl --head http://${REPO_SVC}:7020/o/repo/healthz/

13.部署应用平台-deploy

# Step1: 使用Helm部署deploy服务。 
helm install opsany-saas-deploy ${INSTALL_PATH}/kubernetes/helm/opsany-saas/opsany-saas-deploy/ -n opsany

# Step2: 等待到30-60秒后，查看deploy服务Pod状态是否为Running。 
kubectl get pod -n opsany | grep "opsany-saas-deploy-"

# Step3: 执行数据库创建
DEPLOY_POD=$(kubectl get pod -n opsany | grep opsany-saas-deploy | awk '{print $1}')
kubectl exec $DEPLOY_POD -n opsany -- sh -c   "export BK_ENV="production" && python /opt/opsany/deploy/manage.py migrate --noinput && python /opt/opsany/deploy/manage.py createcachetable django_cache"

# Step4: 修改Openresty配置，开启deploy访问 
cd ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-openresty/
sed -i 's/127.0.0.1:7018/opsany-saas-deploy:7018/g' opsany_paas.conf
helm upgrade opsany-paas-openresty . -n opsany
OPENRESTY_POD=$(kubectl get pod -n opsany | grep opsany-paas-openresty | awk '{print $1}')
kubectl delete pod ${OPENRESTY_POD} -n opsany
kubectl get pod -n opsany | grep opsany-paas-openresty

# Step5: 从RBAC同步用户
cd /opt/opsany-paas/saas/
python3 sync-user-script.py --domain https://${DOMAIN_NAME} --paas_username admin --paas_password admin --app_code deploy


# Step6: 测试访问，返回【HTTP/1.1 200 OK】为正常，其它状态码为异常。
DEPLOY_SVC=$(kubectl get svc -n opsany | grep 'opsany-saas-deploy' | awk -F ' ' '{print $3}')
curl --head http://${DEPLOY_SVC}:7018/o/deploy/healthz/

14.部署OpsAny Proxy服务

Proxy服务用于对运维对象进行纳管操作，可以纳管主机、交换机、路由器、数据库等。被纳管的主机需要可以访问到Proxy的8011、8012、4505、4506端口。所以Proxy服务需要做特殊处理，分为两个方案：

方案1: 部署到Kubernetes集群中，然后将端口暴漏到集群外访问。
方案2: 单独部署在Kubernetes集群或集群外主机上（推荐）。请参考此文档： Proxy独立部署

部署到Kubernetes集群中实现：

OpsAny Proxy使用HostNetwork，将直接监听Node主机的8011、8012、4505、4506端口。
使用Node Selctor将Proxy指定到固定的节点上去，方便内部开放IP白名单。

# Step0: 请选择一个节点，用于运行OpsAny Proxy，为该节点打上标签
kubectl label node k8s-node3.example.com opsany-role=proxy

# Step1: 使用Helm部署Proxy服务。
mkdir -p /data/k8s-nfs/opsany-logs/proxy
helm install opsany-paas-proxy ${INSTALL_PATH}/kubernetes/helm/opsany-paas/opsany-paas-proxy/ -n opsany

# Step2: 等待到30-60秒后，查看Proxy服务Pod状态是否为Running。
kubectl get pod -n opsany | grep "opsany-paas-proxy-"

# Step3: 执行数据库创建
PROXY_POD=$(kubectl get pod -n opsany | grep opsany-paas-proxy | awk '{print $1}')
kubectl exec $PROXY_POD -n opsany -- sh -c  "export OPS_ANY_ENV="production" && /usr/local/bin/python3 /opt/opsany-proxy/manage.py makemigrations && /usr/local/bin/python3 /opt/opsany-proxy/manage.py migrate"

# Step4: 测试访问，返回【HTTP/1.1 200 OK】为正常，5XX状态码为异常。
PROXY_SVC=$(kubectl get svc -n opsany | grep 'opsany-paas-proxy' | awk -F ' ' '{print $3}')
curl --head http://{$PROXY_SVC}:8010/api/proxy/v0_1/ht/

进行OpsAny平台初始化¶

1.执行初始化脚本

OpsAny初始化用于帮助用户做很多初始化的配置操作： - 工作台-导入工单流程案例、工单案例。 - 管控平台-采控管理-创建内置控制器（Proxy） - 为所有SaaS平台进行用户信息初始化 - 导入作业平台内置作业 - 导入作业平台内置脚本

# 执行完毕之后会修改admin的密码。
cd /opt/opsany-paas/install/
./saas-ce-k8s-install.sh init

2.访问平台，进行基础设置。

安装完毕之后，在控制台会输出访问的地址和密码。请使用Chrome浏览器打开。

访问地址：https://$DOMAIN_NAME
用户名：admin
密码：为了安全考虑，安装完毕之后自动修改并且输出。同时保存在$INSTALL_PATH/conf/.passwd_env文件中。

3.放置Agent和内置文档

# 下载Agent部署包到NFS的卷中
cd /data/k8s-nfs/opsany-uploads/
wget https://opsany.oss-cn-beijing.aliyuncs.com/opsany-agent-2.2.0.tar.gz
tar zxf opsany-agent-2.2.0.tar.gz

# 下载内置文档到NFS的卷中
cd /data/k8s-nfs/opsany-uploads/
wget https://opsany.oss-cn-beijing.aliyuncs.com/opsany-docs-2.2.2.tar.gz
tar zxf opsany-docs-2.2.2.tar.gz

4.现在就可以正式使用OpsAny了，强烈建议你，先从快速入门开始，将资源进行纳管，然后再研究其它功能。

登录后，需要在【管控平台】-【采控管理】页面进行“控制器（proxy）”和“Grafana集成”的配置方可正常使用。

快速入门

如果你遇到问题，建议先看下常见问题，看是否有收获。

常见问题

如果你需要使用基础监控，还需要集成Zabbix。

基础监控部署

如果你想使用DevOps相关功能，请继续部署。

应用平台部署

部署完毕后，想替换HTTPS证书，请按此操作。

替换HTTPS证书

在线部署完成后，方可进行离线部署。

离线部署手册

OpsAny社区版Kubernetes集群部署¶

Kubernetes集群和部署主机准备¶

安装kubectl并配置¶

部署NFS文件共享¶

进行部署环境初始化¶

配置安装环境¶

创建存储和访问插件¶

基于Helm部署OpsAny社区版¶

部署OpsAny基础服务¶

部署OpsAny PaaS平台¶

部署OpsAny SaaS平台¶

进行OpsAny平台初始化¶

热门产品

解决方案

服务支持

公司信息

资源平台

管控平台

作业平台

基础监控

云管平台

应用平台

工作台

统一权限

堡垒机

智能巡检

事件中心

知识库

日志平台

容器平台

应用监控

管控面板

稳定性平台

容量管理

价格方案

视频教程

联系我们

运维社区

OpsAny社区版Kubernetes集群部署¶

Kubernetes集群和部署主机准备¶

安装kubectl并配置¶

部署NFS文件共享¶

进行部署环境初始化¶

配置安装环境¶

创建存储和访问插件¶

基于Helm部署OpsAny社区版¶

部署OpsAny基础服务¶

部署OpsAny PaaS平台¶

部署OpsAny SaaS平台¶

进行OpsAny平台初始化¶

热门产品

解决方案

服务支持

公司信息