环境要求
部署原理
部署 MySQL
理解有状态Pod的初始化
MySQL部署环境验证
扩容slave的数量
部署对外读服务
部署对外读写服务
常见错误
参考文献

环境要求

至少需要4台机器，并且每台机器内存不少于2G以及至少2个CPU

1个master节点
3个node

mysql的主节点不能和从节点在同一个node机器上，且任意两个从节点也必须在不同机器上

部署原理

使用 statefulset控制器部署mysql主从集群的原理如下图所示：
使用 statefulset控制器部署mysql主从集群 - 图1

使用 statefulset控制器部署mysql主从集群 - 图2

部署 MySQL

部署 MySQL 示例，包含一个 ConfigMap，两个 Services，与一个 StatefulSet。

创建ConfigMap

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

[root@k8s-master01 pv-pvc]# mkdir mysql
[root@k8s-master01 pv-pvc]# cd mysql/
[root@k8s-master01 mysql]# cat >> configmap.yaml <<EOF
> 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    
> EOF

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

ConfigMap 本身没有什么特别之处，它可以使不同部分应用于不同的 Pod。每个 Pod 都会决定在初始化时要看基于 StatefulSet 控制器提供的信息。

运行这个yaml文件之前删除之前实验所创建的configmap：

[root@k8s-master01 mysql]# kubectl delete cm --all
configmap "config-map" deleted
configmap "test-config1" deleted
configmap "test-config3" deleted
configmap "test-config4" deleted
configmap "test-configmap" deleted
[root@k8s-master01 mysql]# kubectl get cm
No resources found in default namespace.

运行yaml文件：

[root@k8s-master01 mysql]# kubectl apply -f configmap.yaml 
configmap/mysql created
[root@k8s-master01 mysql]# kubectl get cm
NAME    DATA   AGE
mysql   2      9s
[root@k8s-master01 mysql]# kubectl describe cm mysql
Name:         mysql
Namespace:    default
Labels:       app=mysql
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"v1","data":{"master.cnf":"# Apply this config only on the master.\n[mysqld]\nlog-bin    \n","slave.cnf":"# Apply this confi...

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    

Events:  <none>

创建Services

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

[root@k8s-master01 mysql]# cat >> service.yaml <<EOF
> # 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
> EOF
[root@k8s-master01 mysql]# 
[root@k8s-master01 mysql]# kubectl apply -f service.yaml 
service/mysql created
service/mysql-read created
[root@k8s-master01 mysql]# kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
mysql        ClusterIP   None            <none>        3306/TCP   6s
mysql-read   ClusterIP   10.20.154.107   <none>        3306/TCP   6s

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

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

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

用户所有写请求，必须以 DNS 记录的方式直接访问到 Master 节点，也就是 mysql-0.mysql 这条 DNS 记录。

用户所有读请求，必须访问自动分配的 DNS 记录可以被转发到任意一个 Master 或 Slave 节点上，也就是 mysql-read 这条 DNS 记录

StatefulSet控制器创建pod

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

cat >> statefulset.yaml <<"EOF"
> 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: gcr.io/google-samples/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"
>         - name: MYSQL_ROOT_PASSWORD
>           value: "Sgy@97"
>                    #- name: MYSQL_DATABASE
>         #  value: "nacos_config"
>         #- name: MYSQL_USER
>         #  value: "nacos"
>         #- name: MYSQL_PASSWORD
>         #  value: "nacos"        
>         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: gcr.io/google-samples/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 ]]; then
>             # XtraBackup already generated a partial "CHANGE MASTER TO" query
>             # because we're cloning from an existing slave.
>             mv xtrabackup_slave_info change_master_to.sql.in
>             # Ignore xtrabackup_binlog_info in this case (it's useless).
>             rm -f 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 xtrabackup_binlog_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"
>             # In case of container restart, attempt this at-most-once.
>             mv change_master_to.sql.in change_master_to.sql.orig
>             mysql -h 127.0.0.1 <<EOF
>           $(<change_master_to.sql.orig),
>             MASTER_HOST='mysql-0.mysql',
>             MASTER_USER='root',
>             MASTER_PASSWORD='',
>             MASTER_CONNECT_RETRY=10;
>           START SLAVE;
>           EOF
>           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:
>       accessModes: ["ReadWriteOnce"]
>       resources:
>         requests:
>           storage: 1Gi
> EOF

上述yaml文件中需要的镜像有：mysql:5.7 和 xtrabackup:1.0，需要提前拉取放到私有仓库里面。

运行这个文件：

[root@k8s-master01 mysql]# kubectl apply -f statefulset.yaml 
statefulset.apps/mysql created

运行后等待几分钟即可查看到所有pod均以运行：

通过如下命令查看启动过程，添加--namespace=kube-public可以查看某个命名空间下的

kubectl get pods -l app=mysql --watch

通过如下命令可以查看某个pod的运行信息

kubectl describe pod mysql-1

等待好长时间后，查看运行状态

[root@k8s-master01 mysql]# kubectl get pod -l app=mysql -o wide
NAME      READY   STATUS    RESTARTS   AGE     IP                NODE         NOMINATED NODE   READINESS GATES
mysql-0   2/2     Running   0          10m     192.168.85.237    k8s-node01   <none>           <none>
mysql-1   2/2     Running   1          9m54s   192.168.58.197    k8s-node02   <none>           <none>
mysql-2   2/2     Running   1          4m32s   192.168.135.133   k8s-node03   <none>           <none>

