KubeSphere实战
文章目录
- 一、KubeSphere平台安装
-
- 1、Kubernetes上安装KubeSphere
-
- 1.1 安装docker
- 1.2 安装Kubernetes
- 1.3 前置环境之nfs存储
- 1.4 前置环境之metrics-server
- 1.5 安装KubeSphere
- 2、Linux单节点部署KubeSphere
- 3、Linux多节点部署KubeSphere(推荐)
- 二、KubeSphere实战
-
- 1、多租户实战
- 2、中间件部署实战
-
- 2.1 MySql部署
- 2.2 redis部署
- 2.3 部署ElasticSearch
- 2.4 应用商店部署
- 2.5 应用仓库部署(推荐)
- 3、RuoYi-Cloud部署实战
-
- 3.1 本地部署
- 3.2 k8s中间件部署
- 3.3 微服务层部署
- 4、云原生DevOps实战
-
- 4.1 环境和中间件准备
- 4.2 Jenkins构建
- 4.3 webhook
一、KubeSphere平台安装
官网：https://kubesphere.com.cn/
1、Kubernetes上安装KubeSphere
1.1 安装docker
# centos7.9，建议机器4核8G
sudo yum remove docker*
sudo yum install -y yum-utils
#配置docker的yum地址
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#安装指定版本
sudo yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7 containerd.io-1.4.6
# 启动&开机启动docker
systemctl enable docker --now
# docker加速配置
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2"
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1.2 安装Kubernetes
首先基本环境的安装，每个机器使用内网ip互通，每个机器配置自己的hostname，不能用localhost
#设置每个机器自己的hostname，k8s-master/node1/node2
hostnamectl set-hostname xxx
# 将 SELinux 设置为 permissive 模式（相当于将其禁用）
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
# 关闭防火墙，云的花内网需要互通
systemctl stop firewalld
# 禁用 firewalld 服务
systemctl disable firewalld
#关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab
#允许 iptables 检查桥接流量
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sudo sysctl --system
然后安装kubelet、kubeadm、kubectl
#配置k8s的yum源地址
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
#安装 kubelet，kubeadm，kubectl
sudo yum install -y kubelet-1.21.9 kubeadm-1.21.9 kubectl-1.21.9
#启动kubelet
sudo systemctl enable --now kubelet
#所有机器配置master域名,改成自己的ip
echo "192.168.249.146 k8s-master" >> /etc/hosts
cat > /etc/hosts <<EOF
192.168.249.146 k8s-master
192.168.249.147 node1
192.168.249.148 node2
EOF
初始化master节点
# 注意ip和主机名的修改
kubeadm init \
--apiserver-advertise-address=192.168.249.146 \
--control-plane-endpoint=k8s-master \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.21.9 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16
# 然后记录相关信息
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
# 安装Calico网络插件
curl https://docs.projectcalico.org/v3.20/manifests/calico.yaml -O
# 如果失败了就自己手动下载导入
# https://github.com/projectcalico/calico/releases
kubectl apply -f calico.yaml
# 如果手动下载，无法下载镜像时，所有结点导入calico-cni/calico-node/calico-pod2daemon-flexvol，master结点需要额外导入calico-kube-controllers
# 最后node结点加入集群
# 对于重置结点，现在主节点去除
kubectl delete node node2
kubectl get node
# 然后node2从节点重置
kubeadm reset
1.3 前置环境之nfs存储
安装nfs-server
# 在每个机器
yum install -y nfs-utils
# 在master 执行以下命令
echo "/nfs/data/ *(insecure,rw,sync,no_root_squash)" > /etc/exports
# 执行以下命令，启动 nfs 服务;创建共享目录
mkdir -p /nfs/data
# 在master执行
systemctl enable rpcbind
systemctl enable nfs-server
systemctl start rpcbind
systemctl start nfs-server
# 使配置生效
exportfs -r
#检查配置是否生效
exportfs
# 配置nfs-client（选做）
# 注意在非master结点，注意ip修改
showmount -e 192.168.249.146
mkdir -p /nfs/data
mount -t nfs 192.168.249.146:/nfs/data /nfs/data
配置默认存储，在master执行，vim sc.yaml，注意nfs地址改成自己的
## 创建了一个存储类
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: nfs-storage
annotations:
storageclass.kubernetes.io/is-default-class: "true"
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner
parameters:
archiveOnDelete: "true" ## 删除pv的时候，pv的内容是否要备份
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: nfs-client-provisioner
labels:
app: nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
spec:
replicas: 1
strategy:
type: Recreate
selector:
matchLabels:
app: nfs-client-provisioner
template:
metadata:
labels:
app: nfs-client-provisioner
spec:
serviceAccountName: nfs-client-provisioner
containers:
- name: nfs-client-provisioner
image: registry.cn-beijing.aliyuncs.com/kubesphereio/nfs-subdir-external-provisioner:v4.0.2
# resources:
# limits:
# cpu: 10m
# requests:
# cpu: 10m
volumeMounts:
- name: nfs-client-root
mountPath: /persistentvolumes
env:
- name: PROVISIONER_NAME
value: k8s-sigs.io/nfs-subdir-external-provisioner
- name: NFS_SERVER
value: 192.168.249.146 ## 指定自己nfs服务器地址
- name: NFS_PATH
value: /nfs/data ## nfs服务器共享的目录
volumes:
- name: nfs-client-root
nfs:
server: 192.168.249.146
path: /nfs/data
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: nfs-client-provisioner-runner
rules:
- apiGroups: [""]
resources: ["nodes"]
verbs: ["get", "list", "watch"]
- apiGroups: [""]
resources: ["persistentvolumes"]
verbs: ["get", "list", "watch", "create", "delete"]
- apiGroups: [""]
resources: ["persistentvolumeclaims"]
verbs: ["get", "list", "watch", "update"]
- apiGroups: ["storage.k8s.io"]
resources: ["storageclasses"]
verbs: ["get", "list", "watch"]
- apiGroups: [""]
resources: ["events"]
verbs: ["create", "update", "patch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: run-nfs-client-provisioner
subjects:
- kind: ServiceAccount
name: nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
roleRef:
kind: ClusterRole
name: nfs-client-provisioner-runner
apiGroup: rbac.authorization.k8s.io
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: leader-locking-nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
rules:
- apiGroups: [""]
resources: ["endpoints"]
verbs: ["get", "list", "watch", "create", "update", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: leader-locking-nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
subjects:
- kind: ServiceAccount
name: nfs-client-provisioner
# replace with namespace where provisioner is deployed
namespace: default
roleRef:
kind: Role
name: leader-locking-nfs-client-provisioner
apiGroup: rbac.authorization.k8s.io
确认配置是否生效，kubectl get sc，这样配置完成之后就拥有动态创建pv的能力，例如如下可以自行测试
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: my-pvc
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 3Gi
1.4 前置环境之metrics-server
metrics-server是集群指标监控组件(这里用了别人的镜像库)，vim metrics.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
labels:
k8s-app: metrics-server
name: metrics-server
namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
labels:
k8s-app: metrics-server
rbac.authorization.k8s.io/aggregate-to-admin: "true"
rbac.authorization.k8s.io/aggregate-to-edit: "true"
rbac.authorization.k8s.io/aggregate-to-view: "true"
name: system:aggregated-metrics-reader
rules:
- apiGroups:
- metrics.k8s.io
resources:
- pods
- nodes
verbs:
- get
- list
- watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
labels:
k8s-app: metrics-server
name: system:metrics-server
rules:
- apiGroups:
- ""
resources:
- pods
- nodes
- nodes/stats
- namespaces
- configmaps
verbs:
- get
- list
- watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
labels:
k8s-app: metrics-server
name: metrics-server-auth-reader
namespace: kube-system
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: extension-apiserver-authentication-reader
subjects:
- kind: ServiceAccount
name: metrics-server
namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
labels:
k8s-app: metrics-server
name: metrics-server:system:auth-delegator
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:auth-delegator
subjects:
- kind: ServiceAccount
name: metrics-server
namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
labels:
k8s-app: metrics-server
name: system:metrics-server
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:metrics-server
subjects:
- kind: ServiceAccount
name: metrics-server
namespace: kube-system
---
apiVersion: v1
kind: Service
metadata:
labels:
k8s-app: metrics-server
name: metrics-server
namespace: kube-system
spec:
ports:
- name: https
port: 443
protocol: TCP
targetPort: https
selector:
k8s-app: metrics-server
---
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
k8s-app: metrics-server
name: metrics-server
namespace: kube-system
spec:
selector:
matchLabels:
k8s-app: metrics-server
strategy:
rollingUpdate:
maxUnavailable: 0
template:
metadata:
labels:
k8s-app: metrics-server
spec:
containers:
- args:
- --cert-dir=/tmp
- --kubelet-insecure-tls
- --secure-port=4443
- --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
- --kubelet-use-node-status-port
image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/metrics-server:v0.4.3
imagePullPolicy: IfNotPresent
livenessProbe:
failureThreshold: 3
httpGet:
path: /livez
port: https
scheme: HTTPS
periodSeconds: 10
name: metrics-server
ports:
- containerPort: 4443
name: https
protocol: TCP
readinessProbe:
failureThreshold: 3
httpGet:
path: /readyz
port: https
scheme: HTTPS
periodSeconds: 10
securityContext:
readOnlyRootFilesystem: true
runAsNonRoot: true
runAsUser: 1000
volumeMounts:
- mountPath: /tmp
name: tmp-dir
nodeSelector:
kubernetes.io/os: linux
priorityClassName: system-cluster-critical
serviceAccountName: metrics-server
volumes:
- emptyDir: {}
name: tmp-dir
---
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
labels:
k8s-app: metrics-server
name: v1beta1.metrics.k8s.io
spec:
group: metrics.k8s.io
groupPriorityMinimum: 100
insecureSkipTLSVerify: true
service:
name: metrics-server
namespace: kube-system
version: v1beta1
versionPriority: 100
测试
kubectl top nodes
kubectl top pod -A
1.5 安装KubeSphere
安装文档参考：https://kubesphere.com.cn/docs/v3.3/quick-start/minimal-kubesphere-on-k8s/
# 这里安装需要国外源网络
# 下载核心文件
wget https://github.com/kubesphere/ks-installer/releases/download/v3.3.1/kubesphere-installer.yaml
wget https://github.com/kubesphere/ks-installer/releases/download/v3.3.1/cluster-configuration.yaml
kubectl apply -f kubesphere-installer.yaml
# 注意在启动这个文件前可以选择额外功能，这里默认最小安装，要啥功能将false改为true即可
kubectl apply -f cluster-configuration.yaml
# 在 cluster-configuration.yaml中指定我们需要开启的功能参照官网"启用可插拔组件"：https://kubesphere.com.cn/docs/pluggable-components/overview/
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
# 成功后访问
# 访问任意机器的 30880端口
# 账号 ： admin
# 密码 ： P@88w0rd
# 解决etcd监控证书找不到问题
kubectl -n kubesphere-monitoring-system create secret generic kube-etcd-client-certs --from-file=etcd-client-ca.crt=/etc/kubernetes/pki/etcd/ca.crt --from-file=etcd-client.crt=/etc/kubernetes/pki/apiserver-etcd-client.crt --from-file=etcd-client.key=/etc/kubernetes/pki/apiserver-etcd-client.key
2、Linux单节点部署KubeSphere
官网参考：https://kubesphere.com.cn/docs/v3.3/quick-start/all-in-one-on-linux/
# 首先指定一下hostname
hostnamectl set-hostname node1
# 安装
# 准备KubeKey，国内的下载
export KKZONE=cn
curl -sfL https://get-kk.kubesphere.io | VERSION=v2.3.0 sh -
# 使其拥有可执行权限
chmod +x kk
# 开始安装下载
# ./kk create cluster [--with-kubernetes version] [--with-kubesphere version]
./kk create cluster --with-kubernetes v1.22.12 --with-kubesphere v3.3.1
# 验证安装结果
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l 'app in (ks-install, ks-installer)' -o jsonpath='{.items[0].metadata.name}') -f
# 输出信息会显示 Web 控制台的 IP 地址和端口号，默认的 NodePort 是 30880。现在，您可以使用默认的帐户和密码 (admin/P@88w0rd) 通过 :30880 访问控制台
# kubectl get pod --all-namespaces 查看相关组件情况
仅适用于默认的最小化安装。若要在 KubeSphere 中启用其他组件，请参见启用可插拔组件
进入可视化后也可以启用需要的组件，以 admin 用户登录控制台，点击左上角的平台管理，选择集群管理，点击定制资源定义，在搜索栏中输入 clusterconfiguration，点击选择需要打开的插件即可
3、Linux多节点部署KubeSphere(推荐)
官网：https://kubesphere.com.cn/docs/v3.3/installing-on-linux/introduction/multioverview/
# 最小安装最低要求2c4g(如果性能好，推荐master4c8g/node8c16g)
# 使用KubeKey创建集群
export KKZONE=cn
curl -sfL https://get-kk.kubesphere.io | VERSION=v2.3.0 sh -
chmod +x kk
# 创建集群配置文件
# ./kk create config [--with-kubernetes version] [--with-kubesphere version] [(-f | --file) path]
./kk create config --with-kubernetes v1.21.4 --with-kubesphere v3.3.1
# 然后这里会生成配置文件，修改配置文件，主要修改三台主机，例如下面，主要是修改ip以及指定master，node等
# ===================================================================
# address是公有地址，internalAddress是实例的私有 IP 地址，我这里虚拟机都填写私有地址了
spec:
hosts:
- {name: master, address: 192.168.249.146, internalAddress: 192.168.249.146, user: root, password: " "}
- {name: node1, address: 192.168.249.147, internalAddress: 192.168.249.147, user: root, password: " "}
- {name: node2, address: 192.168.249.148, internalAddress: 192.168.249.148, user: root, password: " "}
roleGroups:
etcd:
- master
control-plane:
- master
worker:
- node1
- node2
controlPlaneEndpoint:
## Internal loadbalancer for apiservers
# internalLoadbalancer: haproxy
# ========================================================================
# 使用配置文件创建集群，注意这里可能会有依赖缺失，根据提示yum install xxx安装即可
yum install -y conntrack socat conntrack socat conntrack socat
./kk create cluster -f config-sample.yaml
# 结束后可以通过
# 查看进度，这个版本好像命令行没有kubectl 了，kubectl在web可以查看
# kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l 'app in (ks-install, ks-installer)' -o jsonpath='{.items[0].metadata.name}') -f
二、KubeSphere实战
1、多租户实战
参考文档：https://kubesphere.com.cn/docs/v3.3/quick-start/create-workspace-and-project/
首先平台管理员admin创建不同用户，包括企业空间管理员bigboss-li和普通成员若干，然后进入企业空间管理员bigboss-li账户，创建不同的企业空间(例如杭州)，他可以管理所有企业空间，每一个企业空间里邀请指定一个人为该空间管理员，例如hangzhou-boss，然后该角色可以邀请其他人为普通人员；
然后hangzhou-boss邀请pm-wang为项目总监负责人，wang可以创建多个项目，可以邀请该企业空间的人到不同的项目，并分配不同的角色，例如这个项目的管理员，而项目管理员又可以邀请这个企业空间的人到此项目中，并分配不同的权限，例如开发者/观察者等
2、中间件部署实战
官网快速入门例子：https://kubesphere.com.cn/docs/v3.3/quick-start/wordpress-deployment/
dockerhub：https://hub.docker.com/
2.1 MySql部署
# 正常docker部署
docker run -p 3306:3306 --name mysql-01 \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=root \
--restart=always \
-d mysql:5.7
# 首先进入dev-lu的账号，这里管理员已经创建好了项目mail
# mysql配置示例
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]
init_connect='SET collation_connection = utf8mb4_unicode_ci'
init_connect='SET NAMES utf8mb4'
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
lower_case_table_names=1
kubesphere首先进去项目(例如我这里项目是mail)，然后创建配置(在配置→配置字典里，名字随便取，里面设置key为xx.cnf，值为上面的配置内容)；然后创建存储(持久卷声明，这里暂时是local类型进行测试)；最后创建有状态副本集，选择镜像，选择容器(使用容器默认配置，然后注意勾选环境变量和时间同步，把MYSQL_ROOT_PASSWORD=root写入，也可以限制一下资源)，最后挂载卷和配置文件，成功创建(如果创建失败需要更改一下docker源)
注意集群内部可以直接通过应用的 【服务名.项目名】 直接访问 (默认)，可以尝试ping
如果要修改内部访问域名，可以在服务里删除默认的，自行创建内部集群和外部访问两个service（注意是选择指定工作负载），也可以直接从服务里进行部署
2.2 redis部署
# ================这是之前的部署方式=============================
#创建配置文件
## 1、准备redis配置文件内容
mkdir -p /mydata/redis/conf && vim /mydata/redis/conf/redis.conf
##配置示例
appendonly yes
port 6379
bind 0.0.0.0
#docker启动redis
docker run -d -p 6379:6379 --restart=always \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-v /mydata/redis-01/data:/data \
--name redis-01 redis:6.2.5 \
redis-server /etc/redis/redis.conf
kubesphere方式部署和mysql类似，不过注意有状态副本集建议在内部直接创建存储，这样每增加一个副本就会新增一个pvc，否则会共用一个
2.3 部署ElasticSearch
# 创建数据目录
mkdir -p /mydata/es-01 && chmod 777 -R /mydata/es-01
# 容器启动
docker run --restart=always -d -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms512m -Xmx512m" \
-v es-config:/usr/share/elasticsearch/config \
-v /mydata/es-01/data:/usr/share/elasticsearch/data \
--name es-01 \
elasticsearch:7.13.4
因为考虑到/usr/share/elasticsearch/config文件夹下有很多默认配置文件，所以不能直接使用配置文件挂载，否则会直接被覆盖，注意这里创建副本时要选择子路径，选择到具体文件覆盖
2.4 应用商店部署
参考：https://kubesphere.com.cn/docs/v3.3/pluggable-components/app-store/
2.5 应用仓库部署(推荐)
官网参考：https://helm.sh/zh/
包搜索中心：https://artifacthub.io/
应用商店应用少，更多建议直接使用helm应用仓库进行安装部署，类似于dockerhub。首先去企业空间→应用管理→应用仓库添加bitnami仓库(需要对应权限角色，仓库地址https://charts.bitnami.com/bitnami)，同步完成后进入项目→应用负载→应用→从项目模板导入，选择导入的bitnami仓库即可选择对应的镜像了
3、RuoYi-Cloud部署实战
官网：https://gitee.com/y_project/RuoYi-Cloud
架构图：https://gitee.com/zhangmrit/ruoyi-cloud/blob/nacos/doc/ruoyi-cloud.png
3.1 本地部署
首先需要在本地进行跑起来，才能成功上云，首先clone若依项目，然后在本地创建数据库，根据项目数据库文件，注意这里需要自行创建ry-cloud数据库，然后再将quartz和ry表导入，其他两个会自行创建数据库，然后下载Nacos配置中心，进入conf/application.properties，可以直接在文件末尾直接添加
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/ry-config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=root
然后进入bin目录startup.cmd -m standalone启动，进入后在配置列表修改所有数据库的账号密码(根据自己账号密码来修改)，最后启动redis即可，然后启动前后端
3.2 k8s中间件部署
首先创建一个新项目his，然后点击应用负载→服务→创建有状态服务(这样就可以直接自定义DNS域名了)，根据上面情况部署mysql和redis，然后将数据库文件导入(注意这里需要自行创建ry-cloud数据库，然后再将quartz和ry表导入，其他两个会自行创建数据库)；
其次部署nacos集群，这里有个问题，nacos集群要设置每个naocs的IP地址，这里就需要进行有状态部署，这样就可以使用固定域名进行配置。然后我们需要获取一下固定域名，首先创建多个nacos有状态副本，然后进入nacos服务，获取总的nacos域名，打开随机一个nacos容器进行ping his-nacos.his，这样就可以获取每个nacos的域名规律，比如我的his-nacos-v1-0.his-nacos.his.svc.cluster.local(pod名+服务名+固定)就代表是nacos1
然后正式创建nacos集群，首先需要抽取两个配置文件application.properties(上面粘贴，但是数据库ip换成mysql服务器域名，比如我的his-mysql.his)和cluster.conf(然后选择服务→有状态部署，取名his-nacos，版本v1)
his-nacos-v1-0.his-nacos.his.svc.cluster.local:8848
his-nacos-v1-1.his-nacos.his.svc.cluster.local:8848
his-nacos-v1-2.his-nacos.his.svc.cluster.local:8848
然后重新创建nacos，挂载映射路径为/home/nacos/conf/xxx(需要挂载到子路径，否则其他就被覆盖了)，启动三个nacos，然后查看日志，成功暴露一下外部service，最后登录尝试http://192.168.249.146:32735/nacos/，然后修改里面mysql和redis的连接ip，换成DNS域名，同时账号密码设置一下。这里集群模式的话需要版本v2.1.0，也可以直接单节点模式启动(单节点增加环境变量MODE=standalone，如果集群的话需要增加环境变量PREFER_HOST_MODE=hostname，具体可以参考nacos dockerhub)
3.3 微服务层部署
下面的Dockerfile文件需要放置在每一个项目根目录，方便打包，官方可以参考：https://gitee.com/y_project/RuoYi-Cloud/tree/v3.6.1/docker
# 规则：
# 容器默认以8080端口启动
# 时间为CST
# 环境变量 PARAMS 可以动态指定配置文件中任意的值
# nacos集群内地址为 his-nacos.his:8848
# 微服务默认启动加载 nacos中 服务名-激活的环境.yml 文件，所以线上的配置可以全部写在nacos中
FROM openjdk:8-jdk
LABEL maintainer=shawn
# 注意这里要登陆nacos创建prod命名空间。然后将dev的配置文件克隆到prod，同时改dev后缀为prod
#docker run -e PARAMS="--server.port 9090"
ENV PARAMS="--server.port=8080 --spring.profiles.active=prod --spring.cloud.nacos.discovery.server-addr=his-nacos.his:8848 --spring.cloud.nacos.config.server-addr=his-nacos.his:8848 --spring.cloud.nacos.config.namespace=prod --spring.cloud.nacos.config.file-extension=yml"
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
COPY target/*.jar /app.jar
EXPOSE 8080
#
ENTRYPOINT ["/bin/sh","-c","java -Dfile.encoding=utf8 -Djava.security.egd=file:/dev/./urandom -jar app.jar ${PARAMS}"]
打包好docker镜像后可以推送到仓库，也可以搭建自己私有仓库Harbor
docker login --username=forsum**** registry.cn-hangzhou.aliyuncs.com
#把本地镜像，改名，成符合阿里云名字规范的镜像。
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/镜像名:[镜像版本号]
## docker tag 461955fe1e57 registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-visual-monitor:v1
docker push registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/镜像名:[镜像版本号]
## docker push registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-visual-monitor:v1
# ruoyi所有镜像
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-auth:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-file:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-gateway:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-job:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-system:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-visual-monitor:v2
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_ruoyi/ruoyi-ui:v2
然后开始正式部署微服务层，
- 应用一启动会获取到 “应用名-激活的环境标识.yml”
- 每次部署应用的时候，需要提前修改nacos线上配置，确认好每个中间件的连接地址是否正确
4、云原生DevOps实战
4.1 环境和中间件准备
项目地址：
https://gitee.com/leifengyang/yygh-parent
https://gitee.com/leifengyang/yygh-admin
https://gitee.com/leifengyang/yygh-site
首先在kubesphere打开devops开关，在原来his的项目中添加其他中间件，sentienl可以选择leifengyang/sentinel:1.8.2，mongodb/RabbitMQ可以从模板创建，ElasticSearch创建与之前方法类似吗
| 中间件 | 集群内地址 | 外部访问地址 |
|---|---|---|
| Nacos | his-nacos.his:8848 | http://192.168.249.146:30397/nacos |
| MySQL | his-mysql.his:3306 | 192.168.249.146:31840 |
| Redis | his-redis.his:6379 | 192.168.249.146:31968 |
| Sentinel | his-sentinel.his:8080 | http://192.168.249.146:31229 |
| MongoDB | mongodb.his:27017 | 192.168.249.146:30640 |
| RabbitMQ | rabbitm-rabbitmq.his:5672 | 192.168.249.146:31018 |
| ElasticSearch | his-es.his:9200 | 192.168.249.146:31300 |
然后抽取项目配置，把生产环境分开，项目默认规则
- 每个微服务项目，在生产环境时，会自动获取 微服务名-prod.yml 作为自己的核心配置文件
- 每个微服务项目，在生产环境时，默认都是使用 8080 端口
4.2 Jenkins构建
Jenkins官网
构建和部署 Maven 项目参考：https://kubesphere.io/zh/docs/v3.3/devops-user-guide/examples/a-maven-project/
首先在企业空间创建DevOps项目(如果一直处于等待状态，可以尝试重启一下docker或者换个密码)，点击进入后创建流水线，编辑流水线，可以先选择一个CI/CD模板，这样就可以看见可视化界面了，然后编辑可视化流水线，最后可以导出Jenkinsfile。这里kubesphere有内置容器和代理，可以参考Jenkins代理文档，然后一步步进行编辑即可。
第一步拉取代码，配置好地址和凭证，可以打印一下输出
第二步项目编译，maven项目打包，mvn clean package -Dmaven.test.skip=true(如果有弹框要输入，先随便输入)，这里我们可以配置maven加速(已经下载过的jar包，下一次流水线的启动，不会重复下载)
- 使用admin登陆ks
- 进入集群管理
- 进入配置中心
- 找到配置ks-devops-agent
- 修改这个配置，加入maven阿里云镜像加速地址
第三步打包Docker镜像，将每个jar包打包成镜像
第四步推送最新镜像到镜像仓库，注意改成自己镜像仓库，这里jenkinsfile可以设置环境变量，然后再推送那里进行变量替换
第五步进行镜像部署，注意这一步要创建好kubectl集群凭证和阿里云凭证，然后在每一个项目放置好deploy.yml文件，变量都需要在jenkinsfile里定义好(发布到生产环境可以卡点)
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: hospital-manage
name: hospital-manage
namespace: his #一定要写名称空间
spec:
progressDeadlineSeconds: 600
replicas: 1
selector:
matchLabels:
app: hospital-manage
strategy:
rollingUpdate:
maxSurge: 50%
maxUnavailable: 50%
type: RollingUpdate
template:
metadata:
labels:
app: hospital-manage
spec:
imagePullSecrets:
- name: aliyun-docker-hub #提前在项目下配置访问阿里云的账号密码
containers:
- image: $REGISTRY/$ALIYUNHUB_NAMESPACE/hospital-manage:SNAPSHOT-$BUILD_NUMBER
# readinessProbe:
# httpGet:
# path: /actuator/health
# port: 8080
# timeoutSeconds: 10
# failureThreshold: 30
# periodSeconds: 5
imagePullPolicy: Always
name: app
ports:
- containerPort: 8080
protocol: TCP
resources:
limits:
cpu: 300m
memory: 600Mi
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
dnsPolicy: ClusterFirst
restartPolicy: Always
terminationGracePeriodSeconds: 30
---
apiVersion: v1
kind: Service
metadata:
labels:
app: hospital-manage
name: hospital-manage
namespace: his
spec:
ports:
- name: http
port: 8080
protocol: TCP
targetPort: 8080
selector:
app: hospital-manage
sessionAffinity: None
type: ClusterIP
jenkinsfile举例，其中几步可以并发构建，自行填写相应信息
pipeline {
agent {
node {
label 'maven'
}
}
stages {
stage('拉取代码') {
agent none
steps {
container('maven') {
git(url: 'https://gitee.com/LXT2017/yygh-parent', credentialsId: 'gitee', branch: 'master', changelog: true, poll: false)
sh 'ls -la'
}
}
}
stage('项目编译') {
agent none
steps {
container('maven') {
sh 'ls'
sh 'mvn clean package -Dmaven.test.skip=true'
}
sh 'ls server-gateway/target'
}
}
stage('default-2') {
parallel {
stage('构建hospital-manage镜像') {
steps {
container('maven') {
sh 'ls hospital-manage/target'
sh 'docker build -t hospital-manage:latest -f hospital-manage/Dockerfile ./hospital-manage/'
}
}
}
}
}
stage('default-3') {
parallel {
stage('推送hospital-manage镜像') {
agent none
steps {
container('maven') {
withCredentials([usernamePassword(credentialsId : 'aliyun-docker' ,passwordVariable : 'DOCKER_PWD_VAR' ,usernameVariable : 'DOCKER_USER_VAR' ,)]) {
sh 'echo "$DOCKER_PWD_VAR" | docker login $REGISTRY -u "$DOCKER_USER_VAR" --password-stdin'
sh 'docker tag hospital-manage:latest $REGISTRY/$DOCKERHUB_NAMESPACE/hospital-manage:SNAPSHOT-$BUILD_NUMBER'
sh 'docker push $REGISTRY/$DOCKERHUB_NAMESPACE/hospital-manage:SNAPSHOT-$BUILD_NUMBER'
}
}
}
}
}
}
stage('default-4') {
parallel{
stage('hospital-manage - 部署到dev环境'){
steps {
container ('maven') {
withCredentials([
kubeconfigFile(
credentialsId: env.KUBECONFIG_CREDENTIAL_ID,
variable: 'KUBECONFIG')
]) {
sh 'envsubst < hospital-manage/deploy/deploy.yml | kubectl apply -f -'
}
}
}
}
}
}
}
environment {
DOCKER_CREDENTIAL_ID = 'dockerhub-id'
GITHUB_CREDENTIAL_ID = 'github-id'
KUBECONFIG_CREDENTIAL_ID = 'demo-kubeconfig'
REGISTRY = 'registry.cn-hangzhou.aliyuncs.com'
DOCKERHUB_NAMESPACE = 'llxxtt'
GITHUB_ACCOUNT = 'kubesphere'
APP_NAME = 'devops-java-sample'
ALIYUNHUB_NAMESPACE = 'llxxtt'
}
parameters {
string(name: 'TAG_NAME', defaultValue: '', description: '')
}
}
最后一步可以添加邮件功能，kubesphere全局设置在平台设置里配置不同服务(会发生报警监控等)，而流水线的邮件服务可以参考：为 KubeSphere 流水线设置电子邮件服务器
其他模块同理
4.3 webhook
- 每个项目，都有流水线文件(比如创建好连接远程仓库的流水线项目)
- 点击流水线，里面谁有webhook地址，可以挂载在远程仓库的webhook
- 写代码并提交------> gitee ---------> 给指定的地方发请求（webhook）------> kubesphere平台感知到 -----> 自动启动流水线继续运行
参考
https://www.bilibili.com/video/BV13Q4y1C7hS
https://www.yuque.com/leifengyang/oncloud/