关于k8s:K8S部署MySQL主从

一、部署阐明

能够应用 kubesphere，疾速搭建 MySQL 环境。

• 有状态服务抽取配置为 ConfigMap
• 有状态服务必须应用 pvc 长久化数据
• 服务集群内拜访应用 DNS 提供的稳固域名

k8s 部署有状态服务的话就是参照下面的图。
部署具体阐明：

• 有状态服务抽取配置为 ConfigMap
  在之前咱们应用 Docker 部署 MySQL 的时候也会将 conf、logs、data 等数据挂载到宿主机上，那么在 k8s 外面的话专门有一个空间是治理配置文件的也就是下面提到的 ConfigMap，能够将一些罕用的配置抽离进去做成 ConfigMap 配置，起初不论是 MySQL 挂了重启还是创立新的 MySQL 都可已应用同一个 ConfigMap 中的配置，这也就是第一点将有状态服的配置抽离到 ConfigMap 中来，这样前期批改配置就只须要更改 ConfigMap 就行了
• 有状态服务必须应用 PVC 长久化数据
  每个 MySQL 都会用本人的数据存储，那么在 k8s 中存在一个专门存储数据的空间，也就是下面提到的 PVC，每一个 MySQL 都会调配一个 PVC 数据存储空间，或者共享一个 PVC 空间，也就是想 Docker 挂载进去的 data 目录一样，在 Docker 中的 MySQL 容器重启后 MySQL 中的数据还存在，那么 k8s 中的 MySQL 挂掉后重启后也会在 PVC 中找长久化的数据，那么这样就不会存在在其余节点拉起 MySQL 存在数据失落的问题了
• 服务集群内拜访应用 DNS 提供稳固的域名
  在下面图中存在一个主节点 MySQL 和两个从节点 MySQL，在这个 MySQL 集群中个节点间是要互相通信拜访的，这里实现各节点间通信拜访的话就须要应用 Headless Service 服务，这个服务就是集群两头互相拜访的，在 k8s 中最小的部署单元是 pod，如 MySQL0 就是一个 pod，那么咱们将这个 pod 包装成一个 Service，同时让 k8s 为这个 Service 生成一个域名，DNS 为这个服务提供一个稳固域名，如图上为 MySQL0 这个服务提供了 mysql-0.test 域名，其余的 pod 对外裸露服务后也会提供相应的域名，那么各节点通信就能够应用域名拜访，这里提供域名的益处就是避免某台对外裸露的服务忽然挂掉了，在别的机器上拉起，那么这时的 ip 就会产生扭转，那么集群内的所有利用，包含服务本人都能够应用域名来拜访

二、创立主从有状态服务

1、创立 mysql master 有状态服务

操作步骤：
1)、根本信息：

2)、容器镜像：
设置 MySQL 容器镜像，MySQL:5.7 版本，内存设置为 2G，环境变量应用之前设置好的 MySQL 密钥。

3)、挂载存储：

这里能够挂载配置文件或密钥，所以，接下来另开一个窗口，在 配置核心 -> 配置，创立配置文件：

①、创立配置根本信息

②、设置 mysql 配置文件
my.cnf

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
#master-slaver repication
server_id=1
log-bin=mysql-bin
read-only=0
binlog-do-db=gulimall_ums
binlog-do-db=gulimall_pms
binlog-do-db=gulimall_oms
binlog-do-db=gulimall_sms
binlog-do-db=gulimall_wms
binlog-do-db=gulimall_admin
replicate-ignore-db=mysql
replicate-ignore-db=sys
replicate-ignore-db=information_schema
replicate-ignore-db=performance_schema

my.cnf 配置内容间接复制粘贴到如下文本框内即可，kubesphere 提供了可视化界面，也提供了 yaml 编辑模式，咱们能够点击编辑模式查看 yaml 文件是如何写的。

mysql-master-cnf.yaml 编辑模式：

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: gulimall
  labels:
    app: mysql-master-cnf
  name: mysql-master-cnf
  annotations:
    kubesphere.io/alias-name: master 配置
spec:
  template:
    metadata:
      labels:
        app: mysql-master-cnf