理解有状态Pod的初始化

StatefulSet 控制器一次按顺序启动 Pod 序数索引。它一直等到每个 Pod 报告就绪为止，然后再开始下一个 Pod。

此外，控制器为每个 Pod 分配一个唯一，稳定的表单名称 - 其结果是 Pods 名为 mysql-0，mysql-1 和 mysql-2。

生成配置

在启动 Pod 规范中的任何容器之前， Pod 首先按照定义的顺序运行所有初始容器。

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

该脚本通过从 Pod 名称的末尾提取索引来确定自己的序号索引，该名称由 hostname 命令返回。然后将序数(带有数字偏移量以避免保留值)保存到 MySQL conf.d 目录中的文件 server-id.cnf 中。这将转换 StatefulSet 提供的唯一，稳定的身份控制器进入需要相同属性的 MySQL 服务器 ID 的范围。

通过将内容复制到 conf.d 中，init-mysql 容器中的脚本也可以应用 ConfigMap 中的 master.cnf 或 slave.cnf。由于示例拓扑由单个 MySQL 主节点和任意数量的从节点组成，因此脚本仅将序数 0 指定为主节点，而将其他所有人指定为从节点。与 StatefulSet 控制器的部署顺序保证,这样可以确保 MySQL 主服务器在创建从服务器之前已准备就绪，以便它们可以开始复制。

克隆现有数据

通常，当新的 Pod 作为从节点加入集合时，必须假定 MySQL 主节点可能已经有数据。还必须假设复制日志可能不会一直追溯到时间的开始。这些保守假设的关键是允许正在运行的 StatefulSet 随时间扩大和缩小而不是固定在其初始大小。

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

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

开始复制

初始化容器成功完成后，常规容器将运行。 MySQL Pods 由运行实际 mysqld 服务器的 mysql 容器和充当辅助工具的 xtrabackup 容器组成。

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

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

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

MySQL部署环境验证

通过运行一个临时的容器(使用mysql:5.7镜像)，使用MySQL 客户端发送测试请求给MySQL master节点（主机名为mysql-0.mysql；跨命名空间的话，主机名请使用mysql-0.mysql.命名空间名）

kubectl run mysql-client --image=mysql:5.7 -it --rm --restart=Never -- mysql -h mysql-0.mysql

在master节点上创建demo数据库，并创建一个只有message字段的demo.messages的表，并为message字段插入hello值。

CREATE DATABASE demo; 
CREATE TABLE demo.messages (message VARCHAR(250)); 
INSERT INTO demo.messages VALUES ('hello');

使用主机名为mysql-read来发送测试请求给服务器：

kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never -- mysql -h mysql-read

结果

[root@k8s-master01 mysql]# kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never -- mysql -h mysql-read
If you don't see a command prompt, try pressing enter.

mysql> select * from demo.messages;
+---------+
| message |
+---------+
| hello   |
+---------+
1 row in set (0.00 sec)

扩容slave的数量

对于mysql副本，通过添加从节点进行扩容。

kubectl scale statefulset mysql --replicas=5 --namespace=kube-public

通过下面的命令查看新的Pod

kubectl get pods -l app=mysql --watch --namespace=kube-public

使用 statefulset控制器部署mysql主从集群 - 图4

缩容也是无缝的：

kubectl scale statefulset mysql --replicas=3 --namespace=kube-public

部署对外读服务

apiVersion: v1
kind: Service
metadata:
  # namespace: blog
  name: mysql-read
  labels:
    app: mysql
spec:
  ports:
  - name: mysql
    port: 3306
    targetPort: 3306
    nodePort: 30036
  type: NodePort
  selector:
    app: mysql

部署对外读写服务

[root@k8s-master01 mysql]# kubectl get pods --show-labels -n blog | grep mysql-0 | awk '{print $6}' | awk -F, '{print $3}'
# 如果是默认命名空间则去掉 -n blog
[root@k8s-master01 mysql]# kubectl get pods --show-labels | grep mysql-0 | awk '{print $6}' | awk -F, '{print $3}'
statefulset.kubernetes.io/pod-name=mysql-0

得到该标签后写入如下selector字段

apiVersion: v1
kind: Service
metadata:
  # namespace: blog
  name: mysql-writeandread
  labels:
    app: mysql
spec:
  ports:
  - name: mysql
    port: 3306
    targetPort: 3306
    nodePort: 30006
  selector:
    statefulset.kubernetes.io/pod-name: mysql-0
  type: NodePort

运行

[root@k8s-master01 mysql]# kubectl apply -f mysql-write.yaml
service/mysql-writeandread created

使用集群任意节点IP:nodePort进行连接

常见错误

mysql Back-off restarting failed container
这个原因有很多，比如k8s gcr.io被墙导致ImagePullBackOff，或者节点内存不足导致caused “process_linux.go:101: executing setns process caused “exit status 1，等。

docker pull ist0ne/xtrabackup
docker tag ist0ne/xtrabackup:latest gcr.io/google-samples/xtrabackup:1.0

参考文献

可以参考官方文档：https://kubernetes.io/zh/docs/tasks/run-application/run-replicated-stateful-application/
mysql主从复制的原理参考：https://blog.csdn.net/qq_35887546/article/details/104661790

shell的EOF使用 : https://www.yuque.com/yanggev587/om3wbn/vvh7m0