Navi 2025-05-29T02:30:25.000Z https://imszz.com/ Navi Hexo K8s强制删除命名空间（namespace） https://imszz.com/p/3ee01430/ 2024-05-29T02:00:25.000Z 2025-05-29T02:30:25.000Z 查看命名空间列表：

命名空间 keda 一直处于Terminating 状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
kubectl get ns

NAME               STATUS        AGE
default            Active        87d
dev                Active        21d
ingress-nginx      Active        126m
keda               Terminating   126m
kube-flannel       Active        87d
kube-node-lease    Active        87d
kube-public        Active        87d
kube-system        Active        87d
openfaas           Active        87d
openfaas-fn        Active        87d
openfunction       Active        28h
tekton-pipelines   Active        126m

解决办法

将无法删除命名空间的json格式配置文件导出：

1
kubectl get ns keda -o json > keda.json

编辑json配置文件的"spec"配置，将"finalizers"清空：

1
2
3
4
"spec": {
    "finalizers": [
    ]
},

根据修改后的json配置replace掉原来的ns配置：

1
kubectl replace --raw "/api/v1/namespaces/keda/finalize" -f ./keda.json

再度查看：

已成功删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
kubectl get ns

NAME               STATUS   AGE
default            Active   87d
dev                Active   21d
ingress-nginx      Active   144m
kube-flannel       Active   87d
kube-node-lease    Active   87d
kube-public        Active   87d
kube-system        Active   87d
openfaas           Active   87d
openfaas-fn        Active   87d
openfunction       Active   28h
tekton-pipelines   Active   144m

]]> <h4 id="查看命名空间列表："><a href="#查看命名空间列表：" class="headerlink" title="查看命名空间列表："></a>查看命名空间列表：</h4><p>命名空间 <code>keda</code> 一直处于<code>Terminati kubernetes部署skywalking集群包括Java服务接入 https://imszz.com/p/f1160bc8/ 2024-05-29T02:00:00.000Z 2024-05-29T08:00:00.000Z 1 概述：
1.1 环境

版本信息如下：
`
a、操作系统：centos 7.9

a、skywalking版本：v9.0.1

c、kubernetes版本：v1.22.0

d、es版本：6.8.6

e、helm版本： helm3.8

`

1.2 skywalking概述

1.2.1 skywalking是什么
SkyWalking是一个开源的APM系统，为云原生分布式系统提供监控、链路追踪、诊断能力，支持集成多种编程语言的应用（java、php、go、lua等），也能和服务网格进行集成。除了支持代码侵入方式的集成，一个主要亮点也支持零代码入侵的集成（零代码侵入是和具体的编程语言相关的），是利用java agent的特性在jvm级别修改了运行时的程序，因此程序员在代码编辑期间不需要修改业务代码也能达到埋点的效果。后端存储支持es、mysql、tidb等多种数据库。

架构图如下：
github--lena

1.2.1 skywalking的java代理的使用

1）方式1：命令行方式

1
2
3
4
5
java \
-javaagent:/root/skywalking/agent/skywalking-agent.jar \
-Dskywalking.agent.service_name=app1 \
-Dskywalking.collector.backend_service=localhost:11800 \
-jar myapp.jar

2）方式2：环境变量方式

1
2
3
4
5
6
7
export SW_AGENT_COLLECTOR_BACKEND_SERVICES=10.0.0.1:11800,10.0.0.2:11800
export SW_AGENT_NAME=demo1
export JAVA_OPTS=-javaagent:/root/skywalking/agent/skywalking-agent.jar

java \
$JAVA_OPTS \
-jar myapp.jar

2 部署前置条件：

具备一个k8s集群：
github--lena

3 部署：

3.1 部署es集群
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
cat > elasticsearch-deployment.yaml < EOF
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: elasticsearch
  namespace: elastic
spec:
  replicas: 3
  selector:
    matchLabels:
      app: elasticsearch
  serviceName: elasticsearch
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: elasticsearch
    spec:
      containers:
      - env:
        - name: cluster.name
          value: k8s-logs
        - name: node.name
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.name
        - name: discovery.zen.ping.unicast.hosts
          value: elasticsearch-0.elasticsearch,elasticsearch-1.elasticsearch,elasticsearch-2.elasticsearch
        - name: discovery.zen.minimum_master_nodes
          value: "2"
        - name: ES_JAVA_OPTS
          value: -Xms512m -Xmx512m
        image: docker.elastic.co/elasticsearch/elasticsearch:6.8.6
        imagePullPolicy: Always
        name: elasticsearch
        ports:
        - containerPort: 9200
          name: rest
          protocol: TCP
        - containerPort: 9300
          name: inter-node
          protocol: TCP
        resources:
          limits:
            cpu: "1"
          requests:
            cpu: 100m
        volumeMounts:
        - mountPath: /usr/share/elasticsearch/data
          name: elasticsearch-data-pvc
      initContainers:
      - command:
        - sh
        - -c
        - chown -R 1000:1000 /usr/share/elasticsearch/data
        image: busybox
        imagePullPolicy: Always
        name: fix-permissions
        securityContext:
          privileged: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /usr/share/elasticsearch/data
          name:  elasticsearch-data-pvc
      - command:
        - sysctl
        - -w
        - vm.max_map_count=262144
        image: busybox
        imagePullPolicy: Always
        name: increase-vm-max-map
        resources: {}
        securityContext:
          privileged: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      - command:
        - sh
        - -c
        - ulimit -n 65536
        image: busybox
        imagePullPolicy: Always
        name: increase-fd-ulimit
        resources: {}
        securityContext:
          privileged: true
     #  volumes:
  volumeClaimTemplates:
    - metadata:
        name: elasticsearch-data-pvc # 这里不要修改，进阶用法参考 ECK 官方文档
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 100Gi # 配置默认大小，allowVolumeExpansion为true后续可以扩展
        storageClassName: elasticsearch-nfs-sc
      #- emptyDir: {}
      #  name: data
      #- name: data
      #  persistentVolumeClaim:
      #    claimName: elasticsearch-data-pvc

---
kind: Service
apiVersion: v1
metadata:
  name: elasticsearch
  namespace: elastic
  labels:
    app: elasticsearch
spec:
  selector:
    app: elasticsearch
  clusterIP: None
  ports:
    - port: 9200
      name: rest
    - port: 9300
      name: inter-node

---
kind: Service
apiVersion: v1
metadata:
  name: elasticsearch-logging
  namespace: elastic
  labels:
    app: elasticsearch
spec:
  selector:
    app: elasticsearch
  ports:
    - port: 9200
      name: external
      
EOF                                                                                                                        ```                    
```shell
cat > elasticsearch-data-sc.yaml < EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: elasticsearch-nfs-sc
provisioner: fuseim.pri/ifs
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
cat >  elasticsearch-pvc.yaml
 < EOF
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: elasticsearch-data-pvc
  namespace: elastic
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Gi
  storageClassName: elasticsearch-nfs-sc
status:
  accessModes:
    - ReadWriteMany
  capacity:
    storage: 100Gi

EOF

es 集群地址：主机IP+port
github--lena

3.2 部署skywalking集群

从github中下载skywalking的chart包仓库

1
2
3
cd /tmp
git clone https://github.com/apache/skywalking-kubernetes
cd /tmp/skywalking-kubernetes/chart

由于已存在es集群，因此不需要再通过helm去部署es。可把chart包依赖的es chart注释掉。

1
vim skywalking/Chart.yaml

github--lena
执行helm命令部署skywalking集群。在第一步，我已经在kube-system名字空间下部署了es集群，因此skywalking连接的es集群是：elasticsearch-logging.kube-system:9200。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
export SKYWALKING_RELEASE_NAME=skywalking
export SKYWALKING_RELEASE_NAMESPACE=skywalking
kubectl create ns $SKYWALKING_RELEASE_NAMESPACE

helm install "$SKYWALKING_RELEASE_NAME" ./skywalking \
  -n "$SKYWALKING_RELEASE_NAMESPACE" \
  --set oap.image.tag=9.1.0 \
  --set oap.storageType=elasticsearch \
  --set oap.service.type=NodePort \
  --set oap.javaOpts="-Xmx4g -Xms4g" \
  --set ui.image.tag=9.1.0 \
  --set ui.service.type=NodePort \
  --set elasticsearch.enabled=false \
  --set elasticsearch.config.host=elasticsearch-logging.elastic \
  --set elasticsearch.config.port.http=9200 \
  --set elasticsearch.config.user="" \
  --set elasticsearch.config.password=""

查看svc和pod，可见部署skywalking成功：
github--lena

3.3 制作skywalking agent的init容器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mkdir skywalking-java-agent && cd skywalking-java-agent
wget  https://dlcdn.apache.org/skywalking/java-agent/8.12.0/apache-skywalking-java-agent-8.12.0.tgz
tar -xvf apache-skywalking-java-agent-8.12.0.tgz


cat > Dockerfile < EOF
FROM busybox:latest
ENV LANG=C.UTF-8
RUN set -eux && mkdir -p /opt/skywalking/agent/
ADD skywalking-agent /opt/skywalking/agent/
WORKDIR /
EOF

执行docker build命令制作镜像，并推送至仓库。
docker build -t registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.0.1 .
docker push registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.0.1

4 部署springboot微服务

1）微服务来自网上，并做了一些修改。微服务几乎没有业务逻辑，只有http调用和睡眠指令。
2）我的业务服务部署在另外一个k8s集群中，因此skywalking agent访问的是位于另一个集群中的skywalking oap服务的NodePort。
3）每个yaml文件都可以直接使用，需要根据实际情况修改环境变量SW_AGENT_COLLECTOR_BACKEND_SERVICES。在我的例子中SW_AGENT_COLLECTOR_BACKEND_SERVICES=192.9.30.230:32297。

4.1 UI服务
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
cat > acme-financial-ui.yaml < EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: acme-financial-ui
  name: acme-financial-ui
spec:
  replicas: 1
  selector:
    matchLabels:
      app: acme-financial-ui
  template:
    metadata:
      labels:
        app: acme-financial-ui
    spec:
      initContainers:
      - image: registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.1.0
        name: skywalking-sidecar
        command: ["sh"]
        args: [
                "-c",
                "mkdir -p /opt/sw/agent && cp -rf /opt/skywalking/agent/* /opt/sw/agent/"
        ]
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      containers:
      - env:
        - name: JAVA_OPTS
          value: "-javaagent:/opt/sw/agent/skywalking-agent.jar"
        - name: SW_AGENT_NAME
          value: "acme-financial-ui"
        - name: SW_AGENT_COLLECTOR_BACKEND_SERVICES
          value: "192.9.30.230:32297"
        image: registry.cn-shenzhen.aliyuncs.com/gzlj/acme-financial-ui:v0.1
        imagePullPolicy: Always
        name: ui
        ports:
        - containerPort: 8081
          protocol: TCP
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      volumes:
      - name: sw-agent
        emptyDir: {}

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: acme-financial-ui
  name: acme-financial-ui
spec:
  ports:
  - name: http
    port: 8081
    protocol: TCP
    targetPort: 8081
  selector:
    app: acme-financial-ui
  sessionAffinity: None
  type: NodePort

EOF
4.2 office服务
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
cat > acme-financial-office.yaml < EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: acme-financial-office
  name: acme-financial-office
spec:
  replicas: 1
  selector:
    matchLabels:
      app: acme-financial-office
  template:
    metadata:
      labels:
        app: acme-financial-office
    spec:
      initContainers:
      - image: registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.1.0
        name: skywalking-sidecar
        command: ["sh"]
        args: [
                "-c",
                "mkdir -p /opt/sw/agent && cp -rf /opt/skywalking/agent/* /opt/sw/agent/"
        ]
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      containers:
      - env:
        - name: JAVA_OPTS
          value: "-javaagent:/opt/sw/agent/skywalking-agent.jar"
        - name: SW_AGENT_NAME
          value: "acme-financial-office"
        - name: SW_AGENT_COLLECTOR_BACKEND_SERVICES
          value: "192.9.30.230:32297"
        image: registry.cn-shenzhen.aliyuncs.com/gzlj/acme-financial-office:v0.1
        imagePullPolicy: Always
        name: office
        ports:
        - containerPort: 8082
          protocol: TCP
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      volumes:
      - name: sw-agent
        emptyDir: {}

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: acme-financial-office
  name: acme-financial-back-office
spec:
  ports:
  - name: http
    port: 8082
    protocol: TCP
    targetPort: 8082
  selector:
    app: acme-financial-office
  sessionAffinity: None
  type: ClusterIP 
EOF
4.3 account服务
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
cat > acme-financial-account.yaml < EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: acme-financial-account
  name: acme-financial-account
spec:
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: acme-financial-account
  template:
    metadata:
      labels:
        app: acme-financial-account
    spec:
      initContainers:
      - image: registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.1.0
        name: skywalking-sidecar
        command: ["sh"]
        args: [
                "-c",
                "mkdir -p /opt/sw/agent && cp -rf /opt/skywalking/agent/* /opt/sw/agent/"
        ]
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      containers:
      - env:
        - name: JAVA_OPTS
          value: "-javaagent:/opt/sw/agent/skywalking-agent.jar"
        - name: SW_AGENT_NAME
          value: "acme-financial-account"
        - name: SW_AGENT_COLLECTOR_BACKEND_SERVICES
          value: "192.9.30.230:32297"
        image: registry.cn-shenzhen.aliyuncs.com/gzlj/acme-financial-account:v0.1
        imagePullPolicy: Always
        name: account
        ports:
        - containerPort: 8083

          protocol: TCP
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      volumes:
      - name: sw-agent
        emptyDir: {}
---

apiVersion: v1
kind: Service
metadata:
  labels:
    app: acme-financial-account
  name: acme-financial-account
spec:
  ports:
  - name: http
    port: 8083
    protocol: TCP
    targetPort: 8083
  selector:
    app: acme-financial-account
  sessionAffinity: None
  type: ClusterIP

EOF
4.4 customer服务
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
cat > acme-financial-customer.yaml < EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: acme-financial-customer
  name: acme-financial-customer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: acme-financial-customer
  template:
    metadata:
      labels:
        app: acme-financial-customer
    spec:
      initContainers:
      - image: registry.cn-hangzhou.aliyuncs.com/k8s_beijing/skywalking-agent:9.1.0
        name: skywalking-sidecar
        command: ["sh"]
        args: [
                "-c",
                "mkdir -p /opt/sw/agent && cp -rf /opt/skywalking/agent/* /opt/sw/agent/"
        ]
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      containers:
      - env:
        - name: JAVA_OPTS
          value: "-javaagent:/opt/sw/agent/skywalking-agent.jar"
        - name: SW_AGENT_NAME
          value: "acme-financial-customer"
        - name: SW_AGENT_COLLECTOR_BACKEND_SERVICES
          value: "192.9.30.230:32297"
        image: registry.cn-shenzhen.aliyuncs.com/gzlj/acme-financial-customer:v0.1
        imagePullPolicy: Always
        name: customer
        ports:
        - containerPort: 8084
          protocol: TCP
        volumeMounts:
        - name: sw-agent
          mountPath: /opt/sw/agent
      volumes:
      - name: sw-agent
        emptyDir: {}

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: acme-financial-customer
  name: acme-financial-customer
  namespace: default
spec:
  ports:
  - name: http
    port: 8084
    protocol: TCP
    targetPort: 8084
  selector:
    app: acme-financial-customer
  sessionAffinity: None
  type: ClusterIP
EOF
4.5 ingress
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
cat > acme-ingress.yaml < EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: skywalking-ingress
  namespace: default
  annotations:
    prometheus.io/http_probe: "true"
spec:
  ingressClassName: nginx
  rules:
  - host: acme.k8s.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: acme-financial-ui
            port:
              number: 8081
EOF
4.6 业务微服务部署结果

部署业务服务成功，如图所示，UI服务的NodePort为32468。
github--lena

5 访问springboot业务微服务并查看skywalking

5.1 访问UI服务的三个接口

通过NodePort或者ingress域名 访问UI服务的三个接口：/hello、/start、/readtimeout。

]]> <h4 id="1-概述："><a href="#1-概述：" class="headerlink" title="1 概述："></a>1 概述：</h4><h5 id="1-1-环境"><a href="#1-1-环境" class="headerlink" title="1 XFS文件系统挂载报错 https://imszz.com/p/b1f8a123/ 2024-02-20T08:00:00.000Z 2024-02-20T08:00:00.000Z Linux 系统中 xfs 分区挂载错误：

错误提示：

mount: /mnt: wrong fs type, bad option, bad superblock on /dev/vdc1, missing codepage or helper program, or other error.

主要场景：

该错误通常在挂载 xfs 类型分区时发生，尤其是在要挂载的磁盘与已挂载磁盘（例如系统盘或数据盘）的磁盘 ID（UUID）冲突时。

解决办法：

1. 检查 UUID 冲突

使用以下命令查询系统日志以检查 UUID 冲突：

1
dmesg | tail

如果出现以下提示，则表明存在 UUID 冲突：

1
XFS (vdc1): Filesystem has duplicate UUID 60d67439-baf0-4c8b-94a3-3f10a362e8fe - can't mount

2. 使用 nouuid 选项进行临时挂载

如果存在 UUID 冲突，可以使用 nouuid 选项进行临时挂载：

1
mount -o nouuid /dev/vdc1 /abc

其中，/dev/vdc1 是要挂载的磁盘分区，/abc 是挂载点。

此操作将成功挂载磁盘分区，但重启后挂载会失效。

3. 永久挂载

要永久挂载，需要使用 xfs_admin 命令为新分区分配一个新的 UUID：

1
sudo xfs_admin -U generate /dev/vdc1

其中，/dev/vdc1 是要更改其 UUID 的磁盘分区。

]]> <p><strong>Linux 系统中 xfs 分区挂载错误：</strong></p> <p><strong>错误提示：</strong></p> <p><code>mount: /mnt: wrong fs type, bad option, bad superblock ceph运维操作 https://imszz.com/p/3e15b5bb/ 2022-01-03T12:46:25.000Z 2022-01-03T16:46:25.000Z 一 统一节点上ceph.conf文件

如果是在admin节点修改的ceph.conf，想推送到所有其他节点，则需要执行下述命令

1
ceph-deploy --overwrite-conf config push mon01 mon02 mon03 osd01 osd02 osd03

修改完毕配置文件后需要重启服务生效，请看下一小节

二 ceph集群服务管理

!!!下述操作均需要在具体运行服务的那个节点上运行，而不是admin节点!!!

2.1 方式一

在各具体节点执行下行命令，重启节点上的所有ceph守护进程

1
systemctl restart ceph.target

2.2 方式二

在各具体节点执行下行命令，按类型重启相应的守护进程

1、重启 mgr 守护进程
1
2
systemctl restart ceph-mgr.target

2、重启 mds 守护进程
1
systemctl restart ceph-mds.target
3、重启 rgw 守护进程
1
systemctl restart ceph-radosgw.target
4、重启 mon 守护进程
1
systemctl restart ceph-mon.target
5、重启 osd 守护进程

登录到osd01节点上，该节点上运行有三个osd daemon进程osd.0、osd.l、osd.2

5.1 重启所有的osd daemoon
1
systemctl restart ceph-osd.target
5.2 挨个重启
1
2
3
systemctl restart ceph-osd@0
systemctl restart ceph-osd@1
systemctl restart ceph-osd@2

了解：也可以根据进程类型+主机名.service

1 mon 守护进程
1
2
3
systemctl { start | stop | restart} ceph-mon@{mon_instance}.service
例
systemctl restart ceph-mon@mon01.service
2 mgr 守护进程
1
systemctl { start | stop | restart} ceph-mgr@{mgr_instance}.service
3 osd 守护进程
1
systemctl { start | stop | restart} ceph-osd@{osd_instance}.service
4 rgw 守护进程
1
systemctl { start | stop | restart} ceph-radosgw@{rgw_instance}.service
5 mds 守护进程
1
systemctl { start | stop | restart} ceph-mds@{mds_instance}.service

三 服务平滑重启

有时候需要更改服务的配置，但不想重启服务，或者是临时修改，此时我们就可以通过admin sockets直接与守护进程交互。如查看和修改守护进程的配置参数。
守护进程的socket文件一般是/var/run/ceph/$cluster-$type.$id.asok
基于admin sockets的操作：

  • 方式一：tell子命令
  • 方式二：daemon子命令
    ceph daemon $type.$id command
  • 方式三：通过socket文件
1
ceph --admin-daemon /var/run/ceph/$cluster-$type.$id.asok command

常用command如下

1
2
3
4
5
6
7
8
9
help

config get parameter

config set parameter

config show

perf dump

3.1 tell子命令

命令使用格式如下，在管理节点执行即可

1
ceph tell {daemon-type}.{daemon id or *} injectargs --{name}={value} [--{name}={value}]
  • daemon-type：为要操作的对象类型如osd、mon等。
  • daemon id：该对象的名称，osd通常为0、1等，mon为ceph -s显示的名称，这里可以输入*表示全部。
  • injectargs：表示参数注入，后面必须跟一个参数，也可以跟多个。

例如

1
2
3
# 在管理节点运行
ceph tell mon.mon01 injectargs --mon_allow_pool_delete=true
ceph tell mon.* injectargs --mon_allow_pool_delete=true

mon_allow_pool_delete此选项的值默认为false，表示不允许删除pool，只有此选项打开后方可删除，记得改回去！！！ 这里使用mon.ceph-monitor-1表示只对ceph-monitor-1设置，可以使用*

3.2 daemon子命令

命令格式如下，需要登录到守护进程所在的那台主机上执行

1
ceph daemon {daemon-type}.{id} config set {name}={value}

例。

1
2
ssh root@mon01
ceph daemon mon.mon01 config set mon_allow_pool_delete false

3.3 socket文件

1
2
3
4
5
6
7
8
9
# 1、查看帮助

ceph --admin-daemon /var/run/ceph/ceph-mds.mon01.asok help

# 2、查看配置项
ceph --admin-daemon /var/run/ceph/ceph-mds.mon01.asok config get mon_allow_pool_delete

# 3、设置
ceph --admin-daemon /var/run/ceph/ceph-mds.mon01.asok config set mon_allow_pool_delete true

如果超过半数的monitor节点挂掉，此时通过网络访问ceph的所有操作都会被阻塞，但monitor的本地socket还是可以通信的。

1
ceph --admin-daemon /var/run/ceph/ceph-mon.mon03.asok quorum_status

四 维护集群常用命令

4.1 查看集群健康状况

1
2
3
4
5
6
7
8
9
# 检查ceph的状态
ceph -s
ceph status
ceph health
ceph health detail


# 实时观察集群健康状态
ceph -w

4.2 检查集群的使用情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
=======================命令1=======================
ceph df  # 它和 Linux 上的 df 相似

# GLOBAL段
展示了数据所占用集群存储空间的概要,详解如下
SIZE: 集群的总容量;
AVAIL: 集群的空闲空间总量;
RAW USED: 已用存储空间总量;
% RAW USED: 已用存储空间比率。用此值参照 full ratio 和 near full \ ratio 来确保不会用尽集群空间。 详情见存储容量。

# POOLS 段:
展示了存储池列表及各存储池的大致使用率。没有副本、克隆品和快照占用情况。例如，如果你 把 1MB 的数据存储为对象，理论使用率将是 1MB ，但考虑到副本数、克隆数、和快照数，实际使用率可能是 2MB 或更多。
NAME: 存储池名字;
ID: 存储池唯一标识符;
USED: 大概数据量，单位为 B、KB、MB 或 GB ;
%USED: 各存储池的大概使用率;
Objects: 各存储池内的大概对象数。

=======================命令2=======================
ceph osd df  # 可以详细列出集群每块磁盘的使用情况，包括大小、权重、使用多少空间、使用率等等

4.3 mds相关

1、查看mds状态

1
2
ceph mds stat
ceph mds dump

2、删除mds节点

1
2
3
4
ssh root@mon01 systemctl stop ceph-mds.target
ceph mds rm 0  # 删除一个不活跃的mds

# 启动mds后，则恢复正常

3、关闭mds集群

1
ceph mds cluster_down

4、开启mds集群

1
2
ceph mds cluster_up

5、设置cephfs 文件系统存储方式最大单个文件尺寸

1
2
ceph mds set max_file_size 1024000000000

6、了解：清除mds文件系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1、强制 mds 状态为 featrue
ceph mds fail 0

# 2、删除 mds 文件系统
ceph fs rm cephfs --yes-i-really-mean-it

# 3、删除数据池
ceph osd pool delete cephfs_data cephfs_data --yes-i-really-really-mean-it

# 4、删除元数据池
ceph osd pool delete cephfs_metadata cephfs_metadata --yes-i-really-really-mean-it 