data:
  my.cnf: |-
    [client]
    default-character-set=utf8
    [mysql]
    default-character-set=utf8
    [mysqld]
    init_connect='SET collation_connection = utf8_unicode_ci'
    init_connect='SET NAMES utf8'
    character-set-server=utf8
    collation-server=utf8_unicode_ci
    skip-character-set-client-handshake
    skip-name-resolve
    #master-slaver repication
    server_id=1
    log-bin=mysql-bin
    read-only=0
    binlog-do-db=gulimall_ums
    binlog-do-db=gulimall_pms
    binlog-do-db=gulimall_oms
    binlog-do-db=gulimall_sms
    binlog-do-db=gulimall_wms
    binlog-do-db=gulimall_admin
    replicate-ignore-db=mysql
    replicate-ignore-db=sys
    replicate-ignore-db=information_schema
    replicate-ignore-db=performance_schema

配置设置好之后，而后点击创立就创立好了：

4)、创立存储 PVC
存储卷 -> 创立

①、根本信息设置

②、存储卷设置

因为在装置 kubesphere 时没有创立 openebs 存储卷，所以，这里只能选 local，应该须要创立 openebs。

通过图形化界面创立好之后，咱们能够看编辑模式的 yaml：

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  namespace: gulimall
  name: gulimall-mysql-master-pvc
  labels:
    app: gulimall-mysql-master-pvc
  annotations:
    kubesphere.io/alias-name: 主节点 pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  template:
    metadata:
      labels:
        app: gulimall-mysql-master-pvc
  storageClassName: local

而后点击创立，创立好的 PVC：

5)、有状态服务 - 挂载存储
创立好配置和 PVC 之后，咱们再接着创立有状态服务的挂载存储步骤接着往下做：
配置文件挂载：

存储卷挂载：

而后点击增加，设置好的页面：

而后点击下一步，高级设置 放弃默认，而后点击创立，另外，咱们也能够看看编辑模式的 yaml 文件：

apiVersion: apps/v1
kind: StatefulSet
metadata:
  namespace: gulimall
  labels:
    app: gulimall-mysql-master
  name: gulimall-mysql-master-qpr2er
  annotations:
    kubesphere.io/alias-name: mysql 主节点
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gulimall-mysql-master
  template:
    metadata:
      labels:
        app: gulimall-mysql-master
      annotations:
        kubesphere.io/containerSecrets: null
        logging.kubesphere.io/logsidecar-config: '{}'
    spec:
      containers:
        - name: container-jbrfx9
          type: worker
          imagePullPolicy: IfNotPresent
          resources:
            requests:
              cpu: '0.01'
              memory: 10Mi
            limits:
              cpu: '0.98'
              memory: 1700Mi
          image: 'mysql:5.7'
          ports:
            - name: tcp-3306
              protocol: TCP
              containerPort: 3306
              servicePort: 3306
            - name: tcp-33060
              protocol: TCP
              containerPort: 33060
              servicePort: 33060
          env:
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: MYSQL_ROOT_PASSWORD
          volumeMounts:
            - name: volume-vvijno
              readOnly: false
              mountPath: /etc/mysql
            - name: volume-dddvwk
              readOnly: false
              mountPath: /var/lib/mysql
      serviceAccount: default
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              podAffinityTerm:
                labelSelector:
                  matchLabels:
                    app: gulimall-mysql-master
                topologyKey: kubernetes.io/hostname
      initContainers: []
      imagePullSecrets: null
      volumes:
        - name: volume-vvijno
          configMap:
            name: mysql-master-cnf
            items:
              - key: my.cnf
                path: my.cnf
        - name: volume-dddvwk
          persistentVolumeClaim:
            claimName: gulimall-mysql-master-pvc
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      partition: 0
  serviceName: gulimall-mysql-master
---
apiVersion: v1
kind: Service
metadata:
  namespace: gulimall
  labels:
    app: gulimall-mysql-master
  annotations:
    kubesphere.io/serviceType: statefulservice
    kubesphere.io/alias-name: mysql 主节点
  name: gulimall-mysql-master
