三个步骤

1. VMware安装虚拟机
2. 部署k8s集群
3. 部署MySQL应用

前两个步骤主要是参考文章 《VMware虚拟机部署k8s集群》
最后一个步骤主要是参考文章 《k8s部署单机版mysql5.6》

VMware安装虚拟机

1. 下载VMware：VMware下载地址
   (本文下载的是 VMware v16，网上有的推荐v12的，对比了一下，v16的创建虚拟机的时候比较快一点)
2. 下载CentOS7：CentOS7下载地址
   (本文采用的是图中版本的镜像文件: CentOS-7-x86_64-DVD-2009.iso)
   
3. 安装VMware软件(基本就是点击下一步，选择安装位置，不再赘述)

• 还有激活码，网上随便搜一搜即可，这里给出俩参考
  网址1
  网址2

4. 创建虚拟机

• 创建新的虚拟机
  
• 选择自定义，下一步
  
• 直接下一步
  
• 稍后安装操作系统
  
• 选择Linux，CentOS 7 64位
  
• 修改名称，选择虚拟机安装的磁盘
  
• 选择CPU数量（Master建议选2个，Node 1个就够了）
  
• 内存大小：2048MB，2GB足够了
  
• 网络
  
• IO，直接下一步
  
• 磁盘，直接下一步
  
• 创建新虚拟磁盘
  
• 默认，直接下一步
  
• 下一步
  
• 自定义硬件
  
• 选择新 CD/DVD，使用ISO映像文件，选择上面下载的 CentOS 镜像文件，然后关闭，然后完成
  
• 一个虚拟机创建完成，k8s集群中一般创建三个虚拟机，按照上述步骤操作即可

5. 安装操作系统

• 开启虚拟机
  
• 安装
  回车
  
  回车
  
• 安装指引，往下拉，找到中文，继续
  
• 往下拉，选择安装位置，直接完成即可
  
  
• 开始安装（安装期间，需要设置一下 root 用户的登录密码）
  
• 等待大约十几分钟，安装进度完成后，点击重启。

6. 网络问题

• 以root用户登录虚拟机，执行以下命令，找到文件 ifcfg-ens33

cd /etc/sysconfig/network-scripts/
ls

• 编辑该文件，设置 BOOTPROTO=dhcp 和 ONBOOT=yes

vi ifcfg-ens33

• 重启network service

service netowrk restart

• 测试一下网络是否有效，并查看一下虚拟机IP地址

ping 110.242.68.3

ip addr

• 至此，虚拟机安装完毕，网络搞定。

安装k8s集群

1. 初始化虚拟机（Master、Node 都需要初始化）

• 设置基础环境

# 关闭防火墙
systemctl stop firewalld && systemctl disable firewalld

# 关闭 SElinux
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

# 关闭 swap 分区
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

# 配置 iptables
cat <<EOF | tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF

cat <<EOF | tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sysctl --system

• 安装 docker 环境

# 安装 yum-utils
yum install -y yum-utils

# 配置 yum docker源 阿里云
yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 安装 docker 
yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7  containerd.io-1.4.6
systemctl enable docker --now

# 配置 docker 仓库源
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],   
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

# 检测一下 docker 安装效果，没有报错即为成功
docker info

# 配置 k8s 下载源
cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
   http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF

# 安装 kubelet、kubeadm、kubectl
yum install -y kubelet-1.20.9 kubeadm-1.20.9 kubectl-1.20.9 --disableexcludes=kubernetes

# 启动kubelet
sudo systemctl enable --now kubelet

• 配置 hosts，下面的 IP 是指 Master 节点的 IP 地址，让每个节点都知道 Master 节点的别名

echo "192.168.59.128 cluster_endpoint" >> /etc/hosts

2. 安装 Master 节点

• 修改hostname

hostnamectl set-hostname cluster_endpoint
# 检查一下
hostname

• 下载 master 节点所需镜像

sudo tee ./images.sh <<-'EOF'
#!/bin/bash
images=(
kube-apiserver:v1.20.9
kube-proxy:v1.20.9
kube-controller-manager:v1.20.9
kube-scheduler:v1.20.9
coredns:1.7.0
etcd:3.4.13-0
pause:3.2
)
for imageName in ${images[@]} ; do
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/$imageName
done
EOF
   
chmod +x ./images.sh && ./images.sh

• 初始化主节点

# init 只需要修改apiserver的地址即可，其他不用改变
kubeadm init \
--apiserver-advertise-address=192.168.59.128 \
--control-plane-endpoint=cluster-endpoint \
--image-repository registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images \
--kubernetes-version v1.20.9 \
--service-cidr=10.96.0.0/16 \
--pod-network-cidr=192.168.0.0/16

• 执行成功后，出现以下指引

