AWS EKS运行有状态应用Mysql8.0集群（读写分离）

yuanzelong

已于 2022-03-24 15:37:14 修改

阅读量1.3k

点赞数

分类专栏： kubernetes 文章标签： kubernetes aws mysql 容器

于 2022-03-23 21:56:35 首次发布

本文链接：https://blog.csdn.net/yuanzelong/article/details/123690487

版权

kubernetes 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

阅读本文时，我认为你已经具备kubernets基础，已经创建好了AWS EKS集群，并且能够使用kubectl管理集群。

1、概述

一般我们采用mysq作为数据库时，常用的是mysql5.x或mysql8.x版本。

数据库实例类型有单机版、高可用版、读写分离集群版。前两种都比较容易实现。

今天我们来实现mysql8.0.26版本的读写分离，并且同步复制时采用密码方式。

为了更好地适应生产环境，以及后续的便利性，我们需要用到namespace（ns）、Configmap（cm），Secret，Service（svc），StatefulSet（sts）。

首先，描述一下我们想要部署的“有状态应用”。

1.是一个“主从复制”（Maser-Slave Replication）的 MySQL 集群；

2.有 1 个主节点（Master）；有多个从节点（Slave）；从节点需要能水平扩展；

3.所有的写操作，只能在主节点上执行；读操作可以在所有节点上执行。

这个主从模式的 MySQL 集群非常典型。我们通过一张图来表示。

2、存储

如果是自建kubernetes集群，你不懂golang开发的话，很难编写出CSI存储插件，存储类型可能会是你非常头疼的事情，但我们采用AWS EKS，这会让我们非常省心，因为AWS EKS已经帮我们做好了storageClass。采用storageClass，能够自动创建相应的pv和pvc，非常方便。

运行有状态应用Mysql，我们需要用到块存储，即AWS EBS。

AWS EBS存储类型有：io1，gp2，gp3，sc1，st1。存储类型区别详见Amazon EBS volume types - Amazon Elastic Compute Cloud。默认值：gp2。

通过如下命令，可以查看AWS EKS帮我们做好的storageClass。默认只有gp2类型的，我们可以直接使用。

$ kubectl get storageclass   #或 $kubectl get sc

#会输出如下内容

NAME              PROVISIONER                 AGE

gp2 (default)   kubernetes.io/aws-ebs   37m

这个storageClass非常容易实现，它是由gp2-storage-class.yaml这个文件生成的，内容如下：

apiVersion: storage.k8s.io/v1

kind: StorageClass

metadata:

  name: gp2

annotations:    storageclass.kubernetes.io/is-default-class: "true"

provisioner: kubernetes.io/aws-ebs

parameters:

  type: gp2

  fsType: ext4

如果，你想用其它类型的StorageClass，可以将配置文件中的type，更改为其它，如gp3。通过如下命令，即可创建。

$ kubectl create -f gp2-storage-class.yaml

3、命名空间namespace

配置文件中，如果没有指定namespace，默认会自动使用default，在生产环境中，最好是单独创建个命名空间，创建方法

mysql-ns.yaml

apiVersion: v1

kind: Namespace

metadata:

  name: mysql

接下来使用如下命令创建namespace

$kubectl create -f mysql-ns.yaml

记得在secret、statufulset文件中，加上如下一行。

metadata

  namespace: mysql

4、密钥Secret

我们将数据库的帐号密码存在Secret中。

Secret 对象要求这些数据必须是经过 Base64 转码的，以免出现明文密码的安全隐患。这个转码操作也很简单，比如：

$ echo -n 'root' |base64

cm9vdA==

$ echo -n '123456' |base64

MTIzNDU2

然后使用如下文件如 mysql-secret.yaml

apiVersion: v1

kind: Secret

metadata:

  name: prod-db-secret

  namespace: mysql

type: Opaque

data:

  password: MTIzNDU2

  username: cm9vdA==

接下来，我们尝试一下创建这个 Secret：

$ kubectl create -f mysql-secret.yaml

5、配置ConfigMap

可能以前我们习惯在Deployment或Statufulset中写配置文件，我建议生产环境中，配置文件采用configmap。

做mysql读写分离时，Master 节点和 Slave 节点需要有不同的配置文件。

内容如下mysql-config.yaml

apiVersion: v1

kind: ConfigMap

metadata:

  name: mysql

  namespace: mysql

  labels:

    app: mysql

data:

  master.cnf: |

    [mysqld]

    log-bin

  

  slave.cnf: |

    [mysqld]   

    super-read-only

    relay_log_info_repository=table

    master_info_repository=table

    relay_log_recovery = 1

接下来，我们尝试一下创建这个 configmap：

$ kubectl create -f mysql-configmap.yaml

如果你的程序是之前一直是在mysql5.7上运行，你可能会用到如下configMap

apiVersion: v1

kind: ConfigMap

metadata:

  name: mysql

  namespace: mysql

  labels:

    app: mysql