# 5、然后再删除 mds key,残留文件等

# 6、最后删除不活跃的mds
ceph mds rm 0

4.4 mon相关

1、查看mon状态

1
2
ceph mon stat

2、查看mon映射信息

1
ceph mon dump

3、检查Ceph monitor仲裁/选举状态

1
ceph quorum_status --format json-pretty

4、查看mon信息包括ip地址

1
2
3
获得一个正在运行的 mon map，并保存在 1.txt 文件中 
ceph mon getmap -o 1.txt
monmaptool --print 1.txt

4.5 auth相关

一：认证与授权

Ceph使用cephx协议对客户端进行身份验证，集群中每一个Monitor节点都可以对客户端进行身份验证，所以不存在单点故障。cephx仅用于Ceph集群中的各组件，而不能用于非Ceph组件。它并不解决数据传输加密问题，但也可以提高访问控制安全性问题。

二：认证授权流程如下

  • 1、客户端向Monitor请求创建用户。

  • 2、Monitor返回用户共享密钥给客户端，并将此用户信息共享给MDS和OSD。

  • 3、客户端使用此共享密钥向Monitor进行认证。

  • 4、Monitor返回一个session key给客户端，并且此session key与对应客户端密钥进行加密。此session key过一段时间后就会失效，需要重新请求。

  • 5、客户端对此session key进行解密，如果密钥不匹配无法解密，这时候认证失败。

  • 6、如果认证成功，客户端向服务器申请访问的令牌。

  • 7、服务端返回令牌给客户端。

  • 8、这时候客户端就可以拿着令牌访问到MDS和OSD，并进行数据的交互。因为MDS和Monitor之间有共享此用户的信息，所以当客户端拿到令牌后就可以直接访问。

    三：相关概念
    1、用户

  • 用户通常指定个人或某个应用

  • 个人就是指定实际的人，比如管理员

  • 而应用就是指客户端或Ceph集群中的某个组件，通过用户可以控制谁可以如何访问Ceph集群中的哪块数据。

  • Ceph支持多种类型的用户，个人与某应用都属于client类型。还有mds、osd、mgr一些专用类型。

    2、用户标识

  • 用户标识由“TYPE.ID”组成，通常ID也代表用户名，如client.admin、osd.1等。

3、使能caps
  • 使能表示用户可以行使的能力，通俗点也可以理解为用户所拥有的权限。 对于不同的对象所能使用的权限也不一样，大致如下所示。
  • Monitor权限有：r、w、x和allow、profile、cap。
  • OSD权限有：r、w、x、class-read、class-wirte和profile osd。
  • 另外OSD还可以指定单个存储池或者名称空间，如果不指定存储池，默认为整个存储池。
  • MDS权限有：allow或者留空。

关于各权限的意义：

  • allow：对mds表示rw的意思，其它的表示“允许”。
  • r：读取。
  • w：写入。
  • x：同时拥有读取和写入，相当于可以调用类方法，并且可以在monitor上面执行auth操作。
  • class-read：可以读取类方法，x的子集。
  • class-wirte：可以调用类方法，x的子集。
  • *：这个比较特殊，代表指定对象的所有权限。
  • profile：类似于Linux下sudo，比如profile osd表示授予用户以某个osd身份连接到其它OSD或者Monitor的权限。
  • profile bootstrap-osd表示授予用户引导OSD的权限，关于此处可查阅更多资料。
四 命令

1、查看 ceph 集群中的认证用户及相关的 key

1
ceph auth list  # 简写：ceph auth ls

2、查看某一用户详细信息

1
ceph auth get client.admin

3、只查看用户的key信息

1
ceph auth print-key client.admin

4、创建用户，用户标识为client.test。指定该用户对mon有r的权限，对osd有rw的权限，osd没有指定存储池，所以是对所有存储池都有rw的权限。在创建用户的时候还会自动创建用户的密钥。

1
2
ceph auth add client.test mon "allow r" osd "allow rw"

5、修改用户权限

1
ceph auth caps client.test mon "allow r" osd "allow rw pool=kvm"

6、删除用户，用户名为osd.0

1
ceph auth del osd.0

7、keyring秘钥环文件
keyring文件是一个包含密码，key，证书等内容的一个集合。一个keyring文件可以包含多个用户的信息，也就是可以将多个用户信息存储到一个keyring文件。

keyring自动加载顺序

当访问Ceph集群时候默认会从以下四个地方加载keyring文件。

  • /etc/ceph/cluster-name.user-name.keyring：通过这种类型的文件用来保存单个用户信息，文件名格式固定：集群名.用户标识.keyring。如ceph.client.admin.keyring。这个代表ceph这个集群，这里的ceph是集群名，而client.admin为admin用户的标识。
  • /etc/ceph/cluster.keyring：通用来保存多个用户的keyring信息。
  • /etc/ceph/keyring：也用来保存多个用户的keyring信息。
  • /etc/ceph/keyring.bin：二进制keyring文件，也用来保存多个用户的keyring信息。

8、创建一个名为client.admin 的用户，设置好用户对mds、osd、mon的权限，然后把密钥导出到文件中

1
2
3
4
ceph auth get-or-create client.admin mds 'allow *' osd 'allow *' mon 'allow *' > /etc/ceph/ceph.client.admin.keyring1

# 或者
ceph auth get-or-create client.admin mds 'allow *' osd 'allow *' mon 'allow *' -o /etc/ceph/ceph.client.admin.keyring1

9、创建一个名为osd.0 的用户，设置好用户对mon、osd的权限，然后把密钥导出到文件中

1
ceph auth get-or-create osd.0 mon 'allow profile osd' osd 'allow *' -o /var/lib/ceph/osd/ceph-0/keyring

10、创建一个名为mds.nc3 的用户，设置好用户对mon、osd、mds的权限，然后把密钥导出到文件中

1
ceph auth get-or-create mds.nc3 mon 'allow rwx' osd 'allow *' mds 'allow *' -o /var/lib/ceph/mds/ceph-cs1/keyring

4.6 osd相关

1、查看osd状态

1
ceph osd stat

2、查看osd树

1
2
ceph osd tree查看
ceph osd ls-tree rack1  # 查看osd tree中rack1下的osd编号

3、查看osd映射信息

1
ceph osd dump

4、查看数据延迟

1
ceph osd perf

5、查看CRUSH map

1
ceph osd crush dump

6、查看与设置最大 osd daemon 的个数

1
2
3
4
5
6
7
# 查看
[root@admin ~]# ceph  osd getmaxosd
max_osd = 12 in epoch 379


# 设置最大的 osd daemon的个数(当扩大 osd daemon的时候必须扩大这个值)
ceph osd setmaxosd 2048

7、设置 osd 的权重

1
ceph osd reweight 3 0.5  # 把osd.3的权重改为0.5

8、暂停 osd (暂停后整个ceph集群不再接收数据)

1
ceph osd pause  # 暂停的是所有的osd

9、再次开启 osd (开启后再次接收数据)

1
ceph osd unpause

10、设置标志 flags ，不允许关闭 osd、解决网络不稳定，osd 状态不断切换的问题

1
2
3
ceph osd set nodown
取消设置
ceph osd unset nodown

4.7 pool相关

1、创建存储池

1
2
3
4
5
6
7
8
# 语法：ceph osd pool create <pool name> <pg num> <pgp num> [type]
pool name：存储池名称，必须唯一。
pg num：存储池中的pg数量。
pgp num：用于归置的pg数量，默认与pg数量相等。
type：指定存储池的类型，有replicated和erasure， 默认为replicated。 

# 例: 创建一个副本池
ceph osd pool create egon_test 32 32  # 生路type，默认为replicated

2、修改存储池的pg数

注意：在更改pool的PG数量时，需同时更改PGP的数量。PGP是为了管理placement而存在的专门的PG，它和PG的数量应该保持一致。如果你增加pool的pg_num，就需要同时增加pgp_num，保持它们大小一致，这样集群才能正常rebalancing。

1
2
ceph osd pool set egon_test pg_num 60  
ceph osd pool set egon_test pgp_num 60

3、查看存储池

1
2
3
4
5
6
7
8
9
# 查看ceph集群中的pool数量
ceph osd lspools

# 查看名字与详情
ceph osd pool ls
ceph osd pool ls detail

# 查看状态
ceph osd pool stats

4、重命名

1
ceph osd pool rename <old name> <new name>

5、在集群中删除一个 pool,注意删除 poolpool 映射的 image 会直接被删除，线上操作要谨慎
存储池的名字需要重复两次

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
ceph osd pool delete tom_test tom_test --yes-i-really-really-mean-it

# 删除时会报错：
Error EPERM: pool deletion is disabled; you must first set the mon_allow_pool_delete config option to true before you can destroy a pool

这是由于没有配置mon节点的 mon_allow_pool_delete 字段所致，解决办法就是到mon节点进行相应的设置。
解决方案：

# =============方案1==================
ceph tell mon.* injectargs --mon_allow_pool_delete=true
ceph osd pool delete tom_test tom_test --yes-i-really-really-mean-it
删除完成后最好把mon_allow_pool_delete改回去，降低误删的风险

# =============方案2==================
如果是测试环境，想随意删除存储池，可以在配置文件中全局开启删除存储池的功能
# 1、编辑配置文件： vi /etc/ceph/ceph.conf
在配置文件中添加如下内容：
[mon]
mon allow pool delete = true

# 2、推送配置文件
ceph-deploy --overwrite-conf config push mon01 mon02 mon03 osd01 osd02 osd03

# 3、重启ceph-mon服务：
systemctl restart ceph-mon.target

# 4、重新执行删除pool命令即可

6、为一个 ceph pool

配置配额、达到配额前集群会告警，达到上限后无法再写入数据
当我们有很多存储池的时候，有些作为公共存储池，这时候就有必要为这些存储池做一些配额，限制可存放的文件数，或者空间大小，以免无限的增大影响到集群的正常运行。 设置配额。

1
2
3
4
5
6
7
8
9
10
11
12
# 查看池配额设置
ceph osd pool get-quota {pool_name}

# 对对象个数进行配额
ceph osd pool set-quota {pool_name} max_objects {number}

# 对磁盘大小进行配额
ceph osd pool set-quota {pool_name} max_bytes {number}


# 例：
ceph osd pool set-quota egon_test max_bytes 1000000000

7、配置参数
对于存储池的配置参数可以通过下面命令获取。

1
ceph osd pool get <pool name> [key name]

如

1
ceph osd pool get <pool name> size

如果不跟个key名称，会输出所有参数，但有个报错。

1
ceph osd pool set <pool name> <key> <value>

如

1
2
3
# 修改pool的最大副本数与最小副本数
ceph osd pool set egon_test min_size 1
ceph osd pool set egon_test size 2

常用的可用配置参数有。

  • size：存储池中的对象副本数
  • min_size：提供服务所需要的最小副本数，如果定义size为3，min_size也为3，坏掉一个OSD，如果pool池中有副本在此块OSD上面，那么此pool将不提供服务，如果将min_size定义为2，那么还可以提供服务，如果提供为1，表示只要有一块副本都提供服务。
  • pg_num：定义PG的数量
  • pgp_num：定义归置时使用的PG数量
  • crush_ruleset：设置crush算法规则
  • nodelete：控制是否可删除，默认可以
  • nopgchange：控制是否可更改存储池的pg num和pgp num
  • nosizechange：控制是否可以更改存储池的大小
  • noscrub和nodeep-scrub：控制是否整理或深层整理存储池，可临时解决高I/O问题
  • scrub_min_interval：集群负载较低时整理存储池的最小时间间隔
  • scrub_max_interval：整理存储池的最大时间间隔

8、快照
创建存储池快照需要大量的存储空间，取决于存储池的大小。 创建快照，以下两条命令都可以 。

1
2
3
ceph osd pool mksnap <pool name> <snap name>
rados -p <pool name> mksnap <snap name>

列出快照。

1
rados -p <pool name> lssnap

回滚至存储池快照。

1
rados -p <pool name> rollback <obj-name> <snap name>  # 只能回复某个对象

删除存储池快照，以下两条命令都可以删除。

1
2
ceph osd pool rmsnap <pool name> <snap name> 
rados -p <pool name> rmsnap <snap name>

提示
Pool池的快照，相对来说是有局限性的，没办法直接恢复快照里边全部object对象文件，只能一个个来恢复，保存点密码文件应该还是可以的。这样的设计效果，猜测有可能是因为如果pool池直接整体恢复，会导致整个ceph集群数据混乱，毕竟集群中数据是分布式存放的！

pool存储池快照功能了解即可，感兴趣详见《附录5：》

9、压缩
如果使用bulestore存储引擎，默认提供数据压缩，以节约磁盘空间。 启用压缩。

1
ceph osd pool set <pool name> compression_algorithm snappy

snappy：压缩使用的算法，还有有none、zlib、lz4、zstd和snappy等算法。默认为sanppy。zstd压缩比好，但消耗CPU，lz4和snappy对CPU占用较低，不建议使用zlib。

1
2
3
4
ceph osd pool set <pool name> compression_mode aggressive

# 例如
ceph osd pool set egon_test compression_mode aggressive

压缩的模式有none、aggressive、passive和force

  • 默认none。表示不压缩
  • passive表示提示COMPRESSIBLE才压缩
  • aggressive表示提示INCOMPRESSIBLE不压缩，其它都压缩
  • force表示始终压缩。 压缩参数。

参数:

1
2
3
4
5
6
7
8
9
10
11
compression_max_blob_size：压缩对象的最大体积，超过此体积不压缩。默认为0。
compression_min_blob_size：压缩对象的最小体积，小于此体积不压缩。默认为0。 全局压缩选项，这些可以配置到ceph.conf配置文件，作用于所有存储池。
bluestore_compression_algorithm
bluestore_compression_mode
bluestore_compression_required_ratio
bluestore_compression_min_blob_size
bluestore_compression_max_blob_size
bluestore_compression_min_blob_size_ssd
bluestore_compression_max_blob_size_ssd
bluestore_compression_min_blob_size_hdd
bluestore_compression_max_blob_size_hdd

4.8 PG相关

1、查看pg组映射信息

1
2
ceph pg dump  # 或 ceph pg ls

2、查看pg信息的脚本，第一个行为pool的id号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ceph pg dump | awk '
BEGIN { IGNORECASE = 1 }
 /^PG_STAT/ { col=1; while($col!="UP") {col++}; col++ }
 /^[0-9a-f]+\.[0-9a-f]+/ { match($0,/^[0-9a-f]+/); pool=substr($0, RSTART, RLENGTH); poollist[pool]=0;
 up=$col; i=0; RSTART=0; RLENGTH=0; delete osds; while(match(up,/[0-9]+/)>0) { osds[++i]=substr(up,RSTART,RLENGTH); up = substr(up, RSTART+RLENGTH) }
 for(i in osds) {array[osds[i],pool]++; osdlist[osds[i]];}
}
END {
 printf("\n");
 printf("pool :\t"); for (i in poollist) printf("%s\t",i); printf("| SUM \n");
 for (i in poollist) printf("--------"); printf("----------------\n");
 for (i in osdlist) { printf("osd.%i\t", i); sum=0;
   for (j in poollist) { printf("%i\t", array[i,j]); sum+=array[i,j]; sumpool[j]+=array[i,j] }; printf("| %i\n",sum) }
 for (i in poollist) printf("--------"); printf("----------------\n");
 printf("SUM :\t"); for (i in poollist) printf("%s\t",sumpool[i]); printf("|\n");
}'

3、查看pg状态

1
ceph pg stat

4、查看一个pg的map

1
ceph pg map 1.7b

5、查询一个pg的详细信息

1
ceph pg 1.7b query

6、清理一个pg组

1
ceph pg scrub 1.7b

7、查看pg中stuck(卡住)的状态

1
2
3
ceph pg dump_stuck unclean
ceph pg dump_stuck inactive
ceph pg dump_stuck stale
  • Unclean (不干净)
    归置组含有复制数未达到期望数量的对象，它们应该在恢复中。
  • Inactive (不活跃) 归置组不能处理读写，因为它们在等待一个有最新数据的 OSD 复活且进入集群。
  • Stale (不新鲜)
    归置组处于未知状态，即存储它们的 OSD 有段时间没向监视器报告了(由 mon_osd_report_timeout 配置)。 阀值定义的是，归置组被认为卡住前等待的最小时间(默认 300 秒)

8、显示一个集群中的所有的 pg 统计

1
ceph pg dump --format plain  # 可用格式有 plain (默认)和 json 。

9、查看某个 PG 内分布的数据状态，具体状态可以使用选项过滤输出

1
ceph pg ls 17 clean  # 17为pg的编号

10、查询 osd 包含 pg 的信息，过滤输出 pg 的状态信息

1
ceph pg ls-by-osd osd.5

11、查询 pool 包含 pg 的信息，过滤输出 pg 的状态信息

1
ceph pg ls-by-pool egon_test

12、查询某个 osd 状态为 primary pg ，可以根据需要过滤状态

1
ceph pg ls-by-primary osd.3 clean

13、恢复一个丢失的pg
如果集群丢了一个或多个对象，而且必须放弃搜索这些数据，你就要把未找到的对象标记为丢失( lost )。 如果所有可能的位置都查询过了，而仍找不到这些对象，你也许得放弃它们了。这可能是罕见的失败组合导致的， 集群在写入完成前，未能得知写入是否已执行。
当前只支持 revert 选项，它使得回滚到对象的前一个版本(如果它是新对象)或完全忽略它。要把 unfound 对象 标记为 lost ，执行命令:

1
ceph pg {pg-id} mark_unfound_lost revert|delete

4.9 rados命令相关

rados 是和 Ceph 的对象存储集群(RADOS)，Ceph 的分布式文件系统的一部分进行交互是一种实用工具。
1、看 ceph 集群中有多少个 pool (只是查看 pool)

1
rados lspools  # 同 ceph osd pool ls 输出结果一致

2、显示整个系统和被池毁掉的使用率统计，包括磁盘使用(字节)和对象计数

1
rados df

3、创建一个 pool

1
2
3
rados mkpool test

ceph osd pool set test crush_rule egon_rule  # 修改crush_rule为egon_rule

4、创建一个对象

1
rados create test-object -p test  # 创建时卡住了，看看新建的存储池的crush_rule是否正确

5、上传一个对象

1
rados -p test put xxx /tmp/egon.txt

6、查看 ceph pool 中的 ceph object (这里的 object 是以块形式存储的)

1
rados ls -p test

7、删除一个对象

1
rados rm test-object -p test

8 、删除存储池以及它包含的所有数据

1
rados rmpool test test --yes-i-really-really-mean-it

9、为存储池创建快照

1
rados -p test mksnap testsnap

10、列出给定池的快照

1
rados -p test lssnap

11、删除快照

1
rados -p test rmsnap testsnap

12、使用 rados 进行性能测试！！！！！！！！！！！！！！！！！！！

1
rados bench 600 write rand -t 100 -b 4K -p egon_test

选项解释:

  • 测试时间 :600
  • 支持测试类型:write/read ，加 rand 就是随机,不加就是顺序
  • 并发数( -t 选项):100
  • pool 的名字是:egon_test

五 osd相关之osd故障模拟与恢复

5.1 模拟盘坏掉

如果ceph集群有上千个osd daemon，每天坏个2-3块盘太正常了，我们可以模拟down 掉一个 osd 硬盘

1
2
3
# 如果osd daemon正常运行，down的osd会很快自恢复正常,所以需要先关闭守护进程
ssh root@osd01 systemctl stop ceph-osd@0  
ceph osd down 0

5.2 将坏盘踢出集群
集群中坏掉一块盘后，我们需要将其踢出集群让集群恢复到active+clean状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
====================方法一=====================
# 1、关闭守护进程
ssh root@osd01 systemctl stop ceph-osd@0  # 一定要到具体的节点上关闭

# 2、down掉osd
ceph osd down 0

# 3、将osd.0移出集群，集群会自动同步数据
ceph osd out osd.0

# 4、将osd.0移除crushmap
ceph osd crush remove osd.0  

# 5、删除守护进程对应的账户信息
ceph auth rm osd.0  

# 6、删掉osd.0
ceph osd rm osd.0

====================方法二=====================
ssh root@osd02 systemctl stop ceph-osd@3  # 一定要到具体的节点上关闭
ceph osd out osd.3
ceph osd purge osd.3 --yes-i-really-mean-it  # 综合这一步，就可以完成操作
# 删除配置文件中针对该osd的配置
5.3 把原来坏掉的osd修复后重新加入集群
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 远程连接到osd01节点
ssh root@osd01

# 切换到工作目录下
cd /etc/ceph

# 创建osd，无需指定名，会按序号自动生成
ceph osd create  

# 创建账户,切记账号与文件夹对应！！！
ceph-authtool --create-keyring /etc/ceph/ceph.osd.0.keyring --gen-key -n osd.0 --cap mon 'allow profile osd' --cap mgr 'allow profile osd' --cap osd 'allow *'

# 导入新的账户秘钥，切记账号与文件夹对应！！！
ceph auth import -i /etc/ceph/ceph.osd.0.keyring 
ceph auth get-or-create osd.0 -o /var/lib/ceph/osd/ceph-0/keyring

# 加入集群
ceph osd crush add osd.0 0.01900 host=osd01
ceph osd in osd.0

# 重启osd守护进程
systemctl restart ceph-osd@0

ps：如果重启失败

1
2
3
4
5
6
7
8
9
报错：
Job for ceph-osd@3.service failed because start of the service was attempted too often. See "systemctl status ceph-osd@3.service" and "journalctl -xe" for details.
To force a start use "systemctl reset-failed ceph-osd@3.service" followed by "systemctl start ceph-osd@3.service" again.

# 先运行
systemctl reset-failed ceph-osd@3.service systemctl start ceph-osd@3.service

# 再重新开启
systemctl start ceph-osd@3

六 在物理节点上新增osd daemon

在osd01节点上添加新的osd daemon

1
2
3
4
5
6
7
8
9
10
11
# 在osd01节点运行下述命令，把固态盘分/dev/sdi成两个分区，分别用作数据盘/dev/sdh的--block-db和--block-wal
parted -s /dev/sdi mklabel gpt
parted -s /dev/sdi mkpart primary 0% 50%
parted -s /dev/sdi mkpart primary 51% 100%

# 在管理节点运行
cd /etc/ceph
ceph-deploy --overwrite-conf osd create osd01 --data /dev/sdh --block-db /dev/sdi1 --block-wal /dev/sdi2

# 在管理节点运行,注意，如果crush map的设置不对，那么集群会出现unknown状态
ceph osd crush add osd.9 0.01900 host=osd01

如果是在其他节点，例如mon03节点上添加osd daemon
！！！切记切记切记切记切记切记要为mon03节点添加一个cluster network！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 在mon03节点运行下述命令，把固态盘分/dev/sdc成两个分区，分别用作数据盘/dev/sdb的--block-db和--block-wal
parted -s /dev/sdc mklabel gpt
parted -s /dev/sdc mkpart primary 0% 50%
parted -s /dev/sdc mkpart primary 51% 100%


# 在管理节点运行
cd /etc/ceph
ceph-deploy --overwrite-conf osd create mon03 --data /dev/sdb --block-db /dev/sdc1 --block-wal /dev/sdc2

# 在管理节点运行
ceph osd crush add-bucket mon03 host
ceph osd crush add osd.10 0.01900 host=mon03
ceph osd crush move mon03 rack=rack1
ceph osd in osd.10

ps: 如果报错，磁盘发现gp信息

1
2
3
4
那么先清理磁盘
ceph-disk zap /dev/sdb  # dd if=/dev/zero of=/dev/sdb bs=512 count=1
ceph-disk zap /dev/sdc
然后重新执行上述步骤

注意

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在OSD添加或移除时，Ceph会重平衡PG。数据回填和恢复操作可能会产生大量的后端流量，影响集群性能。为避免性能降低，可对回填/恢复操作进行配置：

osd_recovery_op_priority # 值为1-63，默认为10，相对于客户端操作，恢复操作的优先级，默认客户端操作的优先级为63，参数为osd_client_op_priority

osd_recovery_max_active # 每个osd一次处理的活跃恢复请求数量，默认为15，增大此值可加速恢复，但会增加集群负载

osd_recovery_threads # 用于数据恢复时的线程数，默认为1

osd_max_backfills # 单个osd的最大回填操作数，默认为10

osd_backfill_scan_min # 回填操作时最小扫描对象数量，默认为64

osd_backfill_scan_max # 回填操作的最大扫描对象数量，默认为512

osd_backfill_full_ratio # osd的占满率达到多少时，拒绝接受回填请求，默认为0.85

osd_backfill_retry_interval # 回填重试的时间间隔

七 osd节点关机维护

