当前位置: article > 正文

KubeSphere实战

作者：寸_铁 | 2024-07-26 19:32:41

踩

kubesphere实战

一、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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

然后安装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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

初始化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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

配置默认存储，在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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

确认配置是否生效，kubectl get sc，这样配置完成之后就拥有动态创建pv的能力，例如如下可以自行测试

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 3Gi

1
2
3
4
5
6
7
8
9
10
11

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

测试

kubectl top nodes
kubectl top pod -A

1
2
3

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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) 通过 <NodeIP>:30880 访问控制台
# kubectl get pod --all-namespaces 查看相关组件情况
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

仅适用于默认的最小化安装。若要在 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

# 结束后可以通过 <NodeIP:30880 使用默认帐户和密码 (admin/P@88w0rd) 访问 KubeSphere 的 Web 控制台

# 查看进度，这个版本好像命令行没有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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

二、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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这里插入图片描述

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
1
2
3
4
5
6
7
8
9
10
11

在这里插入图片描述

因为考虑到/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
1
2
3
4
5

然后进入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

1
2
3
4

然后重新创建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}"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

打包好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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

然后开始正式部署微服务层，

应用一启动会获取到 “应用名-激活的环境标识.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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

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: '')
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

最后一步可以添加邮件功能，kubesphere全局设置在平台设置里配置不同服务(会发生报警监控等)，而流水线的邮件服务可以参考：为 KubeSphere 流水线设置电子邮件服务器

其他模块同理

4.3 webhook

每个项目，都有流水线文件(比如创建好连接远程仓库的流水线项目)
点击流水线，里面谁有webhook地址，可以挂载在远程仓库的webhook
写代码并提交------> gitee ---------> 给指定的地方发请求（webhook）------> kubesphere平台感知到 -----> 自动启动流水线继续运行

参考

https://www.bilibili.com/video/BV13Q4y1C7hS

https://www.yuque.com/leifengyang/oncloud/

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】

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