data:

  master.cnf: |

    [client]

    default-character-set=utf8mb4

    [mysql]

    default-character-set=utf8mb4

    [mysqld]

    log-bin

    binlog_expire_logs_seconds=2592000

    max_connections=10000

    binlog_format=MIXED

    explicit_defaults_for_timestamp=true

    lower_case_table_names=1

    max_allowed_packet=128M

    innodb-log-file-size=64M

    default-time-zone='+8:00'

    default-authentication-plugin=mysql_native_password

    character-set-client-handshake=FALSE

    character-set-server=utf8mb4

    collation-server=utf8mb4_unicode_ci

    init_connect='SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci'

    secure_file_priv=/var/lib/mysql

sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION

  slave.cnf: |

    [client]

    default-character-set=utf8mb4

    [mysql]

    default-character-set=utf8mb4

    [mysqld]   

    super-read-only

    max_connections=10000

    binlog_format=MIXED

    relay_log_info_repository=table

    master_info_repository=table

    relay_log_recovery = 1

    explicit_defaults_for_timestamp=true

    lower_case_table_names=1

    max_allowed_packet=128M

    innodb-log-file-size=64M

    default-time-zone='+8:00'

    default-authentication-plugin=mysql_native_password

    character-set-client-handshake=FALSE

    character-set-server=utf8mb4

    collation-server=utf8mb4_unicode_ci

    init_connect='SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci'

    secure_file_priv=/var/lib/mysql

sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION

#如果CM配置文件slave.cnf部分没有relay_log_info_repository=table、master_info_repository=table和relay_log_recovery=1那么最后一个从节点，始终不会正常。

6、服务Service

6.1集群内部访问

我们通过Headless Service来实现集群内部的访问，见配置文件。

mysql-service.yaml

apiVersion: v1

kind: Service

metadata:

  name: mysql

  namespace: mysql

  labels:

    app: mysql

spec:

  ports:

  - name: mysql

    port: 3306

  clusterIP: None

  selector:

    app: mysql

---

apiVersion: v1

kind: Service

metadata:

  name: mysql-read

  namespace: mysql

  labels:

    app: mysql

spec:

  ports:

  - name: mysql

    port: 3306

  selector:

    app: mysql

6.2集群外部访问

如果你想通过navicat等工具，远程连接数据库，可以通过如下两种方法。

方法一：通过nodePort，访问方式： nodeIP:30006

mysql-service-nodeport.yaml

#可读写

apiVersion: v1

kind: Service

metadata:

  name: mysql-node-rw

  namespace: mysql

  labels:

    app: mysql

spec:

  ports:

  - port: 3306

    nodePort: 30306

    targetPort: 3306

    name: mysql

  type: NodePort

  selector:

    statefulset.kubernetes.io/pod-name: mysql-0

方法二：通过LB,推荐选用此方式，AWS会自动帮我们创建好LB，并做好配置。访问方式: lb公网IP:23306

mysql-service-lb.yaml

kind: Service

apiVersion: v1

metadata:

  name: mysql-lb-rw

  namespace: mysql

spec:

  ports:

  - port: 23306 #这个端口就是公网IP的端口

    targetPort: 3306

    #nodePort: 31258  #如果你想指定work节点的端口，可以加上这行。

  selector:

    statefulset.kubernetes.io/pod-name: mysql-0

  type: LoadBalancer

若是访问只读实例，将serivce文件中selector改为如下内容，即可

 selector:

   app: mysql

7、使用StatefulSet运行有状态应用

最关键的来了。

在此配置文件中，能看到有initContainers，它的优先级最高。它包含了mysql容器和sidecar容器，它的作用主要用来主从节点初始化，及拷贝配置文件。 containers中也包含了mysql容器和sidecar容器，后续常态化运行这个containers。

其中sidecar容器的镜像 yuanzl/xtrabackup:2.0支持mysql8.0.26，mysql8.0.26以上版本不支持，如果mysql版本更高，需要重新做Docker镜像。

非常关键的，在配置文件中，能够看到volumeClaimTemplates的配置。只要在这部分配置文件中指定，我们需要的存储类型，容量等参数，EKS集群，会自动帮我们创建并绑定好pv和pvc。

本配置文件中，我声明了，我需要gp2类型的存储，容量为10G，访问方式为ReadWriteOnce（即只能挂在1个worker节点）。另外我声明了 resources，即容器运行时的cpu和内存，可以根据需求更改。

mysql-statefulset.yaml

apiVersion: apps/v1

kind: StatefulSet

metadata:

  name: mysql

  namespace: mysql