你可能需要定期对集群中某个子网进行例行维护，或者要解决某个域内的问题。当你停止OSD时，默认情况下CRUSH机制会对集群自动重平衡，可将集群设为noout状态来关闭自动重平衡：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 1、关闭自动重平衡
ceph osd set noout

# 2、关闭节点上的osd进程
ceph osd down 编号 # 分别把该节点上的osd设置为down状态
systemctl stop ceph-osd.target   # stop该节点上的所有osd进程

# 3、关闭节点
shutdown -h now

# 4、开始维护
当你对失败域中OSD维护时，其中的PG将会变为degraded状态。

# 5、维护完成启动守护进程
systemctl start ceph-osd.target

# 6、最后务必记得取消集群的noout状态
ceph osd unset noout

八 升级ceph软件版本

1
2
3
4
5
6
7
8
9
在MON和OSD机器上升级安装指定的ceph版本的软件包
逐个重启MON进程
设置noout 避免在异常情况下触发集群数据重新平衡
ceph osd set noout
逐个重启OSD进程
ceph osd down {osd-number} #提前mark down， 减少slow request
systemctl restart ceph-osd@{osd-number} #用systemctl重启OSD进程
恢复noout 设置
ceph osd unset noout

九 扩容

如果副本数为2，PB级的集群的容量超过50%，就要考虑扩容了。 假如OSD主机的磁盘容量为48TB（12*4TB），则需要backfill的数据为24TB（48TB 50%） ，假设网卡为10Gb，则新加一个OSD时，集群大约需要19200s（24TB/(10Gb/8)） 约3小时完成backfill，而backfill后台数据填充将会涉及大量的IO读和网络传输，必将影响生产业务运行。 如果集群容量到80%再扩容会导致更长的backfill时间，近8个小时。

OSD对应的磁盘利用率如果超过50%，也需要尽快扩容。

在业务闲时扩容

十 Ceph monitor故障恢复

1 问题

一般来说，在实际运行中，ceph monitor的个数是2n+1(n>=0)个，在线上至少3个，只要正常的节点数>=n+1，ceph的paxos算法能保证系统的正常运行。所以，对于3个节点，同时只能挂掉一个。一般来说，同时挂掉2个节点的概率比较小，但是万一挂掉2个呢？
如果ceph的monitor节点超过半数挂掉，paxos算法就无法正常进行仲裁(quorum)，此时，ceph集群会阻塞对集群的操作，直到超过半数的monitor节点恢复。

If there are not enough monitors to form a quorum, the ceph command will block trying to reach the cluster. In this situation, you need to get enough ceph-mon daemons running to form a quorum before doing anything else with the cluster.

所以，

（1）如果挂掉的2个节点至少有一个可以恢复，也就是monitor的元数据还是OK的，那么只需要重启ceph-mon进程即可。所以，对于monitor，最好运行在RAID的机器上。这样，即使机器出现故障，恢复也比较容易。

（2）如果挂掉的2个节点的元数据都损坏了呢？出现这种情况，说明人品不行，2台机器的RAID磁盘同时损坏，这得多背？肯定是管理员嫌工资太低，把机器砸了。如何恢复呢？

详见：https://www.cnblogs.com/linhaifeng/articles/14761126.html

十一 Cephfs快照

Cephfs的快照功能在官网都很少提及，因为即使开发了很多年，但是由于cephfs的复杂性，功能一直没能达到稳定，这里，只是介绍一下这个功能，怎么使用，并且建议不要在生产中使用，因为搞不好是会丢数据的

1
2
3
4
5
6
7
8
9
10
11
12
1、使能cephfs可以做快照：
ceph fs set ceph allow_new_snaps 1

2.在要做快照的目录下执行：
mkdir .snap/{snapname}
 
3、查看快照中的内容：
ls .snap/{snapname}
 
4、恢复：
 