Your Kubernetes control-plane has initialized successfully!
To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:
  kubeadm join cluster-endpoint:6443 --token 0bw6u4.gqtvp4m3s86uowkt \
    --discovery-token-ca-cert-hash sha256:c01776440ff767075ac2cb84ad9b1db7a579a0273e0ee04c24c4dddeb3b37ae1 \
    --control-plane 

Then you can join any number of worker nodes by running the following on each as root:
  kubeadm join cluster-endpoint:6443 --token 0bw6u4.gqtvp4m3s86uowkt \
    --discovery-token-ca-cert-hash sha256:c01776440ff767075ac2cb84ad9b1db7a579a0273e0ee04c24c4dddeb3b37ae1

• 分别执行上述命令，启动集群

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

export KUBECONFIG=/etc/kubernetes/admin.conf

• 安装网络插件 Calico，这里安装 v3.18，最新版已经不支持 kubernetes1.20了，可以去官网查看Calico与k8s版本之间的对应关系

curl https://docs.projectcalico.org/v3.18/manifests/calico.yaml -O
kubectl apply -f calico.yaml

3. 安装 Node 节点

• 完成上面的机器初始化
• 修改hostname

# 根据node节点设置 node1 node2
hostnamectl set-hostname k8s-node1

• 在主节点上执行该命令，查看node节点加入命令和密钥

kubeadm token create --print-join-command

• 在 node 节点上执行上述命令的输出，添加 node 节点

kubeadm join cluster-endpoint:6443 --token 0bw6u4.gqtvp4m3s86uowkt     --discovery-token-ca-cert-hash sha256:c01776440ff767075ac2cb84ad9b1db7a579a0273e0ee04c24c4dddeb3b37ae1

4. 验证 node pod 等

• 验证 pod，在添加各种节点、网络插件后，等待一段时间，主节点上看到各个pod都已处于Running状态

kubectl get pod --all-namespaces -o wide

• 验证 node，添加node后，等待一段时间各个node都处于Ready状态即可

kubectl get nodes

k8s 集群部署 MySQL

通过 PV PVC Deployment Service 来完成部署，PV完成数据的持久化映射

• 回到用户目录，创建一个文件夹

cd
mkdir data
mkdir mysql_package
cd mysql_package

• 创建PV

# 新建 PV 配置文件
vi mysql-pv.yaml

# mysql-pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  labels:
    pv: mysql-pv
spec:
  capacity:
    storage: 20Gi
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: /root/data

# 创建PV
kubectl create -f mysql-pv.yaml
# 检验
kubectl get pv

• 创建PVC

# 新建 PVC 配置文件
vi mysql-pvc.yaml

# cat mysql-pvc.yaml
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: mysql-pvc
spec:
  storageClassName: ""
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  selector:
    matchLabels:
      pv: mysql-pv

# 创建 PVC
kubectl create -f mysql-pvc.yaml
# 校验
kubectl get pvc

• 创建 Deployment

# 新建 Deployment 配置文件
vi mysql-deploy.yaml
# cat mysql-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql-deploy
spec:
  replicas: 1
  selector:
    matchLabels:
      name: mysql-ops
  template:
    metadata:
      labels:
        name: mysql-ops
    spec:
      containers:
        - name: mysql56
          image: mysql:5.6
          imagePullPolicy: IfNotPresent
          env:
          - name: MYSQL_ROOT_PASSWORD
            value: "123456"
          ports:
            - containerPort: 3306
          volumeMounts:
            - name: mysql-persistent-storage
              mountPath: "/var/lib/mysql"
      volumes:
        - name: mysql-persistent-storage
          persistentVolumeClaim:
            claimName: mysql-pvc

# 创建 Deployment
kubectl create -f mysql-deploy.yaml
# 校验
kubectl get deploy

• 创建 Service

# 新建 Service 配置文件
vi mysql-service.yaml
# cat mysql-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: mysql-svc
  labels:
    name: mysql-svc
spec:
  type: NodePort
  ports:
  - port: 3306
    protocol: TCP
    targetPort: 3306
    name: http
    nodePort: 30056
  selector:
    name: mysql-ops

# 创建 Service
kubectl create -f mysql-service.yaml
# 校验
kubectl get svc

• 连接 MySQL

等待一段时间后，k8s集群自动分配Node进行部署MySQL，通过命令查看pod对应的node

kubectl get po -o wide

从图中可以看到，部署在了k8s-node3节点

• 登录 k8s=node3 机器，查看ip，通过mysql可视化工具连接对应 ip:port，user=root，password=123456
  

• 连接成功，也可以通过对应机器上 docker 命令进入容器执行相应操作。

docker ps

# 找到对应的容器ID，进入容器，执行mysql命令
docker exec -it 0f12726aae19 /bin/bash

# 执行MySQL命令
mysql -uroot -p123456

• 数据持久化存储在了 k8s-node3 节点的 /etc/data 目录下：

• 结束