spec:
  sessionAffinity: ClientIP
  selector:
    app: gulimall-mysql-master
  ports:
    - name: tcp-3306
      protocol: TCP
      port: 3306
      targetPort: 3306
    - name: tcp-33060
      protocol: TCP
      port: 33060
      targetPort: 33060
  clusterIP: None
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 10800

创立好的页面：

2、创立 mysql slaver 有状态服务

能够参考上边创立 master 服务的步骤来创立从库的服务。
①、创立从库配置挂载文件
mysql-slaver-cnf
my.cnf

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
#master-slaver repication
server_id=2
log-bin=mysql-bin
read-only=1
binlog-do-db=gulimall_ums
binlog-do-db=gulimall_pms
binlog-do-db=gulimall_oms
binlog-do-db=gulimall_wms
binlog-do-db=gulimall_admin

replicate-ignore-db=mysql
replicate-ignore-db=sys
replicate-ignore-db=information_schema
replicate-ignore-db=performance_schema

②、创立存储卷 PVC
③、创立 slaver 有状态服务

从节点创立好了：

三、配置主从

上边咱们曾经通过 k8s 创立了主从两个服务，下边通过设置将主从同步起来。

1、主库设置

进入 master 容器终端：

# 1. 进入 mysql 外部
>  mysql -uroot -p123456

# 2. 受权 root 能够近程拜访（主从无关，为了不便咱们近程连贯 MySQL）mysql> grant all privileges on *.* to 'root'@'%' identified by 'root' with grant option;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

# 3. 增加用来同步的用户
mysql> GRANT REPLICATION SLAVE ON *.* to 'backup'@'%' identified by '123456';
Query OK, 0 rows affected, 1 warning (0.01 sec)

# 4. 查看 master 状态
mysql> show master status\G;
*************************** 1. row ***************************
             File: mysql-bin.000003
         Position: 889
     Binlog_Do_DB: gulimall_ums,gulimall_pms,gulimall_oms,gulimall_sms,gulimall_wms,gulimall_admin
 Binlog_Ignore_DB:
Executed_Gtid_Set:
1 row in set (0.00 sec)

设置好之后，记录 File 文件 mysql-bin.000003，从库同步须要用到，而后 exit 退出。

2、从库设置

进入 slaver 容器终端：

# 进入 mysql 外部
mysql -uroot -p123456

# 设置主库连贯  主库 dns: gulimall-mysql-master.gulimall
change master to master_host='gulimall-mysql-master.gulimall',master_user='backup',master_password='123456',master_log_file='mysql_bin.000003',master_log_pos=0,master_port=3306;

# 启动从库同步
start slave;

# 查看从从库状态
show slave status\G;

从库报了这样的一个谬误：

mysql> show slave status\G;
*************************** 1. row ***************************
               Slave_IO_State:
                  Master_Host: gulimall-mysql-master.gulimall
                  Master_User: backup
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql_bin.000003
          Read_Master_Log_Pos: 4
               Relay_Log_File: gulimall-mysql-slaver-5mehjw-0-relay-bin.000001
                Relay_Log_Pos: 4
        Relay_Master_Log_File: mysql_bin.000003
             Slave_IO_Running: No
            Slave_SQL_Running: Yes
              Replicate_Do_DB:
          Replicate_Ignore_DB: mysql,sys,information_schema,performance_schema
  Last_IO_Errno: 1236
                Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Could not find first log file name in binary log index file'
               Last_SQL_Errno: 0
               Last_SQL_Error:

解决办法：

stop slave;
reset slave;
start slave;

而后打印从库同步状态：

能够看到曾经设置胜利了。

3、测试主从是否同步

主库创立一个数据库：

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

mysql> CREATE DATABASE `gulimall_oms` DEFAULT CHARACTER SET utf8mb4;
Query OK, 1 row affected (0.01 sec)

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| gulimall_oms       |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

进入从库：

能够看到从库也曾经同步了刚在主库创立的 gulimall_oms 库，至此咱们在 K8S 上的主从服务曾经创立实现。

相干文章：
Digtime.cn- 部署 -92-K8S 部署 MySQL 主从
K8S 部署有状态服务
Kubernetes（k8s）有状态集群服务部署与治理