cp -R .snap/{snapname}/* ./
]]> <h3 id="一-统一节点上ceph-conf文件"><a href="#一-统一节点上ceph-conf文件" class="headerlink" title="一 统一节点上ceph.conf文件"></a>一 统一节点上ceph.conf文件</h3><p>如果是在ad centos7搭建ceph集群 https://imszz.com/p/877f6188/ 2021-12-28T12:46:25.000Z 2021-12-28T12:46:25.000Z 一、服务器规划
主机名主机IP磁盘角色
node3public-ip：172.18.112.20
cluster-ip: 172.18.112.20		vdbceph-deploy,monitor,mgr,osd
node4public-ip：172.18.112.19
cluster-ip: 172.18.112.19		vdbmonitor,mgr,osd
node5public-ip：172.18.112.18
cluster-ip: 172.18.112.18		vdbmonitor,mgr,osd

二、设置主机名

主机名设置，三台主机分别执行属于自己的命令
node3

1
2
[root@localhost ~]# hostnamectl set-hostname nod3
[root@localhost ~]# hostname node3

node4

1
2
3
[root@localhost ~]# hostnamectl set-hostname node4
[root@localhost ~]# hostname node4

node5

1
2
3
[root@localhost ~]# hostnamectl set-hostname node5
[root@localhost ~]# hostname node5

执行完毕后要想看到效果，需要关闭当前命令行窗口，重新打开即可看到设置效果

三、设置hosts文件

在3台机器上都执行下面命令，添加映射

1
2
3
echo "172.18.112.20 node3 " >> /etc/hosts
echo "172.18.112.19 node4 " >> /etc/hosts
echo "172.18.112.18 node5 " >> /etc/hosts

四、创建用户并设置免密登录

创建用户（三台机器上都运行）

1
2
3
4
5
useradd -d /home/admin -m admin
echo "123456" | passwd admin --stdin 
#sudo权限
echo "admin ALL = (root) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/admin
sudo chmod 0440 /etc/sudoers.d/admin

设置免密登录 （只在node3上执行）

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
[root@node3 ~]# su - admin
[admin@node3 ~]$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/admin/.ssh/id_rsa):
Created directory '/home/admin/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/admin/.ssh/id_rsa.
Your public key has been saved in /home/admin/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:qfWhuboKeoHQOOMLOIB5tjK1RPjgw/Csl4r6A1FiJYA admin@admin.ops5.bbdops.com
The key's randomart image is:
+---[RSA 2048]----+
|+o..             |
|E.+              |
|*%               |
|X+X      .       |
|=@.+    S .      |
|X.*    o + .     |
|oBo.  . o .      |
|ooo.     .       |
|+o....oo.        |
+----[SHA256]-----+
[admin@node3 ~]$ ssh-copy-id admin@node3
[admin@node3 ~]$ ssh-copy-id admin@node4
[admin@node3 ~]$ ssh-copy-id admin@node5

注意: 没有ssh-copy-id 这个命令可以手动把公钥传到对应的机器上去

1
cat ~/.ssh/id_*.pub | ssh  admin@host3 'cat >> .ssh/authorized_keys'

五、配置时间同步

三台都执行

1
2
3
4
5
6
7
8
9
10
11
[root@node3 ~]$ timedatectl #查看本地时间

[root@node3 ~]$ timedatectl set-timezone Asia/Shanghai #改为亚洲上海时间

[root@node3 ~]$ yum install -y chrony #同步工具

[root@node3 ~]$ chronyc -n  sources -v #同步列表

[root@node3 ~]$ chronyc tracking  #同步服务状态

[root@node3 ~]$ timedatectl status #查看本地时间

六、安装ceph-deploy并安装ceph软件包

配置ceph清华源

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
cat > /etc/yum.repos.d/ceph.repo<<'EOF'
[Ceph]
name=Ceph packages for $basearch
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/$basearch
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
[Ceph-noarch]
name=Ceph noarch packages
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/noarch
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
[ceph-source]
name=Ceph source packages
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/SRPMS
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
EOF

安装ceph-deploy

1
[admin@node3 ~]# sudo yum install ceph-deploy

初始化mon点

ceph需要epel源的包，所以安装的节点都需要yum install epel-release

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
[admin@node3 ~]$ mkdir my-cluster
[admin@node3 ~]$ cd my-cluster
# new
[admin@node3 my-cluster]$ ceph-deploy new node3 node4 node5
Traceback (most recent call last):
  File "/bin/ceph-deploy", line 18, in <module>
    from ceph_deploy.cli import main
  File "/usr/lib/python2.7/site-packages/ceph_deploy/cli.py", line 1, in <module>
    import pkg_resources
ImportError: No module named pkg_resources
#以上出现报错，是因为没有pip，安装pip
[admin@node3 my-cluster]$ sudo yum install epel-release
[admin@node3 my-cluster]$ sudo yum install python-pip
#重新初始化
[admin@node3 my-cluster]$ ceph-deploy new node3 node4 node5
[admin@node3 my-cluster]$ ls
ceph.conf  ceph-deploy-ceph.log  ceph.mon.keyring
[admin@node3 my-cluster]$ cat ceph.conf 
[global]
fsid = 3a2a06c7-124f-4703-b798-88eb2950361e
mon_initial_members = node3, node4, node5
mon_host = 172.18.112.20,172.18.112.19,172.18.112.18
auth_cluster_required = cephx
auth_service_required = cephx
auth_client_required = cephx

修改ceph.conf，添加如下配置

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
public network = 172.18.112.0/24
cluster network = 172.18.112.0/24
osd pool default size       = 3
osd pool default min size   = 2
osd pool default pg num     = 128
osd pool default pgp num    = 128
osd pool default crush rule = 0
osd crush chooseleaf type   = 1
max open files              = 131072
ms bind ipv6                = false
[mon]
mon clock drift allowed      = 10
mon clock drift warn backoff = 30
mon osd full ratio           = .95
mon osd nearfull ratio       = .85
mon osd down out interval    = 600
mon osd report timeout       = 300
mon allow pool delete      = true
[osd]
osd recovery max active      = 3    
osd max backfills            = 5
osd max scrubs               = 2
osd mkfs type = xfs
osd mkfs options xfs = -f -i size=1024
osd mount options xfs = rw,noatime,inode64,logbsize=256k,delaylog
filestore max sync interval  = 5
osd op threads               = 2

安装Ceph软件到指定节点

1
[admin@node3 my-cluster]$ ceph-deploy install --no-adjust-repos node3 node4 node5

–no-adjust-repos是直接使用本地源，不生成官方源.

部署初始的monitors，并获得keys

1
[admin@nod3 my-cluster]$ ceph-deploy mon create-initial

做完这一步，在当前目录下就会看到有如下的keyrings：

1
2
3
[admin@node3 my-cluster]$ ls
ceph.bootstrap-mds.keyring  ceph.bootstrap-osd.keyring  ceph.client.admin.keyring  ceph-deploy-ceph.log
ceph.bootstrap-mgr.keyring  ceph.bootstrap-rgw.keyring  ceph.conf                  ceph.mon.keyring

将配置文件和密钥复制到集群各节点

配置文件就是生成的ceph.conf，而密钥是ceph.client.admin.keyring，当使用ceph客户端连接至ceph集群时需要使用的密默认密钥，这里我们所有节点都要复制，命令如下。

1
[admin@node3 my-cluster]$ ceph-deploy admin node3 node4 node5

七、部署ceph-mgr

1
2
#在L版本的`Ceph`中新增了`manager daemon`，如下命令部署一个`Manager`守护进程
[admin@node3 my-cluster]$ ceph-deploy mgr create node3

八、创建osd

1
2
3
4
#用法：ceph-deploy osd create –data {device} {ceph-node}
ceph-deploy osd create --data /dev/vdb node3
ceph-deploy osd create --data /dev/vdb node4
ceph-deploy osd create --data /dev/vdb node5

检查osd状态 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[admin@node3 my-cluster]$ sudo ceph health
HEALTH_OK

[admin@node3 my-cluster]$ sudo ceph -s 
  cluster:
    id:     3a2a06c7-124f-4703-b798-88eb2950361e
    health: HEALTH_OK
 
  services:
    mon: 3 daemons, quorum node5,node4,node3
    mgr: node3(active)
    osd: 3 osds: 3 up, 3 in
 
  data:
    pools:   0 pools, 0 pgs
    objects: 0  objects, 0 MiB
    usage:   3.2 GiB used, 597 GiB / 600 GiB avail
    pgs:

默认情况下ceph.client.admin.keyring文件的权限为600，属主和属组为root，如果在集群内节点使用cephadmin用户直接直接ceph命令，将会提示无法找到/etc/ceph/ceph.client.admin.keyring文件，因为权限不足。

如果使用sudo ceph不存在此问题，为方便直接使用ceph命令，可将权限设置为644。在集群节点上面node1 admin用户下执行下面命令。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[admin@node3 my-cluster]$ ceph -s
2021-12-28 07:59:36.062 7f52d08e0700 -1 auth: unable to find a keyring on /etc/ceph/ceph.client.admin.keyring,/etc/ceph/ceph.keyring,/etc/ceph/keyring,/etc/ceph/keyring.bin,: (2) No such file or directory
2021-12-28 07:59:36.062 7f52d08e0700 -1 monclient: ERROR: missing keyring, cannot use cephx for authentication
[errno 2] error connecting to the cluster
[admin@node3 my-cluster]$ sudo chmod 644 /etc/ceph/ceph.client.admin.keyring 


[admin@node3 my-cluster]$ ceph -s 
  cluster:
    id:     3a2a06c7-124f-4703-b798-88eb2950361e
    health: HEALTH_OK
 
  services:
    mon: 3 daemons, quorum node5,node4,node3
    mgr: node3(active)
    osd: 3 osds: 3 up, 3 in
 
  data:
    pools:   0 pools, 0 pgs
    objects: 0  objects, 0 MiB
    usage:   3.2 GiB used, 597 GiB / 600 GiB avail
    pgs:

查看osds

1
2
3
4
5
6
7
8
9
[admin@node3 my-cluster]$ sudo ceph osd tree 
ID CLASS WEIGHT  TYPE NAME      STATUS REWEIGHT PRI-AFF 
-1       0.58589 root default                           
-3       0.19530     host node3                         
 3   hdd 0.19530         osd.3      up  1.00000 1.00000 
-5       0.19530     host node4                         
 4   hdd 0.19530         osd.4      up  1.00000 1.00000 
-7       0.19530     host node5                         
 5   hdd 0.19530         osd.5      up  1.00000 1.00000

九、开启MGR监控模块

方式一：命令操作

1
ceph mgr module enable dashboard

如果以上操作报错如下：

1
Error ENOENT: all mgr daemons do not support module 'dashboard', pass --force to force enablement

则因为没有安装ceph-mgr-dashboard，在mgr的节点上安装。

1
2
yum install ceph-mgr-dashboard

方式二：配置文件

1
2
3
4
5
6
7
8
9
# 编辑ceph.conf文件
vi ceph.conf
[mon]
mgr initial modules = dashboard
#推送配置
[admin@node3 my-cluster]$ ceph-deploy --overwrite-conf config push node3 node4 node5 
#重启mgr
 sudo systemctl restart ceph-mgr@node3

web登录配置
默认情况下，仪表板的所有HTTP连接均使用SSL/TLS进行保护。

1
2
3
4
5
6
7
#要快速启动并运行仪表板，可以使用以下内置命令生成并安装自签名证书:
[root@node3 my-cluster]# ceph dashboard create-self-signed-cert
Self-signed certificate created

#创建具有管理员角色的用户:
[root@node3 my-cluster]# ceph dashboard set-login-credentials admin admin
Username and password updated

#查看ceph-mgr服务:

1
2
3
4
[root@node3 my-cluster]# ceph mgr services
{
    "dashboard": "https://node3:8443/"
}

以上配置完成后，浏览器输入 https://node3:8443 输入用户名admin，密码admin登录即可查看

要本地hosts解析

ceph

]]> <h2 id="一、服务器规划"><a href="#一、服务器规划" class="headerlink" title="一、服务器规划"></a>一、服务器规划</h2><table> <thead> <tr> <th>主机名</th> <th>主机IP</th> <th>磁 K8S使用ceph-csi持久化存储之RBD https://imszz.com/p/4aa1a279/ 2021-12-28T12:46:25.000Z 2022-01-09T12:46:25.000Z 创建一个ceph pool 创建存储池

ceph集群请看这里：https://imszz.com/p/877f6188/

1
2
3
ceph osd pool create rbd 128
ceph osd pool set-quota rbd max_bytes $((50 * 1024 * 1024 * 1024)) #50G的存储池
rbd pool init rbd

查看集群状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@node3 ~]# ceph -s
  cluster:
    id:     3a2a06c7-124f-4703-b798-88eb2950361e
    health: HEALTH_OK
 
  services:
    mon: 3 daemons, quorum node5,node4,node3
    mgr: node3(active)
    osd: 3 osds: 3 up, 3 in
 
  data:
    pools:   1 pools, 128 pgs
    objects: 23  objects, 22 MiB
    usage:   7.4 GiB used, 593 GiB / 600 GiB avail
    pgs:     128 active+clean

查看用户key

1
2
3
4
5
6
7
8
[root@node3 ~]# ceph auth get client.admin
exported keyring for client.admin
[client.admin]
key = AQCJMslhQW0JEhAAXEgcsW3IZozDi7FF51+sbw==
caps mds = "allow *"
caps mgr = "allow *"
caps mon = "allow *"
caps osd = "allow *"

或者自己创建存储池、用户以及用户key

1
2
3
4
5
[root@node3 ~]# ceph osd pool create kubernetes
[root@node3 ~]# rbd pool init kubernetes
[root@node3 ~]# ceph auth get-or-create client.kubernetes mon 'profile rbd' osd 'profile rbd pool=kubernetes' mgr 'profile rbd pool=kubernetes'
[client.kubernetes]
    key = AQD9o0Fd6hQRChAAt7fMaSZXduT3NWEqylNpmg==

注意：这里key后面对应的只是一个例子，实际配置中要以运行命令后产生的结果为准
这里的key使用user的key，后面配置中是需要用到的
如果是ceph luminous版本的集群，那么命令应该是ceph auth get-or-create client.kubernetes mon 'allow r' osd 'allow rwx pool=kubernetes' -o ceph.client.kubernetes.keyring

k8s所有节点安装ceph客户端

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
cat > /etc/yum.repos.d/ceph.repo<<'EOF'
[Ceph]
name=Ceph packages for $basearch
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/$basearch
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
[Ceph-noarch]
name=Ceph noarch packages
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/noarch
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
[ceph-source]
name=Ceph source packages
baseurl=https://mirror.tuna.tsinghua.edu.cn/ceph/rpm-mimic/el7/SRPMS
enabled=1
gpgcheck=1
type=rpm-md
gpgkey=https://mirror.tuna.tsinghua.edu.cn/ceph/keys/release.asc
priority=1
EOF
1
yum -y install ceph

生成ceph-csi的kubernetes configmap

1
2
3
4
5
6
7
8
9
[root@node3 ~]# ceph mon dump
dumped monmap epoch 1
epoch 1
fsid 3a2a06c7-124f-4703-b798-88eb2950361e
last_changed 2021-12-27 11:27:02.815248
created 2021-12-27 11:27:02.815248
0: 172.18.112.18:6789/0 mon.node5
1: 172.18.112.19:6789/0 mon.node4
2: 172.18.112.20:6789/0 mon.node3

用以上的的信息生成configmap：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
cat csi-config-map.yaml
apiVersion: v1
kind: ConfigMap
data:
  config.json: |-
    [
      {
        "clusterID": "3a2a06c7-124f-4703-b798-88eb2950361e",
        "monitors": [
          "172.18.112.20:6789",
          "172.18.112.19:6789",
          "172.18.112.18:6789"
        ]
      }
    ]
metadata:
  name: ceph-csi-config

在kubernetes集群上，将此configmap存储到集群

1
kubectl apply -f csi-config-map.yaml

生成ceph-csi cephx的secret

1
2
3
4
5
6
7
8
9
10
cat <<EOF > csi-rbd-secret.yaml
apiVersion: v1
kind: Secret
metadata:
name: csi-rbd-secret
namespace: default
stringData:
    userID: admin
    userKey: AQAs89depA23NRAA8yEg0GfHNC/uhKU9jsgp6Q==
EOF

将此配置存储到kubernetes中

1
2
kubectl apply -f csi-rbd-secret.yaml

配置ceph-csi插件(kubernetes上的rbac和提供存储功能的容器)

rbac部分

可以通信github直接部署

1
kubectl apply -f https://raw.githubusercontent.com/ceph/ceph-csi/master/deploy/rbd/kubernetes/csi-provisioner-rbac.yaml
离线请按照以下配置
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
[root@master-1 ~]# cat csi-provisioner-rbac.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: rbd-csi-provisioner
  # replace with non-default namespace name
  namespace: default

---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rbd-external-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["list", "watch", "create", "update", "patch"]
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "update", "delete", "patch"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims/status"]
    verbs: ["update", "patch"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["snapshot.storage.k8s.io"]
    resources: ["volumesnapshots"]
    verbs: ["get", "list"]
  - apiGroups: ["snapshot.storage.k8s.io"]
    resources: ["volumesnapshotcontents"]
    verbs: ["create", "get", "list", "watch", "update", "delete"]
  - apiGroups: ["snapshot.storage.k8s.io"]
    resources: ["volumesnapshotclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["volumeattachments"]
    verbs: ["get", "list", "watch", "update", "patch"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["volumeattachments/status"]
    verbs: ["patch"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["csinodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["snapshot.storage.k8s.io"]
    resources: ["volumesnapshotcontents/status"]
    verbs: ["update"]
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get"]
  - apiGroups: [""]
    resources: ["serviceaccounts"]
    verbs: ["get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rbd-csi-provisioner-role
subjects:
  - kind: ServiceAccount
    name: rbd-csi-provisioner
    # replace with non-default namespace name
    namespace: default
roleRef:
  kind: ClusterRole
  name: rbd-external-provisioner-runner
  apiGroup: rbac.authorization.k8s.io

---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  # replace with non-default namespace name
  namespace: default
  name: rbd-external-provisioner-cfg
rules:
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get", "list", "watch", "create", "update", "delete"]
  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    verbs: ["get", "watch", "list", "delete", "update", "create"]

---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rbd-csi-provisioner-role-cfg
  # replace with non-default namespace name
  namespace: default
subjects:
  - kind: ServiceAccount
    name: rbd-csi-provisioner
    # replace with non-default namespace name
    namespace: default
roleRef:
  kind: Role
  name: rbd-external-provisioner-cfg
  apiGroup: rbac.authorization.k8s.io
1
kubectl apply -f csi-provisioner-rbac.yaml

可以通信github直接部署

1
kubectl apply -f https://raw.githubusercontent.com/ceph/ceph-csi/master/deploy/rbd/kubernetes/csi-nodeplugin-rbac.yaml
离线请按照以下配置
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
[root@master-1 ~]# cat csi-nodeplugin-rbac.yaml 
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: rbd-csi-nodeplugin
  # replace with non-default namespace name
  namespace: default
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rbd-csi-nodeplugin
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get"]
  # allow to read Vault Token and connection options from the Tenants namespace
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get"]
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get"]
  - apiGroups: [""]
    resources: ["serviceaccounts"]
    verbs: ["get"]
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["volumeattachments"]
    verbs: ["list", "get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rbd-csi-nodeplugin
subjects:
  - kind: ServiceAccount
    name: rbd-csi-nodeplugin
    # replace with non-default namespace name
    namespace: default
roleRef:
  kind: ClusterRole
  name: rbd-csi-nodeplugin
  apiGroup: rbac.authorization.k8s.io

部署

1
kubectl apply -f csi-nodeplugin-rbac.yaml

provisioner部分

包含镜像版本，要是用其他版本，请自行修改yaml文件：

1
2
3
4
5
6
k8s.gcr.io/sig-storage/csi-resizer:v1.3.0
k8s.gcr.io/sig-storage/csi-snapshotter:v4.2.0
k8s.gcr.io/sig-storage/csi-provisioner:v3.0.0
k8s.gcr.io/sig-storage/csi-node-driver-registrar:v2.3.0
k8s.gcr.io/sig-storage/csi-attacher:v3.3.0
quay.io/cephcsi/cephcsi:canary

官方文件

1
2
wget https://raw.githubusercontent.com/ceph/ceph-csi/master/deploy/rbd/kubernetes/csi-rbdplugin-provisioner.yaml
wget https://raw.githubusercontent.com/ceph/ceph-csi/master/deploy/rbd/kubernetes/csi-rbdplugin.yaml

以下yml文件所引用的镜像文件已经本地镜像仓库，请根据自己网络环境调整

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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
[root@master-1 ~]# cat csi-rbdplugin-provisioner.yaml
---
kind: Service
apiVersion: v1
metadata:
  name: csi-rbdplugin-provisioner
  # replace with non-default namespace name
  namespace: default
  labels:
    app: csi-metrics
spec:
  selector:
    app: csi-rbdplugin-provisioner
  ports:
    - name: http-metrics
      port: 8080
      protocol: TCP
      targetPort: 8680

---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: csi-rbdplugin-provisioner
  # replace with non-default namespace name
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: csi-rbdplugin-provisioner
  template:
    metadata:
      labels:
        app: csi-rbdplugin-provisioner
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - csi-rbdplugin-provisioner
              topologyKey: "kubernetes.io/hostname"
      serviceAccountName: rbd-csi-provisioner
      priorityClassName: system-cluster-critical
      containers:
        - name: csi-provisioner
          image: dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-provisioner:v3.0.0
          args:
            - "--csi-address=$(ADDRESS)"
            - "--v=5"
            - "--timeout=150s"
            - "--retry-interval-start=500ms"
            - "--leader-election=true"
            #  set it to true to use topology based provisioning
            - "--feature-gates=Topology=false"
            # if fstype is not specified in storageclass, ext4 is default
            - "--default-fstype=ext4"
            - "--extra-create-metadata=true"
          env:
            - name: ADDRESS
              value: unix:///csi/csi-provisioner.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
        - name: csi-snapshotter
          image: dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-snapshotter:v4.2.0
          args:
            - "--csi-address=$(ADDRESS)"
            - "--v=5"
            - "--timeout=150s"
            - "--leader-election=true"
          env:
            - name: ADDRESS
              value: unix:///csi/csi-provisioner.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
        - name: csi-attacher
          image: dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-attacher:v3.3.0
          args:
            - "--v=5"
            - "--csi-address=$(ADDRESS)"
            - "--leader-election=true"
            - "--retry-interval-start=500ms"
          env:
            - name: ADDRESS
              value: /csi/csi-provisioner.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
        - name: csi-resizer
          image: dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-resizer:v1.3.0
          args:
            - "--csi-address=$(ADDRESS)"
            - "--v=5"
            - "--timeout=150s"
            - "--leader-election"
            - "--retry-interval-start=500ms"
            - "--handle-volume-inuse-error=false"
          env:
            - name: ADDRESS
              value: unix:///csi/csi-provisioner.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
        - name: csi-rbdplugin
          # for stable functionality replace canary with latest release version
          image: dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary
          args:
            - "--nodeid=$(NODE_ID)"
            - "--type=rbd"
            - "--controllerserver=true"
            - "--endpoint=$(CSI_ENDPOINT)"
            - "--csi-addons-endpoint=$(CSI_ADDONS_ENDPOINT)"
            - "--v=5"
            - "--drivername=rbd.csi.ceph.com"
            - "--pidlimit=-1"
            - "--rbdhardmaxclonedepth=8"
            - "--rbdsoftmaxclonedepth=4"
            - "--enableprofiling=false"
          env:
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: NODE_ID
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            # - name: KMS_CONFIGMAP_NAME
            #   value: encryptionConfig
            - name: CSI_ENDPOINT
              value: unix:///csi/csi-provisioner.sock
            - name: CSI_ADDONS_ENDPOINT
              value: unix:///csi/csi-addons.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
            - mountPath: /dev
              name: host-dev
            - mountPath: /sys
              name: host-sys
            - mountPath: /lib/modules
              name: lib-modules
              readOnly: true
            - name: ceph-csi-config
              mountPath: /etc/ceph-csi-config/
           # - name: ceph-csi-encryption-kms-config
           #   mountPath: /etc/ceph-csi-encryption-kms-config/
            - name: keys-tmp-dir
              mountPath: /tmp/csi/keys
           # - name: ceph-config
           #   mountPath: /etc/ceph/
        - name: csi-rbdplugin-controller
          # for stable functionality replace canary with latest release version
          image: dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary
          args:
            - "--type=controller"
            - "--v=5"
            - "--drivername=rbd.csi.ceph.com"
            - "--drivernamespace=$(DRIVER_NAMESPACE)"
          env:
            - name: DRIVER_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: ceph-csi-config
              mountPath: /etc/ceph-csi-config/
            - name: keys-tmp-dir
              mountPath: /tmp/csi/keys
           # - name: ceph-config
           #   mountPath: /etc/ceph/
        - name: liveness-prometheus
          image: dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary
          args:
            - "--type=liveness"
            - "--endpoint=$(CSI_ENDPOINT)"
            - "--metricsport=8680"
            - "--metricspath=/metrics"
            - "--polltime=60s"
            - "--timeout=3s"
          env:
            - name: CSI_ENDPOINT
              value: unix:///csi/csi-provisioner.sock
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
          imagePullPolicy: "IfNotPresent"
      volumes:
        - name: host-dev
          hostPath:
            path: /dev
        - name: host-sys
          hostPath:
            path: /sys
        - name: lib-modules
          hostPath:
            path: /lib/modules
        - name: socket-dir
          emptyDir: {
            medium: "Memory"
          }
        #- name: ceph-config
        #  configMap:
        #    name: ceph-config
        - name: ceph-csi-config
          configMap:
            name: ceph-csi-config
        #- name: ceph-csi-encryption-kms-config
        #  configMap:
        #    name: ceph-csi-encryption-kms-config
        - name: keys-tmp-dir
          emptyDir: {
            medium: "Memory"
          }

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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
[root@master-1 ~]# cat csi-rbdplugin.yaml
---
kind: DaemonSet
apiVersion: apps/v1
metadata:
  name: csi-rbdplugin
  # replace with non-default namespace name
  namespace: default
spec:
  selector:
    matchLabels:
      app: csi-rbdplugin
  template:
    metadata:
      labels:
        app: csi-rbdplugin
    spec:
      serviceAccountName: rbd-csi-nodeplugin
      hostNetwork: true
      hostPID: true
      priorityClassName: system-node-critical
      # to use e.g. Rook orchestrated cluster, and mons' FQDN is
      # resolved through k8s service, set dns policy to cluster first
      dnsPolicy: ClusterFirstWithHostNet
      containers:
        - name: driver-registrar
          # This is necessary only for systems with SELinux, where
          # non-privileged sidecar containers cannot access unix domain socket
          # created by privileged CSI driver container.
          securityContext:
            privileged: true
          image: dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-node-driver-registrar:v2.3.0
          args:
            - "--v=5"
            - "--csi-address=/csi/csi.sock"
            - "--kubelet-registration-path=/var/lib/kubelet/plugins/rbd.csi.ceph.com/csi.sock"
          env:
            - name: KUBE_NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
            - name: registration-dir
              mountPath: /registration
        - name: csi-rbdplugin
          securityContext:
            privileged: true
            capabilities:
              add: ["SYS_ADMIN"]
            allowPrivilegeEscalation: true
          # for stable functionality replace canary with latest release version
          image: dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary
          args:
            - "--nodeid=$(NODE_ID)"
            - "--pluginpath=/var/lib/kubelet/plugins"
            - "--stagingpath=/var/lib/kubelet/plugins/kubernetes.io/csi/pv/"
            - "--type=rbd"
            - "--nodeserver=true"
            - "--endpoint=$(CSI_ENDPOINT)"
            - "--csi-addons-endpoint=$(CSI_ADDONS_ENDPOINT)"
            - "--v=5"
            - "--drivername=rbd.csi.ceph.com"
            - "--enableprofiling=false"
            # If topology based provisioning is desired, configure required
            # node labels representing the nodes topology domain
            # and pass the label names below, for CSI to consume and advertise
            # its equivalent topology domain
            # - "--domainlabels=failure-domain/region,failure-domain/zone"
          env:
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: NODE_ID
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            # - name: KMS_CONFIGMAP_NAME
            #   value: encryptionConfig
            - name: CSI_ENDPOINT
              value: unix:///csi/csi.sock
            - name: CSI_ADDONS_ENDPOINT
              value: unix:///csi/csi-addons.sock
          imagePullPolicy: "IfNotPresent"
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
            - mountPath: /dev
              name: host-dev
            - mountPath: /sys
              name: host-sys
            - mountPath: /run/mount
              name: host-mount
            - mountPath: /etc/selinux
              name: etc-selinux
              readOnly: true
            - mountPath: /lib/modules
              name: lib-modules
              readOnly: true
            - name: ceph-csi-config
              mountPath: /etc/ceph-csi-config/
            #- name: ceph-csi-encryption-kms-config
            #  mountPath: /etc/ceph-csi-encryption-kms-config/
            - name: plugin-dir
              mountPath: /var/lib/kubelet/plugins
              mountPropagation: "Bidirectional"
            - name: mountpoint-dir
              mountPath: /var/lib/kubelet/pods
              mountPropagation: "Bidirectional"
            - name: keys-tmp-dir
              mountPath: /tmp/csi/keys
            - name: ceph-logdir
              mountPath: /var/log/ceph
            #- name: ceph-config
            #  mountPath: /etc/ceph/
        - name: liveness-prometheus
          securityContext:
            privileged: true
          image: dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary
          args:
            - "--type=liveness"
            - "--endpoint=$(CSI_ENDPOINT)"
            - "--metricsport=8680"
            - "--metricspath=/metrics"
            - "--polltime=60s"
            - "--timeout=3s"
          env:
            - name: CSI_ENDPOINT
              value: unix:///csi/csi.sock
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
          volumeMounts:
            - name: socket-dir
              mountPath: /csi
          imagePullPolicy: "IfNotPresent"
      volumes:
        - name: socket-dir
          hostPath:
            path: /var/lib/kubelet/plugins/rbd.csi.ceph.com
            type: DirectoryOrCreate
        - name: plugin-dir
          hostPath:
            path: /var/lib/kubelet/plugins
            type: Directory
        - name: mountpoint-dir
          hostPath:
            path: /var/lib/kubelet/pods
            type: DirectoryOrCreate
        - name: ceph-logdir
          hostPath:
            path: /var/log/ceph
            type: DirectoryOrCreate
        - name: registration-dir
          hostPath:
            path: /var/lib/kubelet/plugins_registry/
            type: Directory
        - name: host-dev
          hostPath:
            path: /dev
        - name: host-sys
          hostPath:
            path: /sys
        - name: etc-selinux
          hostPath:
            path: /etc/selinux
        - name: host-mount
          hostPath:
            path: /run/mount
        - name: lib-modules
          hostPath:
            path: /lib/modules
        #- name: ceph-config
        #  configMap:
        #    name: ceph-config
        - name: ceph-csi-config
          configMap:
            name: ceph-csi-config
        #- name: ceph-csi-encryption-kms-config
        #  configMap:
        #    name: ceph-csi-encryption-kms-config
        - name: keys-tmp-dir
          emptyDir: {
            medium: "Memory"
          }
---
# This is a service to expose the liveness metrics
apiVersion: v1
kind: Service
metadata:
  name: csi-metrics-rbdplugin
  # replace with non-default namespace name
  namespace: default
  labels:
    app: csi-metrics
spec:
  ports:
    - name: http-metrics
      port: 8080
      protocol: TCP
      targetPort: 8680
  selector:
    app: csi-rbdplugin

修改csi-rbdplugin-provisioner.yaml和csi-rbdplugin.yaml文件，注释关于ceph-csi-encryption-kms-config与ceph-config配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[root@master-1 ~]# grep  "#" csi-rbdplugin-provisioner.yaml
  # replace with non-default namespace name
  # replace with non-default namespace name
            #  set it to true to use topology based provisioning
            # if fstype is not specified in storageclass, ext4 is default
          # for stable functionality replace canary with latest release version
            # - name: KMS_CONFIGMAP_NAME
            #   value: encryptionConfig
           # - name: ceph-csi-encryption-kms-config
           #   mountPath: /etc/ceph-csi-encryption-kms-config/
           # - name: ceph-config
           #   mountPath: /etc/ceph/
          # for stable functionality replace canary with latest release version
           # - name: ceph-config
           #   mountPath: /etc/ceph/
        #- name: ceph-config
        #  configMap:
        #    name: ceph-config
        #- name: ceph-csi-encryption-kms-config
        #  configMap:
        #    name: ceph-csi-encryption-kms-config

注意：所使用的镜像以及修改为本地仓库镜像，请根据自己网络环境调整

1
2
3
4
5
6
dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-resizer:v1.3.0
dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-snapshotter:v4.2.0
dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-provisioner:v3.0.0
dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-node-driver-registrar:v2.3.0
dockerhub.kubekey.local/k8s.gcr.io/sig-storage/csi-attacher:v3.3.0
dockerhub.kubekey.local/quay.io/cephcsi/cephcsi:canary

部署

1
2
kubectl apply -f csi-rbdplugin-provisioner.yaml
kubectl apply -f csi-rbdplugin.yaml

查看运行状态

1
2
3
4
5
6
7
8
9
10
11
[root@master-1 ~]# kubectl get pods 
NAME                                         READY   STATUS    RESTARTS   AGE

csi-rbdplugin-5jb79                          3/3     Running   0          22h
csi-rbdplugin-7dqd7                          3/3     Running   0          22h
csi-rbdplugin-8dpnb                          3/3     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-4clkc   7/7     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-lbjld   7/7     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-vpvb2   7/7     Running   0          22h
csi-rbdplugin-txjcg                          3/3     Running   0          22h
csi-rbdplugin-x57d6                          3/3     Running   0          22h

使用ceph块儿设备

创建storageclass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[root@master-1 ~]# cat csi-rbd-sc.yaml
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
   name: csi-rbd-sc
provisioner: rbd.csi.ceph.com
parameters:
   clusterID: 3a2a06c7-124f-4703-b798-88eb2950361e
   pool: rbd
   imageFeatures: layering
   csi.storage.k8s.io/provisioner-secret-name: csi-rbd-secret
   csi.storage.k8s.io/provisioner-secret-namespace: default
   csi.storage.k8s.io/controller-expand-secret-name: csi-rbd-secret
   csi.storage.k8s.io/controller-expand-secret-namespace: default
   csi.storage.k8s.io/node-stage-secret-name: csi-rbd-secret
   csi.storage.k8s.io/node-stage-secret-namespace: default
   csi.storage.k8s.io/fstype: ext4
reclaimPolicy: Delete
allowVolumeExpansion: true
mountOptions:
   - discard
  • clusterID对应之前的步骤中的fsid
  • imageFeatures，这个是用来确定创建的image的特征的
  • allowVolumeExpansion: true 是否开启在线扩容

部署

1
kubectl apply -f csi-rbd-sc.yaml

查看storageclass：

1
2
3
4
5
[root@master-1 ~]#  kubectl get storageclass
NAME              PROVISIONER        RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE

csi-rbd-sc        rbd.csi.ceph.com   Delete          Immediate              true                   22h
local (default)   openebs.io/local   Delete          WaitForFirstConsumer   false                  5d23h

创建PVC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[root@master-1 ~]# cat raw-block-pvc.yaml
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: raw-block-pvc
spec:
  accessModes:
    - ReadWriteOnce
  volumeMode: Block
  resources:
    requests:
      storage: 1Gi
  storageClassName: csi-rbd-sc

理论上volumeMode应该指定为Block的，要求PVC和控制器中都指定为相同的模式才能挂载使用，但是经过验证在应用端也指定Block，还是不能挂载上，因此就都去掉了，变成了默认的Filesystem

部署

1
kubectl apply -f raw-block-pvc.yaml

查看pvc

1
2
3
4
[root@master-1 ~]#  kubectl get pvc
NAME            STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
raw-block-pvc   Bound    pvc-23bb1905-2e26-4ce1-8616-2754dd36317f   1Gi        RWO            csi-rbd-sc     22h

创建使用PVC的应用测试无状态Pod

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[root@master-1 ~]# cat raw-block-pod.yaml
---
apiVersion: v1
kind: Pod
metadata:
  name: pod-with-raw-block-volume
spec:
  containers:
    - name: fc-container
      image: fedora:26
      command: ["/bin/sh", "-c"]
      args: ["tail -f /dev/null"]
      volumeDevices:
        - name: data
          devicePath: /dev/xvda
  volumes:
    - name: data
      persistentVolumeClaim:
        claimName: raw-block-pvc

部署

1
kubectl apply -f raw-block-pod.yaml

查看

1
2
3
4
5
6
7
8
9
10
11
12
13
[root@master-1 ~]# kubectl get pods 
NAME                                         READY   STATUS    RESTARTS   AGE

csi-rbdplugin-5jb79                          3/3     Running   0          22h
csi-rbdplugin-7dqd7                          3/3     Running   0          22h
csi-rbdplugin-8dpnb                          3/3     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-4clkc   7/7     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-lbjld   7/7     Running   0          22h
csi-rbdplugin-provisioner-66557fcc8f-vpvb2   7/7     Running   0          22h
csi-rbdplugin-txjcg                          3/3     Running   0          22h
csi-rbdplugin-x57d6                          3/3     Running   0          22h

pod-with-raw-block-volume                    1/1     Running   0          22h
应用测试扩容
1
kubectl edit pvc raw-block-pvc #`raw-block-pvc` 想要扩容的pvc，打开pvc修改容量
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
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"PersistentVolumeClaim","metadata":{"annotations":{},"name":"raw-block-pvc","namespace":"default"},"spec":{"accessModes":["ReadWriteOnce"],"resources":{"requests":{"storage":"1Gi"}},"storageClassName":"csi-rbd-sc","volumeMode":"Block"}}
    pv.kubernetes.io/bind-completed: "yes"
    pv.kubernetes.io/bound-by-controller: "yes"
    volume.beta.kubernetes.io/storage-provisioner: rbd.csi.ceph.com
  creationTimestamp: "2022-01-10T04:01:31Z"
  finalizers:
  - kubernetes.io/pvc-protection
  name: raw-block-pvc
  namespace: default
  resourceVersion: "1142767"
  uid: 18eb2ee1-3eac-4567-9d07-a449ce0ac675
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 15Gi             # 修改此处的容量保存退出即可
  storageClassName: csi-rbd-sc
  volumeMode: Block
  volumeName: pvc-18eb2ee1-3eac-4567-9d07-a449ce0ac675
status:
  accessModes:
  - ReadWriteOnce
  capacity:
    storage: 15Gi
  phase: Bound
查看pvc
1
2
3
4
5
[root@master-1 ~]# kubectl get pvc
NAME                   STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
data-csi-mysql-0       Bound    pvc-e55185b9-fa17-48ad-b125-929d7b01e5a0   5Gi        RWO            csi-rbd-sc        24m
raw-block-pvc          Bound    pvc-18eb2ee1-3eac-4567-9d07-a449ce0ac675   15Gi       RWO            csi-rbd-sc        102m
rbd-pvc-bak            Bound    pvc-6ff9dc5c-b39e-410d-909c-bdd01db765a1   1Gi        RWO            csi-rbd-sc-pv     164m

扩容完成

创建使用PVC的应用测试有状态Pod

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
vim mysql-statefulset-static.yaml 
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: csi-mysql
  namespace: default
spec:
  selector:
    matchLabels:
      app: mysql
  serviceName: mysql
  replicas: 1
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ALLOW_EMPTY_PASSWORD
          value: "1"
        - name: MYSQL_ROOT_PASSWORD
          value: "dlw123"
        ports:
        - name: mysql
          containerPort: 3306
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
     # volumes:
     # - name: data
     #   persistentVolumeClaim:
     #    claimName: csi-rbd-sc
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "csi-rbd-sc"
      resources:
        requests:
          storage: 5Gi

对于有状态服务来说，如果还是直接使用volumes，则进行动态扩容的时候会报错，所有的Pod都会使用一个相同的PVC，会产生冲突，因此需要使用VolumeClaimTemplate来创建PV。

应用测试扩容
1
kubectl edit pvc data-csi-mysql-0 #`data-csi-mysql-0` 想要扩容的pvc，打开pvc修改容量
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
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  annotations:
    pv.kubernetes.io/bind-completed: "yes"
    pv.kubernetes.io/bound-by-controller: "yes"
    volume.beta.kubernetes.io/storage-provisioner: rbd.csi.ceph.com
  creationTimestamp: "2022-01-10T05:19:37Z"
  finalizers:
  - kubernetes.io/pvc-protection
  labels:
    app: mysql-bak
  name: data-csi-mysql-0
  namespace: default
  resourceVersion: "1147968"
  uid: e55185b9-fa17-48ad-b125-929d7b01e5a0
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi             # 修改此处的容量保存退出即可
  storageClassName: csi-rbd-sc
  volumeMode: Filesystem
  volumeName: pvc-e55185b9-fa17-48ad-b125-929d7b01e5a0
status:
  accessModes:
  - ReadWriteOnce
  capacity:
    storage: 5Gi
  phase: Bound
查看扩容状态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
[root@master-1 ~]# kubectl describe pvc data-csi-mysql-0
Name:          data-csi-mysql-0
Namespace:     default
StorageClass:  csi-rbd-sc
Status:        Bound
Volume:        pvc-e55185b9-fa17-48ad-b125-929d7b01e5a0
Labels:        app=mysql-bak
Annotations:   pv.kubernetes.io/bind-completed: yes
               pv.kubernetes.io/bound-by-controller: yes
               volume.beta.kubernetes.io/storage-provisioner: rbd.csi.ceph.com
Finalizers:    [kubernetes.io/pvc-protection]
Capacity:      5Gi
Access Modes:  RWO
VolumeMode:    Filesystem
Used By:       csi-mysql-0
Conditions:
  Type                      Status  LastProbeTime                     LastTransitionTime                Reason  Message
  ----                      ------  -----------------                 ------------------                ------  -------
  FileSystemResizePending   True    Mon, 01 Jan 0001 00:00:00 +0000   Mon, 10 Jan 2022 13:52:21 +0800           Waiting for user to (re-)start a pod to finish file system resize of volume on node.
···

需要重新部署pod生效

更新pod

查看应用

1
2
kubectl get StatefulSet #有状态应用
kubectl get Deployment  #无状态应用

副本伸缩

1
2
kubectl scale StatefulSet csi-mysql --replicas 0  #副本缩容
kubectl scale StatefulSet csi-mysql --replicas 1  #副本扩容
查看扩容状态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[root@master-1 ~]# kubectl describe pvc data-csi-mysql-0
Name:          data-csi-mysql-0
Namespace:     default
StorageClass:  csi-rbd-sc
Status:        Bound
Volume:        pvc-e55185b9-fa17-48ad-b125-929d7b01e5a0
Labels:        app=mysql
Annotations:   pv.kubernetes.io/bind-completed: yes
               pv.kubernetes.io/bound-by-controller: yes
               volume.beta.kubernetes.io/storage-provisioner: rbd.csi.ceph.com
Finalizers:    [kubernetes.io/pvc-protection]
Capacity:      10Gi
Access Modes:  RWO
VolumeMode:    Filesystem
Used By:       csi-mysql-0
Events:
···
查看pvc
1
2
3
4
5
[root@master-1 ~]# kubectl get pvc
NAME                   STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
data-csi-mysql-0       Bound    pvc-e55185b9-fa17-48ad-b125-929d7b01e5a0   5Gi        RWO            csi-rbd-sc        24m
raw-block-pvc          Bound    pvc-18eb2ee1-3eac-4567-9d07-a449ce0ac675   15Gi       RWO            csi-rbd-sc        102m
rbd-pvc-bak            Bound    pvc-6ff9dc5c-b39e-410d-909c-bdd01db765a1   1Gi        RWO            csi-rbd-sc-pv     164m

扩容完成

]]> <h3 id="创建一个ceph-pool-创建存储池"><a href="#创建一个ceph-pool-创建存储池" class="headerlink" title="创建一个ceph pool 创建存储池"></a>创建一个ceph pool 创建存储池</h3><div Linux类型虚拟机磁盘扩容 https://imszz.com/p/6ca3a57f/ 2021-12-09T16:00:00.000Z 2021-12-10T12:46:25.000Z 1.1 Linux类型虚拟机磁盘扩容

步骤1 查看磁盘状态

在虚拟机操作系统内的命令行终端上再次执行“fdisk -l”，发现虚拟磁盘总共有416101个柱面，但只使用了其中的208051个柱面，未被使用的柱面就是扩容之后的磁盘，下面需要为未被使用的柱面创建分区。

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
[root@yjgltpc-cgzs-2  ~]# fdisk -l
 
Disk /dev/vda: 214.7 GB, 214748364800 bytes
16 heads, 63 sectors/track, 416101 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00091944
 
   Device Boot      Start         End      Blocks   Id  System
/dev/vda1   *           3        1018      512000   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/vda2            1018      208051   104344576   8e  Linux LVM
Partition 2 does not end on cylinder boundary.
 
Disk /dev/mapper/centos-root: 53.7 GB, 53687091200 bytes
255 heads, 63 sectors/track, 6527 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
 
 
Disk /dev/mapper/centos-swap: 4093 MB, 4093640704 bytes
255 heads, 63 sectors/track, 497 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
 
 
Disk /dev/mapper/centos-home: 49.1 GB, 49064968192 bytes
255 heads, 63 sectors/track, 5965 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
[root@yjgltpc-cgzs-2  ~]#

步骤2 创建新的分区。

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
[root@yjgltpc-cgzs-2  ~]# fdisk /dev/vda
 
WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
         switch off the mode (command 'c') and change display units to
         sectors (command 'u').
 
Command (m for help): n # 键入“n”创建新的分区
Command action
   e   extended
   p   primary partition (1-4)
e # 键入“e”创建扩展分区
Partition number (1-4): 3
First cylinder (1-416101, default 1): 208051 # 键入起始柱面从“208051”开始
Last cylinder, +cylinders or +size{K,M,G} (208051-416101, default 416101): # 直接回车
Using default value 416101
 
Command (m for help): p # 键入“p”查看分区创建情况
 
Disk /dev/vda: 214.7 GB, 214748364800 bytes
16 heads, 63 sectors/track, 416101 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00091944
 
   Device Boot      Start         End      Blocks   Id  System
/dev/vda1   *           3        1018      512000   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/vda2            1018      208051   104344576   8e  Linux LVM
Partition 2 does not end on cylinder boundary.
/dev/vda3          208051      416101   104857304    5  Extended
 
Command (m for help): n # 键入“n”创建逻辑分区
Command action
   l   logical (5 or over)
   p   primary partition (1-4)
l # 键入“l”选择逻辑分区
First cylinder (208051-416101, default 208051): # 直接回车
Using default value 208051
Last cylinder, +cylinders or +size{K,M,G} (208051-416101, default 416101):
Using default value 416101
 
Command (m for help): p # 键入“p”显示所有分区情况
 
Disk /dev/vda: 214.7 GB, 214748364800 bytes
16 heads, 63 sectors/track, 416101 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00091944
 
   Device Boot      Start         End      Blocks   Id  System
/dev/vda1   *           3        1018      512000   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/vda2            1018      208051   104344576   8e  Linux LVM
Partition 2 does not end on cylinder boundary.
/dev/vda3          208051      416101   104857304    5  Extended
/dev/vda5          208051      416101   104857272+  83  Linux
 
Command (m for help): w # 键入“w”保存分区
The partition table has been altered!
 
Calling ioctl() to re-read partition table.
 
WARNING: Re-reading the partition table failed with error 16: Device or resource busy.
The kernel still uses the old table. The new table will be used at
the next reboot or after you run partprobe(8) or kpartx(8)
Syncing disks.
[root@yjgltpc-cgzs-2 ~]#

步骤3 重新启动虚拟机操作系统之后，对逻辑分区进行格式化。

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
[root@yjgltpc-cgzs-2 ~]# mkfs.ext4 /dev/vda5 # 格式化为ext4文件系统
mke2fs 1.41.12 (17-May-2010)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
6553600 inodes, 26214318 blocks
1310715 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=4294967296
800 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
4096000, 7962624, 11239424, 20480000, 23887872
 
Writing inode tables: done                            
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
 
This filesystem will be automatically checked every 27 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@yjgltpc-cgzs-2 ~]#

步骤4 创建物理卷（PV）

1
2
3
[root@yjgltpc-cgzs-2 ~]# pvcreate /dev/vda5
  Physical volume "/dev/vda5" successfully created
[root@yjgltpc-cgzs-2 ~]#

步骤5 查看当前卷组情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@yjgltpc-cgzs-2 ~]# vgdisplay
  --- Volume group ---
  VG Name               centos
  System ID             
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  4
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                3
  Open LV               3
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               99.51 GiB
  PE Size               4.00 MiB
  Total PE              25474
  Alloc PE / Size       25474 / 99.51 GiB
  Free  PE / Size       0 / 0    # 表示没有可用的扩展空间
  VG UUID               YYbZEp-ddOk-gdIC-h0dU-seBF-Enlx-SeYIpP
   
[root@yjgltpc-cgzs-2 ~]#

步骤6 扩展卷组

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

## 再次查看卷组，发现可扩展空间为100GB。
[root@yjgltpc-cgzs-2 ~]# vgextend /dev/centos /dev/vda5
  Volume group "VolGroup" successfully extended
[root@localhost ~]# vgdisplay
  --- Volume group ---
  VG Name               centos
  System ID             
  Format                lvm2
  Metadata Areas        2
  Metadata Sequence No  5
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                3
  Open LV               3
  Max PV                0
  Cur PV                2
  Act PV                2
  VG Size               199.50 GiB
  PE Size               4.00 MiB
  Total PE              51073
  Alloc PE / Size       25474 / 99.51 GiB
  Free  PE / Size       25599 / 100.00 GiB
  VG UUID               YYbZEp-ddOk-gdIC-h0dU-seBF-Enlx-SeYIpP
   
[root@yjgltpc-cgzs-2 ~]#

步骤7 扩展根分区逻辑卷的容量。

1
2
3
4
[root@yjgltpc-cgzs-2 ~]# lvextend -l +100%FREE /dev/centos/root  # 扩展所有可用空间到根分区
  Extending logical volume lv_root to 150.00 GiB
  Logical volume lv_root successfully resized
[root@yjgltpc-cgzs-2 ~]#

步骤8 文件系统的真正扩容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#上面只是卷扩容了，下面是文件系统的真正扩容，输入以下命令：
#CentOS7下面由于使用的是XFS命令:
#xfs_growfs针对文件系统xfs
#检查数据块大小和数量

xfs_growfs info /dev/centos/root

#将XFS文件扩展到1986208

xfs_growfs /dev/centos/root -D 1986208

#自动扩展XFS文件系统到最大的可用大小

xfs_growfs /dev/centos/root

#/dev/mapper/centos-root是df -h查看到根目录的挂载点,需要扩容的挂载点

xfs_growfs /dev/centos/root

 
#CentOS6使用命令:
#使用resize2fs对挂载目录在线扩容#resize2fs针对文件系统ext2 ext3 ext4
resize2fs /dev/centos/root

步骤9 查看分区情况

1
2
3
4
5
6
7
8
#发现根分区磁盘容量从原来的“50GB”扩容到“~150GB”。
[root@yjgltpc-cgzs-2 ~]# df -h
Filesystem                    Size  Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root  148G  2.9G  138G   3% /
tmpfs                         2.0G  224K  2.0G   1% /dev/shm
/dev/vda1                     485M   39M  421M   9% /boot
/dev/mapper/VolGroup-lv_home   45G  180M   43G   1% /home
[root@yjgltpc-cgzs-2 ~]#

步骤10 磁盘可用性验证

1
2
3
4
5
6
# 从远端共享服务器拷贝一个2GB左右的文件到新建磁盘，验证磁盘的可写性。
[root@yjgltpc-cgzs-2 ~]# scp root@192.168.0.6:/vms/isos/file.iso /
root@192.168.0.6's password:
file.iso                                      100% 1997MB  48.7MB/s   00:41    
[root@yjgltpc-cgzs-2 ~]#

问题

问题1：

1
2
3
4
5
6
7
8
9
10
11
12
[root@yjgltpc-cgzs-2 log]# mkfs.ext4 /dev/vda5 
mke2fs 1.42.9 (28-Dec-2013)
Could not stat /dev/vda5  --- No such file or directory

The device apparently does not exist; did you specify it correctly?

解决方法：执行下partprobe 命令

partprobe
 

       partprobe包含在parted的rpm软件包中。partprobe可以修改kernel中分区表，使kernel重新读取分区表。 因此，使用该命令就可以创建分区并且在不重新启动机器的情况下系统能够识别这些分区。

问题2: Couldn’t create temporary archive name.

原来是根分区满了，无法创建归档名称，至少需要1M的剩余空间才能操作。 所以必须先删除一些临时文件. 首先使用如下命令，查找根分区中大于1G的文件。

占位

我的博客即将同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=y982vd2u7c9k

]]> <h2 id="1-1-Linux类型虚拟机磁盘扩容"><a href="#1-1-Linux类型虚拟机磁盘扩容" class="headerlink" title="1.1 Linux类型虚拟机磁盘扩容"></a>1.1 Linux类型虚拟机磁盘扩容</h2><h3 id="步 k8s部署nacos-nfs版本 https://imszz.com/p/98ed58c9/ 2021-04-06T06:00:25.000Z 2021-04-07T03:01:25.000Z 官方给出了两种方式去搭建集权其中一种是快速搭建方式，另一种是集群搭建方式。
但是快速搭建的劣势是数据没有持久化，可能会出现数据集丢失的问题，一个集群，做到高可用，数据放入mysql数据库，才是生产环境必须要使用的方式。
可以使用自建已有mysql

即在这个k8s集群上搭建nacos集群。

下载代码（代码中自带执行脚本的）

1
git clone https://github.com/nacos-group/nacos-k8s.git

下载之后，上传代码到可执行服务器上。
github--lena

部署 NFS

为什么要部署nfs呢？什么是nfs呢？

在高级使用中,Nacos在K8S拥有自动扩容缩容和数据持久特性,请注意如果需要使用这部分功能请使用PVC持久卷,Nacos的自动扩容缩容需要依赖持久卷,以及数据持久化也是一样,本例中使用的是NFS来使用PVC。也就是说nacos是有状态服务，需要持久化磁盘存储数据。
NFS:Network File System(NFS),网络文件系统,存储数据的硬盘。

这个nfs服务部署在哪里？

可以部署在这样一台机器上，可以和上面的k8s集群通讯，这里选择ip:61作为nfs的部署服务，你也可以选在ip:100等，只要能通就可以。

安装nfs

确认是否安装nfs

1
2
3
[root@master-01 nacos-k8s]# rpm -qa nfs-utils rpcbind
nfs-utils-1.3.0-0.68.el7.x86_64
rpcbind-0.2.0-49.el7.x86_64

我的是已经安装过的，如果没有安装，请安装

安装过程：

1
2
3
4
5
# 服务端 ip:61机器上
$ yum install -y nfs-utils rpcbind

# 客户端 其他台机器上均需要安装这个服务
$ yum install -y nfs-utils

创建共享文件夹/data/nfs和/data/mysql，当然你可以自己选择位置

1
2
3
cd /data
mkdir nfs
mkdir mysql
  • nfs:为nfs共享文件的目录
  • mysql：为mysql数据文件目录

配置 /etc/exports文件，在此文件中写入如下内容

1
2
/data/nfs *(insecure,rw,async,no_root_squash)
/data/mysql *(insecure,rw,async,no_root_squash)

配置完成后需要时期生效：

1
exportfs -r

具体含义如下：

github--lena

启动 RPC 服务

1
service rpcbind start

查看 NFS 服务项 rpc 服务器注册的端口列表

1
rpcinfo -p localhost

由于已经有其他服务，所有看到的多：

github--lena

启动 NFS 服务

1
service nfs start

查看是否加载了/etc/exports中的配置：

1
showmount -e localhost

github--lena

至此nfs部署完成

部署 NFS剩下部分

创建角色

1
kubectl create -f deploy/nfs/rbac.yaml

如果的K8S命名空间不是default,请在部署RBAC之前执行以下脚本（就不要执行上面的脚本了或者手动修改yaml文件内所属 namespace:

1
2
3
4
# Set the subject of the RBAC objects to the current namespace where the provisioner is being deployed
NS=$(kubectl config get-contexts|grep -e "^\*" |awk '{print $5}')
NAMESPACE=${NS:-default}
sed -i'' "s/namespace:.*/namespace: $NAMESPACE/g" ./deploy/nfs/rbac.yaml