spec:

  selector:

    matchLabels:

      app: mysql

  serviceName: mysql

  replicas: 3

  template:

    metadata:

      labels:

        app: mysql

    spec:

      initContainers:

      - name: init-mysql

        image: mysql:8.0.26

        imagePullPolicy: IfNotPresent

        env:

        - name: TZ

          value: Asia/Shanghai

        command:

        - bash

        - "-c"

        - |

          set -ex

          # 使用pod ordinal index生成 mysql server-id.

          [[ `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

          # 从configmap拷贝配置 到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: yuanzl/xtrabackup:2.0

        imagePullPolicy: IfNotPresent

        command:

        - bash

        - "-c"

        - |

          set -ex

          # 如果data存在则跳过.

          [[ -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:8.0.26

        imagePullPolicy: IfNotPresent

        env:

        - name: TZ

          value: Asia/Shanghai

          # 使用secret

        - name: MYSQL_ROOT_PASSWORD

          valueFrom:

            secretKeyRef:

              name: prod-db-secret

              key: password

        ports:

        - name: mysql

          containerPort: 3306

        volumeMounts:

        - name: data

          mountPath: /var/lib/mysql

          subPath: mysql

        - name: conf

          mountPath: /etc/mysql/conf.d

        livenessProbe:

          exec:

            command:

            - /bin/sh

            - "-c"

            - MYSQL_PWD="${MYSQL_ROOT_PASSWORD}"

            - mysqladmin ping"

          initialDelaySeconds: 30

          periodSeconds: 10

          timeoutSeconds: 5

        readinessProbe:

          exec:

            command:

            - /bin/sh

            - "-c"

            - MYSQL_PWD="${MYSQL_ROOT_PASSWORD}"

            - mysql -h 127.0.0.1 -u root -e "SELECT 1"

          initialDelaySeconds: 5

          periodSeconds: 2

          timeoutSeconds: 1

      - name: xtrabackup

        image: yuanzl/xtrabackup:2.0

        imagePullPolicy: IfNotPresent

        ports:

        - name: xtrabackup

          containerPort: 3307

        env:

        - name: MYSQL_ROOT_PASSWORD

          valueFrom:

            secretKeyRef:

              name: prod-db-secret

              key: password

        command:

        - bash

        - "-c"

        - |

          set -ex

          cd /var/lib/mysql

          #cat /etc/hosts



          # 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 -uroot -p${MYSQL_ROOT_PASSWORD} -e "SELECT 1"; do sleep 1; done



            echo "Initializing replication from clone position"

            mv change_master_to.sql.in change_master_to.sql.orig

            mysql -h 127.0.0.1 -uroot -p${MYSQL_ROOT_PASSWORD} <<EOF

            $(<change_master_to.sql.orig),

            MASTER_HOST='mysql-0.mysql',

            MASTER_USER='root',

            MASTER_PASSWORD='${MYSQL_ROOT_PASSWORD}',

            MASTER_CONNECT_RETRY=10;

            START SLAVE;

          EOF

          echo "master slave config ok"

          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 --password=${MYSQL_ROOT_PASSWORD}"         

        volumeMounts:

        - name: data

          mountPath: /var/lib/mysql

          subPath: mysql

        - name: conf

          mountPath: /etc/mysql/conf.d

      volumes:

      - name: conf

        emptyDir: {}

      - name: config-map

        configMap:

          name: mysql

  volumeClaimTemplates:

  - metadata:

      name: data

    spec:

      accessModes:

        - "ReadWriteOnce"

      resources:

        requests:

          storage: "1G"

      storageClassName: gp2

然后，我们就可以创建这个 StatefulSet 了，如下所示：

$ kubectl create -f mysql-statefulset.yaml

$ kubectl get pod -l app=mysql -n mysql

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

8、验证

现在，mysql集群已经正常运行，我们可以尝试向这个 MySQL 集群发起写请求，执行一些 SQL 操作来验证它是否正常。

注意，写请求用的是mysql-0.mysql，并且指定了namespace

$ kubectl run mysql-client --image=mysql:8.0.26 -i --rm --restart=Never -n mysql --\

   mysql -h mysql-0.mysql -uroot -p123456 <<EOF

CREATE DATABASE test;

CREATE TABLE test.messages (message VARCHAR(250));

INSERT INTO test.messages VALUES ('hello');

EOF

通过连接 mysql-read 这个 Service，我们就可以用 SQL 进行读操作，如下所示：

$ kubectl run mysql-client --image=mysql:8.0.26 -i -t --rm --restart=Never -n mysql --\

   mysql -h mysql-read  -uroot -p123456 -e "SELECT * FROM test.messages"

mysql: [Warning] Using a password on the command line interface can be insecure.

+---------+

| message |

+---------+

| hello   |

+---------+

pod "mysql-client" deleted

在互联网上，使用Navicat，通过AWS EKS，自动创建的lb的公网IP，也可以正常访问。

另外，我们可以通过如下命令扩展集群

$ kubectl scale statefulset mysql  --replicas=5

yuanzelong

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AWS EKS运行有状态应用Mysql8.0集群（读写分离）

阅读本文时，我认为你已经具备kubernets基础，已经创建好了AWS EKS集群，并且能够使用kubectl管理集群。1、概述一般我们采用mysq作为数据库时，常用的是mysql5.x或mysql8.x版本。数据库实例类型有单机版、高可用版、读写分离集群版。前两种都比较容易实现。今天我们来实现mysql8.0.26版本的读写分离，并且同步复制时采用密码方式。为了更好地适应生产环境，以及后续的便利性，我们需要用到namespace（ns）、Configmap（cm），Secret，..
复制链接

扫一扫