创建 ServiceAccount 和部署 NFS-Client Provisioner

1
kubectl create -f deploy/nfs/deployment.yaml

内容如下：

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
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner
---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: nfs-client-provisioner
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccount: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: quay.io/external_storage/nfs-client-provisioner:latest
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: fuseim.pri/ifs
            - name: NFS_SERVER
              value: 10.1.33.61 
            - name: NFS_PATH
              value: /data/nfs
      volumes:
        - name: nfs-client-root
          nfs:
            server: 10.1.33.61
            path: /data/nfs

创建 NFS StorageClass

1
kubectl create -f deploy/nfs/class.yaml

验证NFS部署成功

1
kubectl get pod -l app=nfs-client-provisioner

github--lena

部署数据库

这个数据库就是记录nacos配置的数据库，做到持久化，就能保证安全了。

安装数据库

1
kubectl create -f deploy/mysql/mysql-nfs.yaml

代码，如下，有修改哦：

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
apiVersion: v1
kind: ReplicationController
metadata:
  name: mysql
  labels:
    name: mysql
spec:
  replicas: 1
  selector:
    name: mysql
  template:
    metadata:
      labels:
        name: mysql
    spec:
      containers:
      - name: mysql
        image: nacos/nacos-mysql:5.7 
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-data
          mountPath: /var/lib/mysql 
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "root"
        - name: MYSQL_DATABASE
          value: "nacos_config"
        - name: MYSQL_USER
          value: "nacos"
        - name: MYSQL_PASSWORD
          value: "nacos"
      volumes:
      - name: mysql-data
        nfs:
          server: 10.1.33.61 
          path: /data/mysql
---
apiVersion: v1
kind: Service
metadata:
  name: mysql
  labels:
    name: mysql
spec:
  ports:
  - port: 3306
    targetPort: 3306
  selector:
    name: mysql

验证数据库是否安装成功

1
kubectl get pod

github--lena

建表

数据库初始化语句位置

1
https://github.com/alibaba/nacos/blob/develop/distribution/conf/nacos-mysql.sql

如果库中没有这些表需要自己创建。默认是创建完成，自建数据库可以导入使用

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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info   */
/******************************************/
CREATE TABLE `config_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
  `group_id` varchar(255) DEFAULT NULL,
  `content` longtext NOT NULL COMMENT 'content',
  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  `src_user` text COMMENT 'source user',
  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
  `app_name` varchar(128) DEFAULT NULL,
  `tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
  `c_desc` varchar(256) DEFAULT NULL,
  `c_use` varchar(64) DEFAULT NULL,
  `effect` varchar(64) DEFAULT NULL,
  `type` varchar(64) DEFAULT NULL,
  `c_schema` text,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_aggr   */
/******************************************/
CREATE TABLE `config_info_aggr` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
  `group_id` varchar(255) NOT NULL COMMENT 'group_id',
  `datum_id` varchar(255) NOT NULL COMMENT 'datum_id',
  `content` longtext NOT NULL COMMENT '内容',
  `gmt_modified` datetime NOT NULL COMMENT '修改时间',
  `app_name` varchar(128) DEFAULT NULL,
  `tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='增加租户字段';


/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_beta   */
/******************************************/
CREATE TABLE `config_info_beta` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
  `content` longtext NOT NULL COMMENT 'content',
  `beta_ips` varchar(1024) DEFAULT NULL COMMENT 'betaIps',
  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  `src_user` text COMMENT 'source user',
  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
  `tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_tag   */
/******************************************/
CREATE TABLE `config_info_tag` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
  `tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
  `tag_id` varchar(128) NOT NULL COMMENT 'tag_id',
  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
  `content` longtext NOT NULL COMMENT 'content',
  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  `src_user` text COMMENT 'source user',
  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_tags_relation   */
/******************************************/
CREATE TABLE `config_tags_relation` (
  `id` bigint(20) NOT NULL COMMENT 'id',
  `tag_name` varchar(128) NOT NULL COMMENT 'tag_name',
  `tag_type` varchar(64) DEFAULT NULL COMMENT 'tag_type',
  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
  `tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
  `nid` bigint(20) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`nid`),
  UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),
  KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = group_capacity   */
/******************************************/
CREATE TABLE `group_capacity` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `group_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Group ID，空字符表示整个集群',
  `quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
  `usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
  `max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
  `max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数，，0表示使用默认值',
  `max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
  `max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_group_id` (`group_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='集群、各Group容量信息表';

/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = his_config_info   */
/******************************************/
CREATE TABLE `his_config_info` (
  `id` bigint(64) unsigned NOT NULL,
  `nid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `data_id` varchar(255) NOT NULL,
  `group_id` varchar(128) NOT NULL,
  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
  `content` longtext NOT NULL,
  `md5` varchar(32) DEFAULT NULL,
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `src_user` text,
  `src_ip` varchar(50) DEFAULT NULL,
  `op_type` char(10) DEFAULT NULL,
  `tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
  PRIMARY KEY (`nid`),
  KEY `idx_gmt_create` (`gmt_create`),
  KEY `idx_gmt_modified` (`gmt_modified`),
  KEY `idx_did` (`data_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='多租户改造';


/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = tenant_capacity   */
/******************************************/
CREATE TABLE `tenant_capacity` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `tenant_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',
  `quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
  `usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
  `max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
  `max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数',
  `max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
  `max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='租户容量信息表';


CREATE TABLE `tenant_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `kp` varchar(128) NOT NULL COMMENT 'kp',
  `tenant_id` varchar(128) default '' COMMENT 'tenant_id',
  `tenant_name` varchar(128) default '' COMMENT 'tenant_name',
  `tenant_desc` varchar(256) DEFAULT NULL COMMENT 'tenant_desc',
  `create_source` varchar(32) DEFAULT NULL COMMENT 'create_source',
  `gmt_create` bigint(20) NOT NULL COMMENT '创建时间',
  `gmt_modified` bigint(20) NOT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),
  KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';

CREATE TABLE `users` (
`username` varchar(50) NOT NULL PRIMARY KEY,
`password` varchar(500) NOT NULL,
`enabled` boolean NOT NULL
);

CREATE TABLE `roles` (
`username` varchar(50) NOT NULL,
`role` varchar(50) NOT NULL,
UNIQUE INDEX `idx_user_role` (`username` ASC, `role` ASC) USING BTREE
);

CREATE TABLE `permissions` (
    `role` varchar(50) NOT NULL,
    `resource` varchar(255) NOT NULL,
    `action` varchar(8) NOT NULL,
    UNIQUE INDEX `uk_role_permission` (`role`,`resource`,`action`) USING BTREE
);

INSERT INTO users (username, password, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);

INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');

部署Nacos

修改depoly/nacos/nacos-pvc-nfs.yaml

先给出修改后的代码：

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
---
apiVersion: v1
kind: Service
metadata:
  name: nacos-headless
  labels:
    app: nacos
  annotations:
    service.alpha.kubernetes.io/tolerate-unready-endpoints: "true"
spec:
  ports:
    - port: 8848
      name: server
      targetPort: 8848
    - port: 7848
      name: rpc
      targetPort: 7848
  clusterIP: None
  selector:
    app: nacos
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: nacos-cm
data:
  mysql.db.name: "nacos_config"
  mysql.port: "3306"
  mysql.user: "nacos"
  mysql.password: "nacos"
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: nacos
spec:
  serviceName: nacos-headless
  replicas: 3
  template:
    metadata:
      labels:
        app: nacos
      annotations:
        pod.alpha.kubernetes.io/initialized: "true"
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                      - nacos
              topologyKey: "kubernetes.io/hostname"
      serviceAccountName: nfs-client-provisioner
      initContainers:
        - name: peer-finder-plugin-install
          image: nacos/nacos-peer-finder-plugin:1.0
          imagePullPolicy: Always
          volumeMounts:
            - mountPath: "/home/nacos/plugins/peer-finder"
              name: plugindir
      containers:
        - name: nacos
          imagePullPolicy: Always
          image: nacos/nacos-server:latest 
          resources:
            requests:
              memory: "2Gi"
              cpu: "500m"
          ports:
            - containerPort: 8848
              name: client-port
            - containerPort: 7848
              name: rpc
          env:
            - name: NACOS_REPLICAS
              value: "3"
            - name: SERVICE_NAME
              value: "nacos-headless"
            - name: DOMAIN_NAME
              value: "cluster.local"
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: metadata.namespace
            - name: MYSQL_SERVICE_DB_NAME
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.db.name
            - name: MYSQL_SERVICE_PORT
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.port
            - name: MYSQL_SERVICE_USER
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.user
            - name: MYSQL_SERVICE_PASSWORD
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.password
            - name: NACOS_SERVER_PORT
              value: "8848"
            - name: NACOS_APPLICATION_PORT
              value: "8848"
            - name: PREFER_HOST_MODE
              value: "hostname"
          volumeMounts:
            - name: plugindir
              mountPath: /home/nacos/plugins/peer-finder
            - name: datadir
              mountPath: /home/nacos/data
            - name: logdir
              mountPath: /home/nacos/logs
  volumeClaimTemplates:
    - metadata:
        name: plugindir
        annotations:
          volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"
      spec:
        accessModes: [ "ReadWriteMany" ]
        resources:
          requests:
            storage: 5Gi
    - metadata:
        name: datadir
        annotations:
          volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"
      spec:
        accessModes: [ "ReadWriteMany" ]
        resources:
          requests:
            storage: 5Gi
    - metadata:
        name: logdir
        annotations:
          volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"
      spec:
        accessModes: [ "ReadWriteMany" ]
        resources:
          requests:
            storage: 5Gi
  selector:
    matchLabels:
      app: nacos

创建nacos

1
kubectl create -f nacos-k8s/deploy/nacos/nacos-pvc-nfs.yaml

验证Nacos节点启动成功

1
kubectl get pod -l app=nacos

github--lena

页面访问

查看nacos服务对外暴露的端口

1
kubectl get svc -o wide

github--lena

为nacos创建ingres代理

nacos-ingress.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: nacos-ingress
spec:
  rules:
  - host: www.nacos.com 
    http:
      paths:
      - path: /nacos
        backend:
          serviceName: nacos-headless 
          servicePort: 8848

执行下面命令就可以执行成功了

1
2
kubectl apply -f nacos-ingress.yaml

如果需要刪除后重建则特别注意

pv删除

通过k8s 图形界面存储中删除，删除后红色中横线，并没有删除！

使用命令查看是否删除完成

1
kubectl get pv

使用命令删除重新创建即可

1
2
3
4
5
6
7
8
9
10
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'
kubectl patch pv pvc-122b45c0-78fb-4185-9a29-4b2f023ba25e  -p '{"metadata":{"finalizers":null}}'

创建的过程

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
1.先删除
kubectl delete  -f deploy/nfs/class.yaml

2.创建
kubectl create  -f deploy/nfs/class.yaml

3. 删除ServiceAccount 和部署 NFS-Client Provisioner
kubectl delete -f deploy/nfs/deployment.yaml

4. 创建ServiceAccount 和部署 NFS-Client Provisioner
kubectl create -f deploy/nfs/deployment.yaml

5. 验证NFS部署成功 
kubectl get pod -l app=nfs-client-provisioner

6. 删除数据库
kubectl delete -f deploy/mysql/mysql-nfs.yaml

7.安装数据库
kubectl create -f deploy/mysql/mysql-nfs.yaml

8. 验证是否成功
kubectl get pod

9. 建表
进入shell创建

10.删除nacos集群
kubectl delete -f deploy/nacos/nacos-pvc-nfs.yaml

11.创建nacos集群
kubectl create -f deploy/nacos/nacos-pvc-nfs.yaml

参考：https://blog.csdn.net/fsjwin/article/details/110503029
https://nacos.io/zh-cn/docs/use-nacos-with-kubernetes.html

]]> <p>官方给出了两种方式去搭建集权其中一种是快速搭建方式，另一种是集群搭建方式。<br>但是快速搭建的劣势是数据没有持久化，可能会出现数据集丢失的问题，一个集群，做到高可用，数据放入mysql数据库，才是生产环境必须要使用的方式。<br>可以使用自建已有mysql</p> <p> K8S 部署 Statefulset mysql https://imszz.com/p/25e4d739/ 2021-04-01T06:00:25.000Z 2021-04-06T06:01:25.000Z Statefulset MySQL

此例是多副本的 MySQL 数据库。
示例应用的拓扑结构有一个主服务器和多个副本，使用异步的基于行（Row-Based）的数据复制。

说明： 这不是生产环境下配置。 尤其注意，MySQL 设置都使用的是不安全的默认值，这是因为我们想把重点放在 Kubernetes 中运行有状态应用程序的一般模式上。

创建存储卷

集群需要用到存储，准备持久卷（PersistentVolume，简称PV），我这里以yaml文件创建3个PV。如后续伸缩需要更新PersistentVolume 配置

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
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-my1
  labels:
    type: mysql
spec:
  capacity:
    storage: 20Gi
  storageClassName: mysql
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/mysql"
  persistentVolumeReclaimPolicy: Retain
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-my2
  labels:
    type: mysql
spec:
  capacity:
    storage: 20Gi
  storageClassName: mysql
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/mysql"
  persistentVolumeReclaimPolicy: Retain
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-my3
  labels:
    type: mysql
spec:
  capacity:
    storage: 20Gi
  storageClassName: mysql
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/mysql"
  persistentVolumeReclaimPolicy: Retain

部署及存储卷状态查询

注意：如果是使用云服务提供的云盘，注意购买云盘要与node节点使用区一致， 还要注意 node 类型支持那些云盘类型

这里发现pv和pvc还没有绑定状态是Available

1
kubectl apply -f persistent-volume.yaml
1
kubectl get pv

部署 MySQL

MySQL 示例部署包含一个 ConfigMap、两个 Service 与一个 StatefulSet。

ConfigMap

使用以下的 YAML 配置文件创建 ConfigMap ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
apiVersion: v1
kind: ConfigMap
metadata:
  name: mysql
  labels:
    app: mysql
data:
  master.cnf: |
    # Apply this config only on the master.
    [mysqld]
    log-bin    
  slave.cnf: |
    # Apply this config only on slaves.
    [mysqld]
    super-read-only    
1
kubectl apply -f mysql-configmap.yaml

这个 ConfigMap 提供 my.cnf 覆盖设置，使你可以独立控制 MySQL 主服务器和从服务器的配置。在这里，你希望主服务器能够将复制日志提供给副本服务器，并且希望副本服务器拒绝任何不是通过复制进行的写操作。

ConfigMap 本身没有什么特别之处，因而也不会出现不同部分应用于不同的 Pod 的情况。每个 Pod 都会在初始化时基于 StatefulSet 控制器提供的信息决定要查看的部分。

服务

使用以下 YAML 配置文件创建服务：

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
# Headless service for stable DNS entries of StatefulSet members.
apiVersion: v1
kind: Service
metadata:
  name: mysql
  labels:
    app: mysql
spec:
  ports:
  - name: mysql
    port: 3306
  clusterIP: None
  selector:
    app: mysql
---
# Client service for connecting to any MySQL instance for reads.
# For writes, you must instead connect to the master: mysql-0.mysql.
apiVersion: v1
kind: Service
metadata:
  name: mysql-read
  labels:
    app: mysql
spec:
  ports:
  - name: mysql
    port: 3306
  selector:
    app: mysql
1
kubectl apply -f mysql-services.yaml

这个无头服务给 StatefulSet 控制器为集合中每个 Pod 创建的 DNS 条目提供了一个宿主。因为服务名为 mysql，所以可以通过在同一 Kubernetes 集群和名字中的任何其他 Pod 内解析 <Pod 名称>.mysql 来访问 Pod。

客户端服务称为 mysql-read，是一种常规服务，具有其自己的集群 IP。该集群 IP 在报告就绪的所有MySQL Pod 之间分配连接。可能的端点集合包括 MySQL 主节点和所有副本节点。

请注意，只有读查询才能使用负载平衡的客户端服务。因为只有一个 MySQL 主服务器，所以客户端应直接连接到 MySQL 主服务器 Pod（通过其在无头服务中的 DNS 条目）以执行写入操作。

StatefulSet

最后，使用以下 YAML 配置文件创建 StatefulSet：

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
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  serviceName: mysql
  replicas: 3
  template:
    metadata:
      labels:
        app: mysql
    spec:
      initContainers:
      - name: init-mysql
        image: mysql:5.7
        command:
        - bash
        - "-c"
        - |
          set -ex
          # Generate mysql server-id from pod ordinal index.
          [[ `hostname` =~ -([0-9]+)$ ]] || exit 1
          ordinal=${BASH_REMATCH[1]}
          echo [mysqld] > /mnt/conf.d/server-id.cnf
          # Add an offset to avoid reserved server-id=0 value.
          echo server-id=$((100 + $ordinal)) >> /mnt/conf.d/server-id.cnf
          # Copy appropriate conf.d files from config-map to emptyDir.
          if [[ $ordinal -eq 0 ]]; then
            cp /mnt/config-map/master.cnf /mnt/conf.d/
          else
            cp /mnt/config-map/slave.cnf /mnt/conf.d/
          fi          
        volumeMounts:
        - name: conf
          mountPath: /mnt/conf.d
        - name: config-map
          mountPath: /mnt/config-map
      - name: clone-mysql
        image: ist0ne/xtrabackup:1.0
        command:
        - bash
        - "-c"
        - |
          set -ex
          # Skip the clone if data already exists.
          [[ -d /var/lib/mysql/mysql ]] && exit 0
          # Skip the clone on master (ordinal index 0).
          [[ `hostname` =~ -([0-9]+)$ ]] || exit 1
          ordinal=${BASH_REMATCH[1]}
          [[ $ordinal -eq 0 ]] && exit 0
          # Clone data from previous peer.
          ncat --recv-only mysql-$(($ordinal-1)).mysql 3307 | xbstream -x -C /var/lib/mysql
          # Prepare the backup.
          xtrabackup --prepare --target-dir=/var/lib/mysql          
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ALLOW_EMPTY_PASSWORD
          value: "1"
        ports:
        - name: mysql
          containerPort: 3306
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
        livenessProbe:
          exec:
            command: ["mysqladmin", "ping"]
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
        readinessProbe:
          exec:
            # Check we can execute queries over TCP (skip-networking is off).
            command: ["mysql", "-h", "127.0.0.1", "-e", "SELECT 1"]
          initialDelaySeconds: 5
          periodSeconds: 2
          timeoutSeconds: 1
      - name: xtrabackup
        image: ist0ne/xtrabackup:1.0
        ports:
        - name: xtrabackup
          containerPort: 3307
        command:
        - bash
        - "-c"
        - |
          set -ex
          cd /var/lib/mysql

          # Determine binlog position of cloned data, if any.
          if [[ -f xtrabackup_slave_info && "x$(<xtrabackup_slave_info)" != "x" ]]; then
            # XtraBackup already generated a partial "CHANGE MASTER TO" query
            # because we're cloning from an existing slave. (Need to remove the tailing semicolon!)
            cat xtrabackup_slave_info | sed -E 's/;$//g' > change_master_to.sql.in
            # Ignore xtrabackup_binlog_info in this case (it's useless).
            rm -f xtrabackup_slave_info xtrabackup_binlog_info
          elif [[ -f xtrabackup_binlog_info ]]; then
            # We're cloning directly from master. Parse binlog position.
            [[ `cat xtrabackup_binlog_info` =~ ^(.*?)[[:space:]]+(.*?)$ ]] || exit 1
            rm -f xtrabackup_binlog_info xtrabackup_slave_info
            echo "CHANGE MASTER TO MASTER_LOG_FILE='${BASH_REMATCH[1]}',\
                  MASTER_LOG_POS=${BASH_REMATCH[2]}" > change_master_to.sql.in
          fi

          # Check if we need to complete a clone by starting replication.
          if [[ -f change_master_to.sql.in ]]; then
            echo "Waiting for mysqld to be ready (accepting connections)"
            until mysql -h 127.0.0.1 -e "SELECT 1"; do sleep 1; done

            echo "Initializing replication from clone position"
            mysql -h 127.0.0.1 \
                  -e "$(<change_master_to.sql.in), \
                          MASTER_HOST='mysql-0.mysql', \
                          MASTER_USER='root', \
                          MASTER_PASSWORD='', \
                          MASTER_CONNECT_RETRY=10; \
                        START SLAVE;" || exit 1
            # In case of container restart, attempt this at-most-once.
            mv change_master_to.sql.in change_master_to.sql.orig
          fi

          # Start a server to send backups when requested by peers.
          exec ncat --listen --keep-open --send-only --max-conns=1 3307 -c \
            "xtrabackup --backup --slave-info --stream=xbstream --host=127.0.0.1 --user=root"          
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
      volumes:
      - name: conf
        emptyDir: {}
      - name: config-map
        configMap:
          name: mysql
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      storageClassName: mysql
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 20Gi
1
kubectl apply -f mysql-statefulset.yaml

你可以通过运行以下命令查看启动进度：

1
kubectl get pods -l app=mysql --watch

一段时间后，你应该看到所有 3 个 Pod 进入 Running 状态：

1
2
3
4
NAME      READY     STATUS    RESTARTS   AGE
mysql-0   2/2       Running   0          2m
mysql-1   2/2       Running   0          1m
mysql-2   2/2       Running   0          1m

输入 Ctrl+C 结束 watch 操作。如果你看不到任何进度，确保已启用 动态 PersistentVolume 预配器。

了解有状态的 Pod 初始化

StatefulSet 控制器按序数索引顺序地每次启动一个 Pod。它一直等到每个 Pod 报告就绪才再启动下一个 Pod。

此外，控制器为每个 Pod 分配一个唯一、稳定的名称，形如 <statefulset 名称>-<序数索引>其结果是 Pods 名为 mysql-0、mysql-1 和 mysql-2。

上述 StatefulSet 清单中的 Pod 模板利用这些属性来执行 MySQL 副本的有序启动。

生成配置

在启动 Pod 规约中的任何容器之前，Pod 首先按顺序运行所有的 Init 容器

第一个名为 init-mysql 的 Init 容器根据序号索引生成特殊的 MySQL 配置文件。

该脚本通过从 Pod 名称的末尾提取索引来确定自己的序号索引，而 Pod 名称由 hostname 命令返回。然后将序数（带有数字偏移量以避免保留值）保存到 MySQL conf.d 目录中的文件 server-id.cnf。这一操作将 StatefulSet 所提供的唯一、稳定的标识转换为 MySQL 服务器的 ID，
而这些 ID 也是需要唯一性、稳定性保证的。

通过将内容复制到 conf.d 中，init-mysql 容器中的脚本也可以应用 ConfigMap 中的 primary.cnf 或 replica.cnf。由于示例部署结构由单个 MySQL 主节点和任意数量的副本节点组成，因此脚本仅将序数 0 指定为主节点，而将其他所有节点指定为副本节点。

与 StatefulSet 控制器的 部署顺序保证相结合，可以确保 MySQL 主服务器在创建副本服务器之前已准备就绪，以便它们可以开始复制。

克隆现有数据

通常，当新 Pod 作为副本节点加入集合时，必须假定 MySQL 主节点可能已经有数据。还必须假设复制日志可能不会一直追溯到时间的开始。

这些保守的假设是允许正在运行的 StatefulSet 随时间扩大和缩小而不是固定在其初始大小的关键。

第二个名为 clone-mysql 的 Init 容器，第一次在带有空 PersistentVolume 的副本 Pod上启动时，会在从属 Pod 上执行克隆操作。
这意味着它将从另一个运行中的 Pod 复制所有现有数据，使此其本地状态足够一致，从而可以开始从主服务器复制。

MySQL 本身不提供执行此操作的机制，因此本示例使用了一种流行的开源工具 Percona XtraBackup。在克隆期间，源 MySQL 服务器性能可能会受到影响。为了最大程度地减少对 MySQL 主服务器的影响，该脚本指示每个 Pod 从序号较低的 Pod 中克隆。可以这样做的原因是 StatefulSet 控制器始终确保在启动 Pod N + 1 之前 Pod N 已准备就绪。

开始复制

Init 容器成功完成后，应用容器将运行。MySQL Pod 由运行实际 mysqld 服务的 mysql 容器和充当的 xtrabackup 容器组成。

xtrabackup sidecar 容器查看克隆的数据文件，并确定是否有必要在副本服务器上初始化 MySQL 复制。如果是这样，它将等待 mysqld 准备就绪，然后使用从 XtraBackup 克隆文件中提取的复制参数执行 CHANGE MASTER TO 和 START SLAVE 命令。

一旦副本服务器开始复制后，它会记住其 MySQL 主服务器，并且如果服务器重新启动或连接中断也会自动重新连接。另外，因为副本服务器会以其稳定的 DNS 名称查找主服务器（mysql-0.mysql），即使由于重新调度而获得新的 Pod IP，它们也会自动找到主服务器。

最后，开始复制后，xtrabackup 容器监听来自其他 Pod 的连接，处理其数据克隆请求。如果 StatefulSet 扩大规模，或者下一个 Pod 失去其 PersistentVolumeClaim 并需要重新克隆，则此服务器将无限期保持运行。

发送客户端请求

你可以通过运行带有 mysql:5.7 镜像的临时容器并运行 mysql 客户端二进制文件，将测试查询发送到 MySQL 主服务器（主机名 mysql-0.mysql）。

1
2
3
4
5
6
7
8
9
#进入主内部
kubectl exec -it mysql-0  -n <namespace>  -- /bin/sh

#执行或者单独另启动一个客户端执行
mysql -h mysql-0.mysql <<EOF
CREATE DATABASE test;
CREATE TABLE test.messages (message VARCHAR(250));
INSERT INTO test.messages VALUES ('hello');
EOF

使用主机名 mysql-read 将测试查询发送到任何报告为就绪的服务器：

1
2
3
4
5
#进入主内部
kubectl exec -it mysql-0  -n <namespace>  -- /bin/sh

#执行或者单独另启动一个客户端执行
mysql -h mysql-read -e "SELECT * FROM test.messages"

你应该获得如下输出：

1
2
3
4
5
+---------+
| message |
+---------+
| hello   |
+---------+

为了演示 mysql-read 服务在服务器之间分配连接，你可以在循环中运行 SELECT @@server_id：

1
2
3
4
5
#进入主内部
kubectl exec -it mysql-0  -n <namespace>  -- /bin/sh

#执行或者单独另启动一个客户端执行
bash -ic "while sleep 1; do mysql -h mysql-read -e 'SELECT @@server_id,NOW()'; done"

你应该看到报告的 @@server_id 发生随机变化，因为每次尝试连接时都可能选择了不同的端点：

1
2
3
4
5
6
7
8
9
10
11
#如果进入的主执行则结果显示ID`102`与`101`｜另客户端执行 则多显示ID`100`，因为主默认ID`100`
+-------------+---------------------+
| @@server_id | NOW()               |
+-------------+---------------------+
|         102 | 2006-01-02 15:04:06 |
+-------------+---------------------+
+-------------+---------------------+
| @@server_id | NOW()               |
+-------------+---------------------+
|         101 | 2006-01-02 15:04:07 |
+-------------+---------------------+

要停止循环时可以按 Ctrl+C ，但是让它在另一个窗口中运行非常有用，这样你就可以看到以下步骤的效果。

模拟 Pod 和 Node 的宕机时间

为了证明从副本节点缓存而不是单个服务器读取数据的可用性提高，请在使 Pod 退出 Ready状态时，保持上述 SELECT @@server_id 循环一直运行。

破坏就绪态探测

mysql 容器的运行命令 mysql -h 127.0.0.1 -e 'SELECT 1'，以确保服务器已启动并能够执行查询。

迫使就绪态探测失败的一种方法就是中止该命令：

1
kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql /usr/bin/mysql.off

此命令会进入 Pod mysql-2 的实际容器文件系统，重命名 mysql 命令，导致就绪态探测无法找到它。几秒钟后， Pod 会报告其中一个容器未就绪。你可以通过运行以下命令进行检查：

1
kubectl get pod mysql-2

在 READY 列中查找 1/2 ：

1
2
NAME      READY     STATUS    RESTARTS   AGE
mysql-2   1/2       Running   0          3m

此时，你应该会看到 SELECT @@server_id 循环继续运行，尽管它不再报告 102。回想一下，init-mysql 脚本将 server-id 定义为 100 + $ordinal，因此服务器 ID 102 对应于 Pod mysql-2。

现在修复 Pod，几秒钟后它应该重新出现在循环输出中：

1
kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql.off /usr/bin/mysql

删除 Pods

如果删除了 Pod，则 StatefulSet 还会重新创建 Pod，类似于 ReplicaSet 对无状态 Pod 所做的操作。

1
kubectl delete pod mysql-2

StatefulSet 控制器注意到不再存在 mysql-2 Pod，于是创建一个具有相同名称并链接到相同PersistentVolumeClaim 的新 Pod。你应该看到服务器 ID 102 从循环输出中消失了一段时间，然后又自行出现。

腾空节点

如果你的 Kubernetes 其中一个节点 设置不可调度，则可以通过发出以下命令来模拟节点停机（就好像节点在被升级）。

首先确定 MySQL Pod 之一在哪个节点上：

1
kubectl get pod mysql-2 -o wide

节点名称应显示在最后一列中：

1
2
NAME      READY     STATUS    RESTARTS   AGE       IP            NODE
mysql-2   2/2       Running   0          15m       10.244.5.27   kubernetes-node-9l2t

然后通过运行以下命令腾空节点，该命令将其保护起来，以使新的 Pod 不能调度到该节点，然后逐出所有现有的 Pod。将 <节点名称> 替换为在上一步中找到的节点名称。

这可能会影响节点上的其他应用程序，因此最好 仅在测试集群中执行此操作

1
kubectl drain <节点名称> --force --delete-local-data --ignore-daemonsets

现在，你可以看到 Pod 被重新调度到其他节点上：

1
kubectl get pod mysql-2 -o wide --watch

它看起来应该像这样：

1
2
3
4
5
6
7
8
9
NAME      READY   STATUS          RESTARTS   AGE       IP            NODE
mysql-2   2/2     Terminating     0          15m       10.244.1.56   kubernetes-node-9l2t
[...]
mysql-2   0/2     Pending         0          0s        <none>        kubernetes-node-fjlm
mysql-2   0/2     Init:0/2        0          0s        <none>        kubernetes-node-fjlm
mysql-2   0/2     Init:1/2        0          20s       10.244.5.32   kubernetes-node-fjlm
mysql-2   0/2     PodInitializing 0          21s       10.244.5.32   kubernetes-node-fjlm
mysql-2   1/2     Running         0          22s       10.244.5.32   kubernetes-node-fjlm
mysql-2   2/2     Running         0          30s       10.244.5.32   kubernetes-node-fjlm

再次，你应该看到服务器 ID 102 从 SELECT @@server_id 循环输出中消失一段时间，然后自行出现。

现在去掉节点保护（Uncordon），使其恢复为正常模式:

1
kubectl uncordon <节点名称>

扩展副本节点数量

使用 MySQL 复制，你可以通过添加副本节点来扩展读取查询的能力。使用 StatefulSet，你可以使用单个命令执行此操作：

注意：要有满足伸缩的 PersistentVolume 配置

1
kubectl scale statefulset mysql --replicas=5

查看新的 Pod 的运行情况：

1
kubectl get pods -l app=mysql --watch

一旦 Pod 启动，你应该看到服务器 IDs 103 和 104 开始出现在 SELECT @@server_id 循环输出中。

你还可以验证这些新服务器在存在之前已添加了数据：

1
2
3
4
5
#进入主内部
kubectl exec -it mysql-0  -n <namespace>  -- /bin/sh

#执行或者单独另启动一个客户端执行
mysql -h mysql-3.mysql -e "SELECT * FROM test.messages"
1
2
3
4
5
+---------+
| message |
+---------+
| hello   |
+---------+

向下缩容操作也是很平滑的：

1
kubectl scale statefulset mysql --replicas=3

但是请注意，按比例扩大会自动创建新的 PersistentVolumeClaims，而按比例缩小不会自动删除这些 PVC。这使你可以选择保留那些初始化的 PVC，以更快地进行缩放，或者在删除它们之前提取数据。

你可以通过运行以下命令查看此信息：

1
kubectl get pvc -l app=mysql

这表明，尽管将 StatefulSet 缩小为3，所有5个 PVC 仍然存在：

1
2
3
4
5
6
NAME           STATUS    VOLUME                                     CAPACITY   ACCESSMODES   AGE
data-mysql-0   Bound     pvc-8acbf5dc-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-1   Bound     pvc-8ad39820-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-2   Bound     pvc-8ad69a6d-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-3   Bound     pvc-50043c45-b1c5-11e6-93fa-42010a800002   10Gi       RWO           2m
data-mysql-4   Bound     pvc-500a9957-b1c5-11e6-93fa-42010a800002   10Gi       RWO           2m

如果你不打算重复使用多余的 PVC，则可以删除它们：

1
2
kubectl delete pvc data-mysql-3
kubectl delete pvc data-mysql-4

  1. 通过在终端上按 Ctrl+C 取消 SELECT @@server_id 循环，或从另一个终端运行以下命令：

    1
    kubectl delete pod mysql-client-loop --now

  2. 删除 StatefulSet。这也会开始终止 Pod。

    1
    kubectl delete statefulset mysql

  3. 验证 Pod 消失。他们可能需要一些时间才能完成终止。

    1
    kubectl get pods -l app=mysql

    当上述命令返回如下内容时，你就知道 Pod 已终止：

    1
    No resources found.

  4. 删除 ConfigMap、Services 和 PersistentVolumeClaims。

    1
    kubectl delete configmap,service,pvc -l app=mysql

  5. 如果你手动供应 PersistentVolume，则还需要手动删除它们，并释放下层资源。如果你使用了动态预配器，当得知你删除 PersistentVolumeClaims 时，它将自动删除 PersistentVolumes。一些动态预配器（例如用于 EBS 和 PD 的预配器）也会在删除 PersistentVolumes 时释放下层资源。

详细参考：https://kubernetes.io/zh/docs/tasks/run-application/run-replicated-stateful-application/
https://kubernetes.io/zh/docs/concepts/storage/persistent-volumes/

]]> <h2 id="Statefulset-MySQL"><a href="#Statefulset-MySQL" class="headerlink" title="Statefulset MySQL"></a>Statefulset MySQL</h2><p>此例是多副本的 My K8S基于ingress-nginx实现灰度发布 https://imszz.com/p/a6d2532/ 2021-03-30T06:00:25.000Z 2021-03-30T07:41:25.000Z 注解说明

通过给 Ingress 资源指定 Nginx Ingress 所支持的 annotation 可实现金丝雀发布。需给服务创建2个 Ingress，其中1个常规 Ingress，另1个为nginx.ingress.kubernetes.io/canary: "true"· 固定的 annotation 的 Ingress，称为 Canary Ingress。Canary Ingress 一般代表新版本的服务，结合另外针对流量切分策略的 annotation 一起配置即可实现多种场景的金丝雀发布。以下为相关 annotation 的详细介绍：

  • nginx.ingress.kubernetes.io/canary-by-header
    表示如果请求头中包含指定的 header 名称，并且值为 always，就将该请求转发给该 Ingress 定义的对应后端服务。如果值为 never 则不转发，可以用于回滚到旧版。如果为其他值则忽略该 annotation。
  • nginx.ingress.kubernetes.io/canary-by-header-value
    该 annotation 可以作为 canary-by-header 的补充，可指定请求头为自定义值，包含但不限于 always 或 never。当请求头的值命中指定的自定义值时，请求将会转发给该 Ingress 定义的对应后端服务，如果是其它值则忽略该 annotation。
  • nginx.ingress.kubernetes.io/canary-by-header-pattern
    与 canary-by-header-value 类似，区别为该 annotation 用正则表达式匹配请求头的值，而不是只固定某一个值。如果该 annotation 与 canary-by-header-value 同时存在，该 annotation 将被忽略。
  • nginx.ingress.kubernetes.io/canary-by-cookie
    与 canary-by-header 类似，该 annotation 用于 cookie，仅支持 always 和 never。
  • nginx.ingress.kubernetes.io/canary-weight
    表示 Canary Ingress 所分配流量的比例的百分比，取值范围 [0-100]。例如，设置为10，则表示分配10%的流量给 Canary Ingress 对应的后端服务。

说明：
以上规则会按优先顺序进行评估，优先顺序为： canary-by-header -> canary-by-cookie -> canary-weight。
当 Ingress 被标记为 Canary Ingress 时，除了 nginx.ingress.kubernetes.io/load-balance 和 nginx.ingress.kubernetes.io/upstream-hash-by 外，所有其他非 Canary 注释都将被忽略。

可以把以上的四个 annotation 分为三类：

  1. 基于Request Header的流量切分，适用于灰度发布以及AB测试场景
  2. 基于Cookie的流量切分，适用于灰度发布以及AB测试场景
  3. 基于服务权重的流量切分，适用于蓝绿发布场景

总体划分为以下两大类：

  1. 基于权重的 Canary 规则
    github--lena

  2. 基于用户请求的 Canary 规则
    github--lena

注意： Ingress-Nginx 实在0.21.0 版本 中，引入的Canary 功能，因此要确保ingress版本OK

部署正式版本服务

首先创建一个 deployment 代表正式版本的服务，编写 yaml 内容如下：

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
---
apiVersion: v1
kind: Namespace
metadata:
  name: ns-myapp
  labels:
    name: ns-myapp

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: production
  namespace: ns-myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: production
  template:
    metadata:
      labels:
        app: production
    spec:
      containers:
      - name: production
        image: mirrorgooglecontainers/echoserver:1.10
        ports:
        - containerPort: 8080
        env:
          - name: NODE_NAME
            valueFrom:
              fieldRef:
                fieldPath: spec.nodeName
          - name: POD_NAME
            valueFrom:
              fieldRef:
                fieldPath: metadata.name
          - name: POD_NAMESPACE
            valueFrom:
              fieldRef:
                fieldPath: metadata.namespace
          - name: POD_IP
            valueFrom:
              fieldRef:
                fieldPath: status.podIP
---
apiVersion: v1
kind: Service
metadata:
  name: production
  namespace: ns-myapp
  labels:
    app: production
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
    name: http
  selector:
    app: production

为这个服务创建 Ingress 路由规则，yaml 文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: production
  namespace: ns-myapp
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: ingress.test.com
    http:
      paths:
      - backend:
          serviceName: production
          servicePort: 80

应用以上 yaml 文件，创建完成后在 k8s 中查看到如下信息：

1
2
3
4
5
6
7
[k8s-master ~]# kubectl get ingress -n ns-myapp
NAME         CLASS    HOSTS              ADDRESS        PORTS   AGE
production   <none>   ingress.test.com   10.16.13.201   80      4m25s

[k8s-master ~]# kubectl get pod -n ns-myapp
NAME                          READY   STATUS    RESTARTS   AGE
production-5698c4565c-jmjn5   1/1     Running   0          7m11s

此时在命令行中访问 ingress.test.com 可以看到如下内容：

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
# curl ingress.test.com

Hostname: production-5698c4565c-jmjn5

Pod Information:
    node name:  dumlog013201
    pod name:   production-5698c4565c-jmjn5
    pod namespace:  ns-myapp
    pod IP: 10.42.0.74

Server values:
    server_version=nginx: 1.13.3 - lua: 10008

Request Information:
    client_address=10.16.13.201
    method=GET
    real path=/
    query=
    request_version=1.1
    request_scheme=http
    request_uri=http://ingress.test.com:8080/

Request Headers:
    accept=*/*
    host=ingress.test.com
    user-agent=curl/7.64.1
    x-forwarded-for=10.2.130.18
    x-forwarded-host=ingress.test.com
    x-forwarded-port=80
    x-forwarded-proto=http
    x-real-ip=10.2.130.18
    x-request-id=3019362be59228ee2284f5737fa39eb1
    x-scheme=http

Request Body:
    -no body in request-

部署 Canary 版本服务

接下来创建一个 Canary 版本的服务，用于作为灰度测试。

参考将上述 Production 版本的 production.yaml 文件，再创建一个 Canary 版本的应用，包括一个 Canary 版本的 deployment 和 service (为方便快速演示，仅需将 production.yaml 的 deployment和 service 中的关键字 production 直接替换为 canary，实际场景中可能涉及业务代码变更)。

基于权重的 Canary 规则测试

基于权重的流量切分的典型应用场景就是蓝绿部署，可通过将权重设置为 0 或 100 来实现。例如，可将 Green 版本设置为主要部分，并将 Blue 版本的入口配置为 Canary。最初，将权重设置为 0，因此不会将流量代理到 Blue 版本。一旦新版本测试和验证都成功后，即可将 Blue 版本的权重设置为 100，即所有流量从 Green 版本转向 Blue。

使用以下 canary.ingress 的 yaml 文件再创建一个基于权重的 Canary 版本的应用路由 (Ingress)。

注意：要开启灰度发布机制，首先需设置 nginx.ingress.kubernetes.io/canary: "true" 启用 Canary，以下 Ingress 示例的 Canary 版本使用了基于权重进行流量切分的 annotation 规则，将分配 30% 的流量请求发送至 Canary 版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: canary
  namespace: ns-myapp
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-weight: "30"
spec:
  rules:
  - host: ingress.test.com
    http:
      paths:
      - backend:
          serviceName: canary
          servicePort: 80

接下来在命令行中使用如下命令访问域名 ingress.test.com 100次，计算每个版本分配流量的占比：

1
c=0;p=0;for i in $(seq 100); do result=$(curl -s ingress.test.com | grep  Hostname | awk -F: '{print $2}'); [[ ${result} =~ ^[[:space:]]canary ]] && let c++ || let p++; done;echo "production:${p}; canary:${c};"

可以得到如下结果：

1
production:73; canary:28;

注意这里权重不是一个精确的百分比，使用过程当中，只是会看到一个近似分布。

基于用户请求的 Canary 规则测试

基于 Resquest Header

基于 Request Header 进行流量切分的典型应用场景即灰度发布或 A/B 测试场景。

给 Canary 版本的 Ingress 新增一条 annotation ：nginx.ingress.kubernetes.io/canary-by-header: canary（这里的 annotation 的 value 可以是任意值），使当前的 Ingress 实现基于 Request Header 进行流量切分。

将 Canary 版本 Ingress 的 yaml 文件修改为如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: canary
  namespace: ns-myapp
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-weight: "30"
    nginx.ingress.kubernetes.io/canary-by-header: "canary"
spec:
  rules:
  - host: ingress.test.com
    http:
      paths:
      - backend:
          serviceName: canary
          servicePort: 80

说明：金丝雀规则按优先顺序 canary-by-header - > canary-by-cookie - > canary-weight 进行如下排序，因此上面的 ingress 将忽略原有 canary-weight 的规则。

由于上面的 ingress 规则中没有对 canary-by-header: canary 提供具体的值，也就是 nginx.ingress.kubernetes.io/canary-by-header-value 规则，所以在访问的时候，只可以为 canary 赋值 never 或 always，当 header 信息为 canary:never 时，请求将不会发送到 canary 版本；当 header 信息为 canary:always 时，请求将会一直发送到 canary 版本。示例如下：

1
2
[k8s-master ~ ]# curl -s -H "canary:never" ingress.test.com | grep Hostname
Hostname: production-5698c4565c-jmjn5
1
2
[k8s-master ~ ]# curl -s -H "canary:always" ingress.test.com | grep Hostname
Hostname: canary-79c899d85-992nw

也可以在上一个 annotation （即 canary-by-header）的基础上添加一条 nginx.ingress.kubernetes.io/canary-by-header-value: user-value 。用于通知 Ingress 将匹配到的请求路由到 Canary Ingress 中指定的服务。

将 Canary 版本 Ingress 的 yaml 文件修改为如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: canary
  namespace: ns-myapp
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-weight: "30"
    nginx.ingress.kubernetes.io/canary-by-header: "canary"
    nginx.ingress.kubernetes.io/canary-by-header-value: "true"
spec:
  rules:
  - host: ingress.test.com
    http:
      paths:
      - backend:
          serviceName: canary
          servicePort: 80

上面的 ingress 规则设置了 header 信息为 canary:true，也就是只有满足这个 header 值时才会路由到 canary 版本。示例如下：

1
2
3
4
5
6
[k8s-master ~ ]# curl -s ingress.test.com | grep Hostname
Hostname: production-5698c4565c-jmjn5


[k8s-master ~ ]# curl -s -H "canary:test" ingress.test.com | grep Hostname
Hostname: production-5698c4565c-jmjn5
1
2
[k8s-master ~ ]# curl -s -H "canary:true" ingress.test.com | grep Hostname
Hostname: canary-79c899d85-992nw

与基于 Request Header 的 annotation 用法规则类似。例如在 A/B 测试场景 下，需要让地域为北京的用户访问 Canary 版本。那么当 cookie 的 annotation 设置为 nginx.ingress.kubernetes.io/canary-by-cookie: "users_from_Beijing"，此时后台可对登录的用户请求进行检查，如果该用户访问源来自北京则设置 cookieusers_from_Beijing 的值为 always，这样就可以确保北京的用户仅访问 Canary 版本。

将 Canary 版本 Ingress 的 yaml 文件修改为如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: canary
  namespace: ns-myapp
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-by-cookie: "user_from_beijing"
spec:
  rules:
  - host: ingress.test.com
    http:
      paths:
      - backend:
          serviceName: canary
          servicePort: 80

访问示例如下：

1
2
[k8s-master ~ ]# curl -s -b "user_from_beijing=always" ingress.test.com | grep Hostname
Hostname: canary-79c899d85-992nw
1
2
[k8s-master ~ ]# curl -s -b "user_from_beijing=no" ingress.test.com | grep Hostname
Hostname: production-5698c4565c-jmjn5

多实例Ingress controllers 参考
https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary
https://cloud.tencent.com/document/product/457/48907

]]> <h2 id="注解说明"><a href="#注解说明" class="headerlink" title="注解说明"></a>注解说明</h2><p>通过给 Ingress 资源指定 Nginx Ingress 所支持的 annotation 可实现金丝雀发布。需给服务创建 K8S 部署 Statefulset zookeeper https://imszz.com/p/b8e5c788/ 2021-03-30T06:00:25.000Z 2021-04-01T06:01:25.000Z 创建存储卷

Zookeeper集群需要用到存储，这里需要准备持久卷（PersistentVolume，简称PV），我这里以yaml文件创建3个PV，供待会儿3个Zookeeper节点创建出来的持久卷声明

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
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-zk1
  annotations:
    volume.beta.kubernetes.io/storage-class: "anything"
  labels:
    type: zookeeper
spec:
  capacity:
    storage: 3Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/zookeeper"
  persistentVolumeReclaimPolicy: Retain
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-zk2
  annotations:
    volume.beta.kubernetes.io/storage-class: "anything"
  labels:
    type: zookeeper
spec:
  capacity:
    storage: 3Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/zookeeper"
  persistentVolumeReclaimPolicy: Retain
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-zk3
  annotations:
    volume.beta.kubernetes.io/storage-class: "anything"
  labels:
    type: zookeeper
spec:
  capacity:
    storage: 3Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/zookeeper"
  persistentVolumeReclaimPolicy: Retain

部署及存储卷状态查询

这里发现pv和pvc还没有绑定状态是Available

1
kubectl apply -f persistent-volume.yaml 
1
kubectl get pv

新版本创建卷及使用

建议使用新版创建

Kubernetes 使用注解 volume.beta.kubernetes.io/storage-class 而不是 storageClassName 属性。这一注解目前仍然起作用，不过在将来的 Kubernetes 发布版本中该注解会被彻底废弃。

创建卷

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
kind: PersistentVolume
apiVersion: v1
metadata:
  name: k8s-pv-zk1
  labels:
    type: zookeeper
spec:
  storageClassName: disk
  capacity:
    storage: 3Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/var/lib/zookeeper"
  persistentVolumeReclaimPolicy: Retain

存储声明

1
2
3
4
5
6
7
8
9
10
11
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: datadir
spec:
  storageClassName: disk
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi

pod引用

1
2
3
4
5
6
7
8
9
10
11
12
13
          ····
    volumeMounts:
      - name: datadir
        mountPath: /var/lib/zookeeper
volumeClaimTemplates:
- metadata:
    name: datadir
  spec:
    storageClassName: disk
    accessModes: [ "ReadWriteOnce" ]
    resources:
      requests:
        storage: 3Gi

注意：如果是使用云服务商比如阿里云，要注意购买云盘要与node节点使用区一致

创建一个 ZooKeeper Ensemble

下面的清单包含一个 无头服务， 一个 Service， 一个 PodDisruptionBudget， 和一个 StatefulSet。

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
apiVersion: v1
kind: Service
metadata:
  name: zk-hs
  labels:
    app: zk
spec:
  ports:
  - port: 2888
    name: server
  - port: 3888
    name: leader-election
  clusterIP: None
  selector:
    app: zk
---
apiVersion: v1
kind: Service
metadata:
  name: zk-cs
  labels:
    app: zk
spec:
  ports:
  - port: 2181
    name: client
  selector:
    app: zk
---
apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
  name: zk-pdb
spec:
  selector:
    matchLabels:
      app: zk
  maxUnavailable: 1
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: zk
spec:
  selector:
    matchLabels:
      app: zk
  serviceName: zk-hs
  replicas: 3
  updateStrategy:
    type: RollingUpdate
  podManagementPolicy: Parallel
  template:
    metadata:
      labels:
        app: zk
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                    - zk
              topologyKey: "kubernetes.io/hostname"
      containers:
      - name: kubernetes-zookeeper
        imagePullPolicy: Always
        image: "guglecontainers/kubernetes-zookeeper:1.0-3.4.10"
        resources:
          requests:
            memory: "1Gi"
            cpu: "0.5"
        ports:
        - containerPort: 2181
          name: client
        - containerPort: 2888
          name: server
        - containerPort: 3888
          name: leader-election
        command:
        - sh
        - -c
        - "start-zookeeper \
          --servers=3 \
          --data_dir=/var/lib/zookeeper/data \
          --data_log_dir=/var/lib/zookeeper/data/log \
          --conf_dir=/opt/zookeeper/conf \
          --client_port=2181 \
          --election_port=3888 \
          --server_port=2888 \
          --tick_time=2000 \
          --init_limit=10 \
          --sync_limit=5 \
          --heap=512M \
          --max_client_cnxns=60 \
          --snap_retain_count=3 \
          --purge_interval=12 \
          --max_session_timeout=40000 \
          --min_session_timeout=4000 \
          --log_level=INFO"
        readinessProbe:
          exec:
            command:
            - sh
            - -c
            - "zookeeper-ready 2181"
          initialDelaySeconds: 10
          timeoutSeconds: 5
        livenessProbe:
          exec:
            command:
            - sh
            - -c
            - "zookeeper-ready 2181"
          initialDelaySeconds: 10
          timeoutSeconds: 5
        volumeMounts:
        - name: datadir
          mountPath: /var/lib/zookeeper
      securityContext:
        runAsUser: 1000
        fsGroup: 1000
  volumeClaimTemplates:
  - metadata:
      name: datadir
      annotations:
        volume.beta.kubernetes.io/storage-class: "anything"
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 3Gi

开始创建

创建了 zk-hs 无头服务、zk-cs 服务、zk-pdb PodDisruptionBudget 和 zk StatefulSet。

1
2
3
4
5
6
kubectl apply -f zookeeper.yml --namespace=zookeeper

service/zk-hs created
service/zk-cs created
poddisruptionbudget.policy/zk-pdb created
statefulset.apps/zk created

状态查询

1
2
3
kubectl get poddisruptionbudgets -n zookeeper
kubectl get pods -n zookeeper
kubectl get pods -n zookeeper -w -l app=zk

如果发现没有启动pod

1
2
3
kubectl logs zk-0 -n zookeeper


github--lena

没有权限没有办法创建目录
没有zookeeper用户
创建一下并给个权限

创建用户以及授权

1
2
3
useradd -s /sbin/nologin zookeeper

chown zookeeper.zookeeper /var/lib/zookeeper/

【注意】{每个安装zk的机器都要执行创建用户以及授权}

如果你是k8s三节点，请注意：

出于安全考虑Pod不会被调度到Master Node上，也就是说Master Node不参与工作负载

如果希望master进行调度
使用污点（taints）与容忍（tolerations）进行调整

促成 Leader 选举

获取 zk StatefulSet 中 Pods 的主机名。

1
for i in 0 1 2; do kubectl exec --namespace zookeeper zk-$i -- hostname; done

看一下效果是不是集群模式

1
for i in 0 1 2; do kubectl exec --namespace zookeeper  zk-$i zkServer.sh status; done

检查每个服务器的 myid 文件的内容

1
for i in 0 1 2; do echo "myid zk-$i";kubectl exec --namespace zookeeper  zk-$i -- cat /var/lib/zookeeper/data/myid; done

获取 zk StatefulSet 中每个 Pod 的全限定域名

1
for i in 0 1 2; do kubectl exec --namespace zookeeper zk-$i -- hostname -f; done

Pod 中查看 zoo.cfg 文件的内容。

1
kubectl exec --namespace zookeeper zk-0 -- cat /opt/zookeeper/conf/zoo.cfg

Ensemble 健康检查

最基本的健康检查是向一个 ZooKeeper 服务器写入一些数据，然后从 另一个服务器读取这些数据

1
2
3
4
5
6
7
kubectl exec --namespace zookeeper zk-0 zkCli.sh create /hello world


WATCHER::

WatchedEvent state:SyncConnected type:None path:null
Created /hello

从 zk-1 Pod 获取数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
kubectl exec  --namespace zookeeper  zk-1 zkCli.sh get /hello


WATCHER::

WatchedEvent state:SyncConnected type:None path:null
world
cZxid = 0x100000014
ctime = Thu Mar 18 03:21:38 UTC 2021
mZxid = 0x100000014
mtime = Thu Mar 18 03:21:38 UTC 2021
pZxid = 0x100000014
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 5
numChildren = 0

如果出现myid重复可以进入node内/var/lib/zookeeper/data/ 下 修改id参数,然后重新部署

参考：https://kubernetes.io/zh/docs/tutorials/stateful-application/zookeeper/

]]> <h2 id="创建存储卷"><a href="#创建存储卷" class="headerlink" title="创建存储卷"></a>创建存储卷</h2><p>Zookeeper集群需要用到存储，这里需要准备持久卷（PersistentVolume，简称PV），我这里以yam k8s 跨 namespace 访问服务 https://imszz.com/p/9225747c/ 2021-03-30T06:00:25.000Z 2021-03-30T06:01:25.000Z 在K8S中，同一个命名空间（namespace）下的服务之间调用，之间通过服务名（service name）调用即可。不过在更多时候，我们可能会将一些服务单独隔离在一个命名空间中（比如我们将中间件服务统一放在 middleware 命名空间中，将业务服务放在 business 命名空间中）。 遇到这种情况，我们就需要跨命名空间访问，K8S 对service 提供了四种不同的类型，针对这个问题我们选用 ExternalName 类型的 service 即可。

k8s service 分为四种类型
分别为：

  • ClusterIp（默认类型，每个Node分配一个集群内部的Ip，内部可以互相访问，外部无法访问集群内部）
  • NodePort（基于ClusterIp，另外在每个Node上开放一个端口，可以从所有的位置访问这个地址）
  • LoadBalance（基于NodePort，并且有云服务商在外部创建了一个负载均衡层，将流量导入到对应Port。要收费的，一般由云服务商提供，比如阿里云、AWS等均提供这种服务）
  • ExternalName（将外部地址经过集群内部的再一次封装，实际上就是集群DNS服务器将CNAME解析到了外部地址上，实现了集群内部访问）

本文使用 ExternalName 实现我们的需求：

通过 {SERVICE_NAME}.{NAMESPACE_NAME}.svc.cluster.local这样的格式，访问目标 namespace 下的服务。

]]> <p>在K8S中，同一个命名空间<code>（namespace）</code>下的服务之间调用，之间通过服务名<code>（service name）</code>调用即可。不过在更多时候，我们可能会将一些服务单独隔离在一个命名空间中（比如我们将中间件服务统一放在 middle 污点（taints）与容忍（tolerations） https://imszz.com/p/5cb0c128/ 2021-03-30T06:00:25.000Z 2021-03-30T06:01:25.000Z 对于nodeAffinity无论是硬策略还是软策略方式，都是调度 pod 到预期节点上，而Taints恰好与之相反，如果一个节点标记为 Taints ，除非 pod 也被标识为可以容忍污点节点，否则该 Taints 节点不会被调度 pod。

比如用户希望把 Master 节点保留给 Kubernetes 系统组件使用，或者把一组具有特殊资源预留给某些 pod，则污点就很有用了，pod 不会再被调度到 taint 标记过的节点。我们搭建的集群默认就给 master 节点添加了一个污点标记，所以我们看到我们平时的 pod 都没有被调度到 master 上去：

1
2
3
4
5
6
7
8
9
10
11
$ kubectl describe node master
Name:               master
Roles:              master
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    kubernetes.io/hostname=master
                    node-role.kubernetes.io/master=
......
Taints:             node-role.kubernetes.io/master:NoSchedule
Unschedulable:      false
......

我们可以使用上面的命令查看 master 节点的信息，其中有一条关于 Taints 的信息：node-role.kubernetes.io/master:NoSchedule，就表示给 master 节点打了一个污点的标记，其中影响的参数是NoSchedule，表示 pod 不会被调度到标记为 taints 的节点，除了 NoSchedule 外，还有另外两个选项：

  • PreferNoSchedule：NoSchedule 的软策略版本，表示尽量不调度到污点节点上去
  • NoExecute：该选项意味着一旦 Taint 生效，如该节点内正在运行的 pod 没有对应 Tolerate 设置，会直接被逐出

污点 taint 标记节点的命令如下：

1
2
3
$ kubectl taint nodes node02 test=node02:NoSchedule
node "node02" tainted

上面的命名将 node02 节点标记为了污点，影响策略是 NoSchedule，只会影响新的 pod 调度，如果仍然希望某个 pod 调度到 taint 节点上，则必须在 Spec 中做出Toleration定义，才能调度到该节点，
比如现在我们想要将一个 pod 调度到 master 节点：(taint-demo.yaml)

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
apiVersion: apps/v1
kind: Deployment
metadata:
  name: taint
  labels:
    app: taint
spec:
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: taint
  template:
    metadata:
      labels:
        app: taint
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - name: http
          containerPort: 80
      tolerations:
      - key: "node-role.kubernetes.io/master"
        operator: "Exists"
        effect: "NoSchedule"

由于 master 节点被标记为了污点节点，所以我们这里要想 pod 能够调度到 master 节点去，就需要增加容忍的声明：

1
2
3
4
tolerations:
- key: "node-role.kubernetes.io/master"
  operator: "Exists"
  effect: "NoSchedule"

然后创建上面的资源，查看结果：

1
2
3
4
5
6
7
8
9
$ kubectl create -f taint-demo.yaml
deployment.apps "taint" created
$ kubectl get pods -o wide
NAME                                      READY     STATUS             RESTARTS   AGE       IP             NODE
......
taint-845d8bb4fb-57mhm                    1/1       Running            0          1m        10.244.4.247   node02
taint-845d8bb4fb-bbvmp                    1/1       Running            0          1m        10.244.0.33    master
taint-845d8bb4fb-zb78x                    1/1       Running            0          1m        10.244.4.246   node02
......

我们可以看到有一个 pod 副本被调度到了 master 节点，这就是容忍的使用方法。

对于 tolerations 属性的写法，其中的 key、value、effect 与 Node 的 Taint 设置需保持一致， 还有以下几点说明：

  • 如果 operator 的值是 Exists，则 value 属性可省略
  • 如果 operator 的值是 Equal，则表示其 key 与 value 之间的关系是 equal(等于)
  • 如果不指定 operator 属性，则默认值为 Equal

另外，还有两个特殊值：

  • 空的 key 如果再配合 Exists 就能匹配所有的 key 与 value，也是是能容忍所有 node 的所有 Taints
  • 空的 effect 匹配所有的 effect

最后，如果我们要取消节点的污点标记，可以使用下面的命令：

1
2
$ kubectl taint nodes node02 test-
node "node02" untainted

这就是污点和容忍的使用方法。

]]> <p>对于<code>nodeAffinity</code>无论是硬策略还是软策略方式，都是调度 pod 到预期节点上，而<code>Taints</code>恰好与之相反，如果一个节点标记为 Taints ，除非 pod 也被标识为可以容忍污点节点，否则该 Taints 节点不 删除mac启动台launchpad中的无效图标 https://imszz.com/p/c1a54034/ 2021-03-28T16:25:23.000Z 2021-03-28T16:26:23.000Z 第一种情况

在Mac上安装Photoshop CS6的后， 启动台(LaunchPad)莫名其妙的多出了几个”Adobe xxxx…”的图标， 而且无法删除，在访达里面应用程序内也找不到， 非常讨厌。

在网上搜索了试过终端删除，app删除，找到程序文件夹删除等各种方法，但都失败了。。。

最后重点来了，我找到了一个终极解决办法：

重建 启动台(LaunchPad) 内的图标来解决.

方法如下:

打开应用程序- 实用工具 - 终端. 以此出入如下命令：

1
2
3
defaults write com.apple.dock ResetLaunchPad -bool true

killall Dock

再次打开 LaunchPad 的时候, 所有图标会被重建。

如果发现启动台(LaunchPad)里面出现了一个新的相关文件夹，并且是原来Adobe之类的程序， 那么需要再次打开访达->应用程序->实用工具 内找到对应相关文件程序删掉即可。

最后，你会发现重置之后之前的所有设置都会丢失. 没有特殊情况不要使用哦. 以免丢失之前的排列方式与文件夹.

第二种情况

有些应用程序（比如说虚拟机），安装之后会在启动台生成文件夹或其它图标，但是卸载了应用之后，这个文件夹依然会保留下来，简直逼死强迫症。

方法如下:

卸载应用程序之后，一般其在启动台生成的文件夹是不会被删除的，不过这个文件夹里面是空的。如果执意要删除的话，可以从Finder（访达）里面入手。具体操作为，打开访达，按下快捷键「commond」+「shift」+「H」，之后页面会自动跳转到用户的主页。打开「应用程序文件夹」，里面的都是launchpad的内容，找到你要删除的目标将其删除即可。

]]> <h3 id="第一种情况"><a href="#第一种情况" class="headerlink" title="第一种情况"></a>第一种情况</h3><p>在Mac上安装Photoshop CS6的后， 启动台(LaunchPad)莫名其妙的多出了几个”Adobe xxx 如何注册PropellerAds账号 https://imszz.com/p/399b4ecc/ 2021-02-08T16:46:25.000Z 2021-02-08T16:48:26.000Z PropellerAds

PropellerAds是2018-2019年度最好的cpm广告网络之一，也是支付率最高的cpm广告网络之一。如果您正在寻找移动广告，弹出窗口，对话框和插页式广告，那么PorpellerAds是您最适合的CPM网络。出版商将获得10美元的有效每千次展示费用，这个每千次展示费率取决于访问国家，如果您的网站拥有高流量来自英国，美国，那么您可以预期这个广告网络很多钱。它提供了许多广告格式供用户赚取，这些广告格式是横幅广告，原生直接广告，流行下广告，非页内广告，上推广告，对话广告。螺旋桨广告支付净30基础。最低支付限额为100美元，发布可以通过电汇和PayPal提款。

获得批准的要求：

  • 没有最低流量要求
  • 网站必须是基于内容的，而不是简单的链接或广告列表
  • 网站不得在“正在建设中”
  • 网站不得包含与成人相关的内容

最好的功能

  • PropellerAds在Net 30上支付
  • 其最低支付限额是$ 5
  • 实时统计报告系统
  • 付款方式是电汇和PayPal
  • PropellerAds提供多种广告格式

支持国内IP,PropellerAds本身有banner和弹窗广告 , 但是banner广告收入极低 , 所以不建议去做 反而弹窗收入高（垃圾站点使用高）

首先我们注册PropellerAds平台

链接地址PropellerAds

github--lena

我们选择账户类型为Publisher，注意这里我们注册为发行商，一定不要选错了
提供广告的请注册Advertiser，

跳转到这个页面

据实填写我们的个人信息即可，填写完成以后点击下一步 ,只填写必要信息即可
github--lena

点击下一页后在相关的输入框中大家可以根据我填写的内容来进行填写，这里其实只需要简单的说明一下我们目前的流量源

github--lena

最后点击注册就可以了，基本上注册以后我很快会收到确认邮件，当即注册马上就能进入平台了

github--lena

在你的邮箱中收到这份确认邮件以后点击验证账户，然后会跳转至设置初始密码的页面，设置完成以后就ok了，恭喜你，

绑定网站与验证

添加网站
github--lena

验证
github--lena

验证通过后添加广告类别

github--lena

选择自己适用的类别
add zone
点击获取代码并选择在自己的官网手动引用就可以
github--lena

请注意：MultiTag 广告格式包含（In-Page Push (Banner)与Onclick (Popunder)与Interstitial）

不太建议直接使用MultiTag与Onclick (Popunder) 这两种广告格式 因为会跳转到其他网站，可能会包含非法站点

请点击PropellerAds跳转官网注册

]]> <h2 id="PropellerAds"><a href="#PropellerAds" class="headerlink" title="PropellerAds"></a><a href="https://propellerads.com/publishers/?ref_ Linux设置和修改时间与时区 https://imszz.com/p/339c428/ 2021-01-26T16:00:00.000Z 2021-01-27T12:46:25.000Z

linux系统时间有两个，一个是硬件时间，即BIOS时间，就是我们进行CMOS设置时看到的时间，另一个是系统时间，是linux系统Kernel时间。当Linux启动时，系统Kernel会去读取硬件时钟的设置，然后系统时钟就会独立于硬件运作。有时我们会发现系统时钟和硬件时钟不一致，因此需要执行时间同步。

方法一

一、date 查看/设置系统时间

1
2
3
4
5
6
7
8
1、将日期设置为2017年11月3日
[root@linux-node ~]# date -s 11/03/17

2、将时间设置为14点20分50秒
[root@linux-node ~]# date -s 14:20:50

3、将时间设置为2017年11月3日14点16分30秒（MMDDhhmmYYYY.ss）
[root@linux-node ~]# date 1103141617.30

二、hwclock/clock 查看/设置硬件时间

1
2
3
4
5
6
7
1、查看系统硬件时钟
[root@linux-node ~]# hwclock  --show 或者
[root@linux-node ~]# clock  --show

2、设置硬件时间
[root@linux-node ~]# hwclock --set --date="11/03/17 14:55" （月/日/年时:分:秒） 或者
[root@linux-node ~]# clock --set --date="11/03/17 14:55" （月/日/年时:分:秒）

三、同步系统及硬件时钟

1
2
3
4
5
6
7
8
[root@linux-node ~]# hwclock --hctosys 或者
[root@linux-node ~]# clock --hctosys  
备注：hc代表硬件时间，sys代表系统时间，以硬件时间为基准，系统时间找硬件时间同步


[root@linux-node ~]# hwclock --systohc或者
[root@linux-node ~]# clock --systohc 
备注：以系统时间为基准，硬件时间找系统时间同步

方法二

时区设置用tzselect 命令来实现。但是通过tzselect命令设置TZ这个环境变量来选择的时区，需要将变量添加到.profile文件中。

一、tzselect命令执行

1
执行tzselect命令 --> 选择Asia --> 选择China --> 选择east China - Beijing, Guangdong, Shanghai, etc-->然后输入1。

执行完tzselect命令选择时区后，时区并没有更改，只是在命令最后提示你可以执行 TZ=’Asia/Shanghai’; export TZ 并将这行命令添加到.profile中，然后退出并重新登录。

二、修改配置文件来修改时区

1
2
3
4
[root@linux-node ~]# echo "ZONE=Asia/Shanghai" >> /etc/sysconfig/clock         
[root@linux-node ~]# rm -f /etc/localtime
#链接到上海时区文件       
[root@linux-node ~]# ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

执行完上述过程后，重启机器，即可看到时区已经更改。

备注：

1
2
在centos7中设置时区的命令可以通过 timedatectl 命令来实现
[root@linux-node ~]# timedatectl set-timezone Asia/Shanghai
]]> <blockquote> <p>linux系统时间有两个，一个是硬件时间，即BIOS时间，就是我们进行CMOS设置时看到的时间，另一个是系统时间，是linux系统Kernel时间。当Linux启动时，系统Kernel会去读取硬件时钟的设置，然后系统时钟就会独立于硬件运作。有时我们 MySQL5.7 字符集设置 https://imszz.com/p/38510659/ 2021-01-25T16:00:00.000Z 2021-01-26T12:46:25.000Z MySQL5.7 字符集设置
1
2
3
4
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect=’SET NAMES utf8mb4’

character-set-client-handshake

用来控制客户端声明使用字符集和服务端声明使用的字符集在不一致的情况下的兼容性.

1
2
character-set-client-handshake = false
# 设置为 False, 在客户端字符集和服务端字符集不同的时候将拒绝连接到服务端执行任何操作
1
2
3
# 默认为 true
character-set-client-handshake = true
# 设置为 True, 即使客户端字符集和服务端字符集不同, 也允许客户端连接

character-set-server

声明服务端的字符编码, 推荐使用utf8mb4 , 该字符虽然占用空间会比较大, 但是可以兼容 emoji 😈 表情的存储

1
character-set-server = utf8mb4

collation-server

声明服务端的字符集, 字符编码和字符集一一对应, 既然使用了utf8mb4的字符集, 就要声明使用对应的字符编码

1
collation-server = utf8mb4_unicode_ci

init_connect

init_connect 是用户登录到数据库上之后, 在执行第一次查询之前执行里面的内容. 如果 init_connect 的内容有语法错误, 导致执行失败, 会导致用户无法执行查询, 从mysql 退出

使用 init_connect 执行 SET NAMES utf8mb4 意为:

声明自己(客户端)使用的是 utf8mb4 的字符编码
希望服务器返回给自己 utf8mb4 的查询结果

1
init_connect = 'SET NAMES utf8mb4'

完整配置

1
2
3
4
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect = 'SET NAMES utf8mb4'
]]> <h1 id="MySQL5-7-字符集设置"><a href="#MySQL5-7-字符集设置" class="headerlink" title="MySQL5.7 字符集设置"></a>MySQL5.7 字符集设置</h1><figure class="highlight MySQL5.7 高可用高性能配置调优 性能参数参考 https://imszz.com/p/2d27b747/ 2021-01-25T16:00:00.000Z 2021-01-26T12:46:25.000Z

MySQL5.7 在 5.6 版本的基础之上做了大量的优化, 本篇文章开篇将重点围绕经过优化的基于 GTID 的多线程复制和半同步复制的特性介绍, 后续会持续增加 MySQL5.7 的调优参数

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
[client]
default-character-set = utf8mb4

[mysqld]

### 基本属性配置
port = 3306
datadir=/data/mysql
# 禁用主机名解析
skip-name-resolve
# 默认的数据库引擎
default-storage-engine = InnoDB

### 字符集配置
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect='SET NAMES utf8mb4'

### GTID
server_id = 59
# 为保证 GTID 复制的稳定, 行级日志
binlog_format = row
# 开启 gtid 功能
gtid_mode = on
# 保障 GTID 事务安全
# 当启用enforce_gtid_consistency功能的时候,
# MySQL只允许能够保障事务安全, 并且能够被日志记录的SQL语句被执行,
# 像create table ... select 和 create temporarytable语句, 
# 以及同时更新事务表和非事务表的SQL语句或事务都不允许执行
enforce-gtid-consistency = true
# 以下两条配置为主从切换, 数据库高可用的必须配置
# 开启 binlog 日志功能
log_bin = on
# 开启从库更新 binlog 日志
log-slave-updates = on

### 慢查询日志
# 打开慢查询日志功能
slow_query_log = 1
# 超过2秒的查询记录下来
long_query_time = 2
# 记录下没有使用索引的查询
log_queries_not_using_indexes = 1

### 自动修复
# 记录 relay.info 到数据表中
relay_log_info_repository = TABLE
# 记录 master.info 到数据表中 
master_info_repository = TABLE
# 启用 relaylog 的自动修复功能
relay_log_recovery = on
# 在 SQL 线程执行完一个 relaylog 后自动删除
relay_log_purge = 1


### 数据安全性配置
# 关闭 master 创建 function 的功能
log_bin_trust_function_creators = off
# 每执行一个事务都强制写入磁盘
sync_binlog = 1
# timestamp 列如果没有显式定义为 not null, 则支持null属性
# 设置 timestamp 的列值为 null, 不会被设置为 current timestamp
explicit_defaults_for_timestamp=true

### 优化配置
# 优化中文全文模糊索引
ft_min_word_len = 1
# 默认库名表名保存为小写, 不区分大小写
lower_case_table_names = 1
# 单条记录写入最大的大小限制
# 过小可能会导致写入(导入)数据失败
max_allowed_packet = 256M
# 半同步复制开启
rpl_semi_sync_master_enabled = 1
rpl_semi_sync_slave_enabled = 1
# 半同步复制超时时间设置
rpl_semi_sync_master_timeout = 1000
# 复制模式(保持系统默认)
rpl_semi_sync_master_wait_point = AFTER_SYNC
# 后端只要有一台收到日志并写入 relaylog 就算成功
rpl_semi_sync_master_wait_slave_count = 1
# 多线程复制
slave_parallel_type = logical_clock
slave_parallel_workers = 4

### 连接数限制
max_connections = 1500
# 验证密码超过20次拒绝连接
max_connect_errors = 20
# back_log值指出在mysql暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中
# 也就是说，如果MySql的连接数达到max_connections时，新来的请求将会被存在堆栈中
# 以等待某一连接释放资源，该堆栈的数量即back_log，如果等待连接的数量超过back_log
# 将不被授予连接资源
back_log = 500
open_files_limit = 65535
# 服务器关闭交互式连接前等待活动的秒数
interactive_timeout = 3600
# 服务器关闭非交互连接之前等待活动的秒数
wait_timeout = 3600

### 内存分配
# 指定表高速缓存的大小。每当MySQL访问一个表时，如果在表缓冲区中还有空间
# 该表就被打开并放入其中，这样可以更快地访问表内容
table_open_cache = 1024
# 为每个session 分配的内存, 在事务过程中用来存储二进制日志的缓存
binlog_cache_size = 2M
# 在内存的临时表最大大小
tmp_table_size = 128M
# 创建内存表的最大大小(保持系统默认, 不允许创建过大的内存表)
# 如果有需求当做缓存来用, 可以适当调大此值
max_heap_table_size = 16M
# 顺序读, 读入缓冲区大小设置
# 全表扫描次数多的话, 可以调大此值
read_buffer_size = 1M
# 随机读, 读入缓冲区大小设置
read_rnd_buffer_size = 8M
# 高并发的情况下, 需要减小此值到64K-128K
sort_buffer_size = 1M
# 每个查询最大的缓存大小是1M, 最大缓存64M 数据
query_cache_size = 64M
query_cache_limit = 1M
# 提到 join 的效率
join_buffer_size = 16M
# 线程连接重复利用
thread_cache_size = 64

### InnoDB 优化
## 内存利用方面的设置
# 数据缓冲区
innodb_buffer_pool_size=2G
## 日志方面设置
# 事务日志大小
innodb_log_file_size = 256M
# 日志缓冲区大小
innodb_log_buffer_size = 4M
# 事务在内存中的缓冲
innodb_log_buffer_size = 3M
# 主库保持系统默认, 事务立即写入磁盘, 不会丢失任何一个事务
innodb_flush_log_at_trx_commit = 1
# mysql 的数据文件设置, 初始100, 以10M 自动扩展
innodb_data_file_path = ibdata1:100M:autoextend
# 为提高性能, MySQL可以以循环方式将日志文件写到多个文件
innodb_log_files_in_group = 3
##其他设置
# 如果库里的表特别多的情况，请增加此值
innodb_open_files = 800
# 为每个 InnoDB 表分配单独的表空间
innodb_file_per_table = 1
# InnoDB 使用后台线程处理数据页上写 I/O（输入）请求的数量
innodb_write_io_threads = 8
# InnoDB 使用后台线程处理数据页上读 I/O（输出）请求的数量
innodb_read_io_threads = 8
# 启用单独的线程来回收无用的数据
innodb_purge_threads = 1
# 脏数据刷入磁盘(先保持系统默认, swap 过多使用时, 调小此值, 调小后, 与磁盘交互增多, 性能降低)
# innodb_max_dirty_pages_pct = 90
# 事务等待获取资源等待的最长时间
innodb_lock_wait_timeout = 120
# 开启 InnoDB 严格检查模式, 不警告, 直接报错
innodb_strict_mode=1
# 允许列索引最大达到3072
 innodb_large_prefix = on

[mysqldump]
# 开启快速导出
quick
default-character-set = utf8mb4
max_allowed_packet = 256M

[mysql]
# 开启 tab 补全
auto-rehash
default-character-set = utf8mb4

]]> <blockquote> <p>MySQL5.7 在 5.6 版本的基础之上做了大量的优化, 本篇文章开篇将重点围绕经过优化的基于 GTID 的多线程复制和半同步复制的特性介绍, 后续会持续增加 MySQL5.7 的调优参数</p> </blockquote> <figure c mysql 安装5.7 https://imszz.com/p/d47d8d30/ 2021-01-25T16:00:00.000Z 2021-01-26T12:46:25.000Z MySQL编译和安装

##在CentOS7中编译安装MySQL 5.7.21. 依赖和源码包 安装相关的依赖: 

1
2
yum install gcc gcc-c++ ncurses ncurses-devel cmake bison openssl-devel -y 
yum install make cmake gcc gcc-c++ bison bison-devel ncurses ncurses-devel autoconf automake

下载MySQL 5.7.32源码包和依赖boost, MySQL 5.7.32依赖boost 1.59.0: 

1
2
3
4
curl -o boost_1_59_0.tar.gz https://jaist.dl.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.gz 
#curl -o mysql-5.7.32.tar.gz https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.32.tar.gz
如果拉取不到使用下方下载地址 ：
https://downloads.mysql.com/archives/community/

解压下载的包: 

1
2
3
4
5
# 进入下载的路径 
# 解压到/usr/local/目录
tar -xzvf boost_1_59_0.tar.gz -C /usr/local/ 
# 解压到当前目录 
tar -xzvf mysql-5.7.32.tar.gz

创建用户和组

创建MySQL用户和组, 并且用户不能登陆: 

1
groupadd -r mysql && useradd -r -g mysql -s /sbin/nologin -M mysql

创建相关的目录

创建数据目录

1
2
3
4
5
6
7
mkdir -p /home/mysql/data

mkdir -p /home/mysql/logs

mkdir -p /usr/local/mysql 

mkdir -p /home/mysql/temp
1
2
3
4
chown -Rf mysql:mysql /usr/local/mysql


chown -Rf mysql:mysql /home/mysql

预编译

使用各种参数, 预编译源代码. 进入解压的MySQL源码目录, 执行以下命令: 

1
cmake -DCMAKE_INSTALL_PREFIX=/usr/local/mysql -DMYSQL_DATADIR=/home/mysql/data -DSYSCONFDIR=/etc -DMYSQL_UNIX_ADDR=/usr/local/mysql/mysqld.sock -DEXTRA_CHARSETS=all -DDEFAULT_CHARSET=utf8mb4 -DDEFAULT_COLLATION=utf8mb4_unicode_ci -DWITH_MYISAM_STORAGE_ENGINE=1 -DWITH_INNOBASE_STORAGE_ENGINE=1 -DWITH_PARTITION_STORAGE_ENGINE=1 -DWITH_ARCHIVE_STORAGE_ENGINE=1 -DWITH_BLACKHOLE_STORAGE_ENGINE=1 -DENABLED_LOCAL_INFILE=1 -DENABLED_PROFILING=1 -DMYSQL_TCP_PORT=3306 -DWITH_DEBUG=0 -DDOWNLOAD_BOOST=1 -DWITH_BOOST=/usr/local/boost_1_59_0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DCMAKE_INSTALL_PREFIX=/usr/local/mysql :安装路径
DMYSQL_DATADIR=/data/mysql :数据文件存放位置
DSYSCONFDIR=/etc :my.cnf路径
DMYSQL_UNIX_ADDR=/usr/local/mysql/mysqld.sock :连接数据库socket路径 
DEXTRA_CHARSETS=all :安装所有的字符集
DDEFAULT_CHARSET=utf8mb4 :默认字符
DDEFAULT_COLLATION=utf8mb4_unicode_ci :排序集
DWITH_MYISAM_STORAGE_ENGINE=1 :支持MyIASM引擎
DWITH_INNOBASE_STORAGE_ENGINE=1 :支持InnoDB引擎
DWITH_PARTITION_STORAGE_ENGINE=1 :安装支持数据库分区
DENABLED_LOCAL_INFILE=1 :允许从本地导入数据
DENABLED_PROFILING=1 :
DMYSQL_TCP_PORT=3306 :端口
DWITH_DEBUG=0 :
DDOWNLOAD_BOOST=1 :允许下载
DWITH_BOOST=/usr/local/boost_1_59_0 :本地boost路径

编译安装

预编译完成后, 执行下面的命令编译, 安装: 

1
2
# 指定CPU数量编译 
make -j `grep processor /proc/cpuinfo | wc -l` && make install

添加开机自启

对目录修改权限, 添加service/systemd服务: 

1
2
3
4
5
6
chown -R mysql:mysql /usr/local/mysql 
cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysql
chmod +x /etc/init.d/mysql
# 开机自启 
chkconfig --add mysql
chkconfig mysql on

环境变量

将/usr/local/mysql/bin添加进入环境变量, 或者直接使用软链接的方式链到/usr/local/bin下: 

1
2
3
4
5
6
7
8
# 添加到环境变量 
echo "" >> /etc/bashrc 
echo "export PATH=/usr/local/mysql/bin:$PATH" >> /etc/bashrc 
echo "" >> /etc/bashrc 
source ~/.bashrc 

# 使用软链接 
ln -s /usr/local/mysql/bin/* /usr/local/bin/

初始化数据库

以上都完成后, 还不能启动MySQL, 如果非要启动, 会报错. 需要初始化数据库:

1
/usr/local/mysql/bin/mysqld --initialize --user=mysql --basedir=/usr/local/mysql --datadir=/home/mysql/data
1
2
3
--user :指定用户 
--basedir :mysql所在目录 
--datadir :mysql数据库和表所在的目录,以及PID文件

初始化后, 会有一行提示, 冒号后面的是初始密码root@localhost: password:

1
A temporary password is generated for root@localhost: xKefZvib13)5

启动服务

以上都配置完成, 就可以启动服务了: 

1
2
3
4
5
6
# 使用service 
service mysql start 

# 使用systemd 
systemctl daemon-reload 
systemctl start mysql

修改密码

将初始密码修改成自己的密码, 直接在shell中输入命令: mysqladmin -uroot -p'old_pass' password 'new_pass'

配置文件

默认MySQL不需要配置文件, 编译时已经配置好了, 但是也可以使用配置文件, 指定log的位置, 编辑vim /etc/my.cnf, 将以下内容添加到文件中:

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
[client]

port = 3306

socket = /usr/local/mysql/mysql.sock

default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]

character-set-client-handshake=FALSE

character-set-server=utf8mb4

collation-server=utf8mb4_unicode_ci

init_connect='SET NAMES utf8mb4'

#character-set-server = utf8

#collation-server = utf8_general_ci

skip-external-locking

skip-name-resolve

user = mysql

port = 3306

basedir = /usr/local/mysql

datadir = /home/mysql/data

tmpdir = /home/mysql/temp

# server_id = .....

socket = /usr/local/mysql/mysql.sock

log-error = /home/mysql/logs/mysql_error.log

pid-file = /home/mysql/mysql.pid

open_files_limit = 10240

back_log = 600

max_connections=500

max_connect_errors = 6000

wait_timeout=605800

#open_tables = 600

#table_cache = 650

#opened_tables = 630

max_allowed_packet = 32M

sort_buffer_size = 4M

join_buffer_size = 4M

thread_cache_size = 300

query_cache_type = 1

query_cache_size = 256M

query_cache_limit = 2M

query_cache_min_res_unit = 16k

tmp_table_size = 256M

max_heap_table_size = 256M

key_buffer_size = 256M

read_buffer_size = 1M

read_rnd_buffer_size = 16M

bulk_insert_buffer_size = 64M

lower_case_table_names=1

default-storage-engine = INNODB

innodb_buffer_pool_size =2G

innodb_log_buffer_size = 32M

innodb_log_file_size = 128M

innodb_flush_method =O_DIRECT



#####################

#thread_concurrency = 32 5.7不支持

long_query_time= 2

slow-query-log=on

slow-query-log-file =/home/mysql/logs/mysql-slow.log

[mysqldump]

quick

max_allowed_packet = 32M

[mysqld_safe]

log-error=/var/log/mysqld.log

pid-file=/var/run/mysqld/mysqld.pid
]]> <h1 id="MySQL编译和安装"><a href="#MySQL编译和安装" class="headerlink" title="MySQL编译和安装"></a>MySQL编译和安装</h1><p>##在<code>CentOS7</code>中编译安装<code>MySQ mysql数据更改存储路径 https://imszz.com/p/57aae221/ 2021-01-25T16:00:00.000Z 2021-01-26T12:46:25.000Z

在初次安装mysql 的时候将数据库目录安装在了系统盘。（第一个磁盘）使用了一段时间之后数据库存储量变大，快将20GB的存放空间占满了。因此必须将存放数据空间换地方了。下面是简单的操作。

检查mysql数据库存放目录

1
mysql -u root -prootadmin
1
2
3
4
5
6
7
8
9
#进入数据库

show variables like '%dir%';

#查看sql存储路径

（查看datadir 那一行所指的路径）

quit;

停止mysql服务

1
service mysql stop

创建新的数据库存放目录

1
mkdir /data/mysql

移动/复制之前存放数据库目录文件，到新的数据库存放目录位置

1
2
cp -R /usr/local/mysql/data/* /data/mysql/ #或mv /usr/local/mysql/data/* /data/mysql

修改mysql数据库目录权限以及配置文件

1
2
3
4
5
6
7
8
9
10
chown mysql:mysql -R /data/mysql/

vim /etc/my.cnf

datadir=/data/mysql （制定为新的数据存放目录）

vim /etc/init.d/mysql

datadir=/data/mysql

启动数据库服务

1
service mysqld start

说明：根据以上的简单6步操作，已经成功的数据库目录更换路径了。

备注：以上系统为CentOS Linux release 7.8.2003 (Core) mysql-5.7.32 编译安装

]]> <blockquote> <p>在初次安装mysql 的时候将数据库目录安装在了系统盘。（第一个磁盘）使用了一段时间之后数据库存储量变大，快将20GB的存放空间占满了。因此必须将存放数据空间换地方了。下面是简单的操作。</p> </blockquote> <h1 id="检查my