k8s的云原生应用部署-mysql和wordpress

在已经建立有k8s集群的前提下，使用deploy，部署一个单独pod的单点mysql，部署一个4pod的wordpress应用。

应用的数据库使用mysql，mysql和应用都做集群外服务暴露。

通过该应用部署的练习，了解中等难度应用程序如何做云原生状态下的部署，并掌握以下k8s资源-APIServer的使用：

NameSpace、PV、ConfigMap、Secret、PVC、Deployment、NodePort类型的Service。

进行该练习的背景知识，有：

（1）能够独立搭建一套1master、3worker的k8s集群；

（2）能够在k8s上部署一个简单无状态的nginx应用；

（3）对NFS存储有一定的了解。

完成练习后，本练习中创建的数据库+网站应用，可以作为后续练习的基础和背景板。

一、规划

1 节点规划

5个节点：1个master，3个worker，1个独立的NFS server。

基础OS为Ubuntu22.04.3，版本代号jammy，内核5.15.0-91-generic。

节点的统一域名为beety.com。

假设整套k8s环境上已经装好k8s，各项功能运转正常；nfs server已经建立，k8s集群的worker可以正产挂载目录。

假设全部5个节点，主机长名、短名互相可见（使用DNS或绑定hosts表均可）

2 应用版本规划

k8s：containerd 1.6.26, kubernetes 1.28.2，flannel cniVersion 0.3.1

nfs：操作系统级别，Ubuntu22.04.3的镜像源提供的nfs-kernel-server（服务器端）、nfs-common（客户端）

nfs协议：需要nfs server支持NFS4.1版本的协议。

mysql：MySQL Community Server 8.0.19官方docker镜像

wordpress：6-apache（2023年12月31日的latest，wordpress版本6.4.2），官方docker镜像

3 存储规划

nfs server提供共享目录：

repo01.beety.com:/data/nfs/share01，该目录供mysql存放数据文件使用。

repo01.beety.com:/data/nfs/share02，该目录共wordpress存放网页文件使用。

4 k8s资源规划

（1）公用

已经建立好一个k8s集群环境。

使用独立的namespace做本次应用部署，取名mywebapp。

建立一个k8s全局级别的PersistentVolume（PV），nfspv01，指向上面的nfs share01目录。

建立一个k8s全局级别的PersistentVolume（PV），nfspv02，指向上面的nfs share02目录。

（2）mysql

主配置文件my.cnf，配置为ConfigMap。

root口令配置为secret。

为mysql创建一个PersistentVolumeClaim（PVC），指向全局PV nfspv01，用于存放数据库文件。

为mysql应用创建一个pod，引用上面的ConfigMap、secret、PVC，另外为了统一时区，引用pod所在节点本地的/etc/localtime。

pod的东西向访问端口3306，南北向访问端口30336。使用NodePort类型的service资源在南北方向暴露该端口。

（3）wordpress

mysql中数据库db02，用户wordpress给与db02全库权限，口令123456，用来存放wordpress基础数据。

wordpress调用的mysql URL、用户名、口令，使用secret存储。

一个PersistentVolumeClaim（PVC），指向第二个全局PV nfspv02，用于存放网页文件。

为wordpress应用deploy 4个pod，引用上面的secret、PVC。

pod的东西向访问端口80，南北向访问端口30080。使用NodePort类型的service资源在南北方向暴露该端口。

二、验证NFS可用

首先确认worker的3个节点作为nfs client，可以使用nfs server。nfs server的安装配置以及client的挂载方法，参考本文附件一。

能够使用的前提，是worker3节点能够访问nfs server的111、2049两个端口。

注意后面在让pod使用nfs时，并不会在worker节点上直接挂载，而是通过PV、PVC的定义，让pod使用，因此这里只是验证，挂载成功后需要摘掉并删除挂载目录。

在任意或全部worker节点上：

showmount -e repo01.beety.com
###正确回显
Export list for repo01.beety.com:
Export list for localhost:
/data/nfs/share02 *
/data/nfs/share01 *
###回显完
mkdir /tmp001
mount -t nfs -o soft,timeo=200,retrans=3,retry=1 repo01.beety.com:/data/nfs/share01 /tmp001
df -h | grep repo01.beety.com     #(确保成功挂载)
umount /tmp001
rm -r /tmp001

三、准备工作

1 目录准备

在m01节点上为后续各个资源的yaml声明文件做目录准备，mysql和wordpress各一个

mkdir -p ~/k8sapp01/20231229/{global,mysql,wordpress}

全局PV的声明放在global中，mysql和wordpress对应的声明存放在各自目录中，后面不在赘述。

2 独立的命名空间

为本次部署创建独立的namespace：mywebapp

kubectl create namespace mywebapp

后面所有为此次部署而apply的k8s资源，除了无namespace分隔的PV，其他都会创建在mywebapp这个namespace中。

3 全局PV

声明global_pv.yaml

## 第一个PV
apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfspv01
  labels:
    app: nfspv01                  #设置 pv 的 label 标签
spec:
  capacity:
    storage: 2Gi                  #设置 pv 存储资源大小 
  accessModes:
  - ReadWriteOnce
  mountOptions:
  - soft
  - nfsvers=4.1
  nfs:                            #指定使用 NFS 存储驱动
    server: repo01.beety.com      #指定 NFS 服务器 IP 地址
    path: /data/nfs/share01       #指定 NFS 共享目录的位置
  persistentVolumeReclaimPolicy: Retain
---
## 第二个PV
apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfspv02
  labels:
    app: nfspv02                  #设置 pv 的 label 标签
spec:
  capacity:
    storage: 1Gi                  #设置 pv 存储资源大小 
  accessModes:
  - ReadWriteMany                 #相比上一个PV这里可以多路读写
  mountOptions:
  - soft
  - nfsvers=4.1
  nfs:                            #指定使用 NFS 存储驱动
    server: repo01.beety.com      #指定 NFS 服务器 IP 地址
    path: /data/nfs/share02       #指定 NFS 共享目录的位置
  persistentVolumeReclaimPolicy: Retain

直接apply，应用该声明，创建PV

kubectl apply -f global_pv.yaml --dry-run=client
kubectl apply -f global_pv.yaml
kubectl get pv
#回显
NAME      CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS     CLAIM               STORAGECLASS   REASON   AGE
nfspv01   2Gi        RWO            Retain           Available                                              5s
nfspv02   1Gi        RWX            Retain           Available                                              5s

四、mysql应用

1 ConfigMap声明

按照规划，将mysql的主配置文件my.cnf，作为ConfigMap资源，放在etcd中。

mysql-config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: mysql-config
  labels:
    app: mysql
data:
  my.cnf: |-
    [client]
    default-character-set=utf8mb4
    [mysql]
    default-character-set=utf8mb4
    [mysqld]
    innodb_file_per_table=ON
    max_connections = 2000
    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

这里的mysql-config作为一个ConfigMap资源，会被后面的deploy引用。

2 secret声明

按照规划，制作base64的暗文，声明secret。

echo -n "root" | base64
#回显base加密后的用户名密文
cm9vdA==
echo -n "123456" | base64
#回显base64加密后的口令密文
MTIzNDU2

mysql-root-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: mysql-root-secret
type: Opaque
data:
  username: cm9vdA==
  password: MTIzNDU2

后面声明deploy的yaml中，将引用mysql-root-secret这个secretKeyRef，并指定获取key=password这个变量的值。

3 Storage声明

按照规划，创建一个PVC，指向PV nfspv01。

mysql-storage.yaml

## PVC
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: mysqlpvc
spec:
  resources:
    requests:
      storage: 2Gi        #设置 pvc 存储资源大小
  accessModes:
  - ReadWriteOnce
  selector:
    matchLabels:
      app: nfspv01        #根据 Label 选择对应 PV

这里的mysqlpvc作为一个PVC资源，会被后面的deploy引用。

4 deploy声明

按照规划配置pod

mysql-deploy.yaml

## Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql01
  labels:
    app: mysql01
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql01
  template:
    metadata:
      labels:
        app: mysql01
    spec:
      containers:
      - name: mysqlcontainer
        image: mysql:8.0.19
        ports:
        - containerPort: 3306
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-root-secret
              key: password
        resources:
          limits:
            cpu: 2000m
            memory: 512Mi
          requests:
            cpu: 2000m
            memory: 512Mi
        livenessProbe:
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 3
          exec:
            command: ["mysqladmin", "-uroot", "-p${MYSQL_ROOT_PASSWORD}", "ping"]
        readinessProbe:
          initialDelaySeconds: 10
          periodSeconds: 10
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 3
          exec:
            command: ["mysqladmin", "-uroot", "-p${MYSQL_ROOT_PASSWORD}", "ping"]
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
        - name: config
          mountPath: /etc/mysql/conf.d/my.cnf
          subPath: my.cnf
        - name: localtime
          readOnly: true
          mountPath: /etc/localtime
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: mysqlpvc
      - name: config
        configMap:
          name: mysql-config
      - name: localtime
        hostPath:
          type: File
          path: /etc/localtime

5 service声明

按照规划为mysql建立一个NodePort类型的SVC。

## Service
apiVersion: v1
kind: Service
metadata:
  name: mysqlsvc
  labels:
    app: mysqlsvc
spec:
  type: NodePort
  ports:
  - name: mysql
    port: 3306
    targetPort: 3306
    nodePort: 30336
  selector:
    app: mysql01

6 apply执行

ConfigMap：

kubectl apply -f mysql-config.yaml -n mywebapp --dry-run=client
kubectl apply -f mysql-config.yaml -n mywebapp
kubectl -n mywebapp get ConfigMap
#回显
NAME               DATA   AGE
kube-root-ca.crt   1      3m9s
mysql-config       1      2m49s

Secret：

kubectl apply -f mysql-root-secret.yaml -n mywebapp --dry-run=client
kubectl apply -f mysql-root-secret.yaml -n mywebapp
kubectl -n mywebapp get secret
#回显
NAME                TYPE     DATA   AGE
mysql-root-secret   Opaque   2      8s

Storage：

kubectl apply -f mysql-storage.yaml -n mywebapp --dry-run=client
kubectl apply -f mysql-storage.yaml -n mywebapp
kubectl -n mywebapp get pvc
#回显
NAME       STATUS   VOLUME    CAPACITY   ACCESS MODES   STORAGECLASS   AGE
mysqlpvc   Bound    nfspv01   2Gi        RWO                           59s

deploy：

kubectl apply -f mysql-deploy.yaml -n mywebapp --dry-run=client
kubectl apply -f mysql-deploy.yaml -n mywebapp
kubectl -n mywebapp get pod -o wide
#回显
NAME                       READY   STATUS              RESTARTS   AGE   IP            NODE   NOMINATED NODE   READINESS GATES
mysql01-695cf548cd-5zjbr   0/1     ContainerCreating   0          17s   10.244.2.26   w02    <none>           <none>
#创建完成后回显
NAME                       READY   STATUS    RESTARTS   AGE   IP            NODE   NOMINATED NODE   READINESS GATES
mysql01-695cf548cd-5zjbr   0/1     Running   0          11s   10.244.2.26   w02    <none>           <none>

查看apply deploy pod的日志

#查看pod和container日志
kubectl -n mywebapp logs mysql01-695cf548cd-5zjbr -c mysqlcontainer

service：

kubectl apply -f mysql-service.yaml -n mywebapp --dry-run=client
kubectl apply -f mysql-service.yaml -n mywebapp
kubectl -n mywebapp get service
#回显
NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
mysqlsvc   NodePort   10.107.108.12   <none>        3306:30336/TCP   7s

测试南北向暴露的端口

#在m01节点和任意worker节点上，使用iptable查看暴露的30336端口：
iptables -tnat -L | grep 30336
#回显
KUBE-EXT-W3WR2O63YWU7PI6D  tcp  --  anywhere             anywhere             /* mywebapp/mysqlsvc:mysql */ tcp dpt:30336

至此，mysql数据库在K8S集群上部署完毕，可以使用了。

7 创建mysql基本对象

为mysql数据库创建基本的数据库、用户对象

#进入pod
kubectl -n mywebapp exec -it mysql01-695cf548cd-5zjbr -- /bin/bash
#测试mysqld的状态
mysqladmin -uroot -p123456 ping
###回显：
mysqladmin: [Warning] Using a password on the command line interface can be insecure.
mysqld is alive
#以mysql的root用户进入mysql的sql命令控制台
mysql -uroot -p123456
#建立一系列基本数据库对象：
CREATE USER user01@'%' identified BY 'passw0rd';
CREATE USER user01@'localhost' identified BY 'passw0rd';
CREATE DATABASE db01;
GRANT ALL PRIVILEGES ON db01.* to user01;
FLUSH PRIVILEGES;
#退出sql命令控制台
quit;
#退出pod
exit

8 验证数据库访问

使用DataGrid等任意支持mysql的SQL客户端，建立到下面的连接

jdbc:mysql://192.168.172.141:30336/db01
用户名user01
口令123456

成功连接后，建立库内数据对象

create table db01.department
(
    dptid   int auto_increment
        primary key,
    dptname varchar(20) not null
);
insert into db01.department(dptid, dptname) values (1, "市场部");
commit;
select * from db01.department;

确保数据库正常访问。

五、wordpress应用

1 mysql建立wordpress独立数据库和用户

为wordpress建立专用的数据库、用户，并为用户授权

#进入pod
kubectl -n mywebapp exec -it mysql01-695cf548cd-5zjbr -- /bin/bash
#以mysql的root用户进入mysql的sql命令控制台
mysql -uroot -p123456
#建立数据库db02、用户wordpress：
CREATE USER wordpress@'%' identified BY 'passw0rd';
CREATE USER wordpress@'localhost' identified BY 'passw0rd';
CREATE DATABASE db02;
GRANT ALL PRIVILEGES ON db02.* to wordpress;
FLUSH PRIVILEGES;
#退出sql命令控制台
quit;
#退出pod
exit

查看mysql的接入信息

#查看mysql的pod ip信息：
kubectl get pod -n mywebapp -o wide
#回显
NAME                       READY   STATUS    RESTARTS   AGE   IP            NODE   NOMINATED NODE   READINESS GATES
mysql01-695cf548cd-5zjbr   1/1     Running   0          44h   10.244.2.26   w02    <none>           <none>
###这里的10.244.2.26就是mysql01这个pod的ip，但是为了防止变化，需要找到服务地址
kubectl get service -n mywebapp -o wide
#回显
NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE   SELECTOR
mysqlsvc   NodePort   10.107.108.12   <none>        3306:30336/TCP   44h   app=mysql01
#集群默认全局域名为cluster.local，之前为mysql和wordpress建立的额ns为mywebapp，mysql服务名为mysqlsvc
#按照集群内部的名称规则，服务的访问入口为<service_name>.<namespace_name>.svc.<domainname>
#因此应为: mysqlsvc.mywebapp.svc.cluster.local

集群内mysql01的端口号为3306，因此可以得出以下mysql访问信息：

host: mysqlsvc.mywebapp.svc.cluster.local:3306
dbname: db02
dbuser: wordpress
dbpwd: passw0rd

2 secret声明

制作base64的暗文，声明secret，包含mysql连接信息，即host、dbuser、dbpwd的值。

echo -n "mysqlsvc.mywebapp.svc.cluster.local:3306" | base64
echo -n "db02" | base64
echo -n "wordpress" | base64
echo -n "passw0rd" | base64
#分别回显base加密后的密文
bXlzcWxzdmMubXl3ZWJhcHAuc3ZjLmNsdXN0ZXIubG9jYWw6MzMwNg==
ZGIwMg==
d29yZHByZXNz
cGFzc3cwcmQ=

wordpress-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: wordpress-secret
type: Opaque
data:
  host: bXlzcWxzdmMubXl3ZWJhcHAuc3ZjLmNsdXN0ZXIubG9jYWw6MzMwNg==
  dbname: ZGIwMg==
  dbuser: d29yZHByZXNz
  dbpwd: cGFzc3cwcmQ=

3 storage声明

wordpress-storage.yaml

## PVC
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: wordpresspvc
spec:
  resources:
    requests:
      storage: 900Mi        #设置 pvc 存储资源大小
  accessModes:
  - ReadWriteMany
  selector:
    matchLabels:
      app: nfspv02        #根据 Label 选择对应 PV

这里的wordpresspvc作为一个PVC资源，会被后面的deploy引用。

4 deploy声明

按照规划配置pod

wordpress-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpressdpy
  labels:
    app: wordpress01dpy
spec:
  replicas: 4
  selector:
    matchLabels:
      app: wordpress01
  template:
    metadata:
      labels:
        app: wordpress01
    spec:
      containers:
        - name: wordpresscontainer
          image: wordpress:6-apache
          env:
            - name: WORDPRESS_DB_HOST
              valueFrom:
                secretKeyRef:
                  name: wordpress-secret
                  key: host
            - name: WORDPRESS_DB_NAME
              valueFrom:
                secretKeyRef:
                  name: wordpress-secret
                  key: dbname
            - name: WORDPRESS_DB_USER
              valueFrom:
                secretKeyRef:
                  name: wordpress-secret
                  key: dbuser
            - name: WORDPRESS_DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: wordpress-secret
                  key: dbpwd
            - name: WORDPRESS_DEBUG
              value: "true"
          volumeMounts:
            - mountPath: /var/www/html
              name: wp-data
      volumes:
        - name: wp-data
          persistentVolumeClaim:
            claimName: wordpresspvc
        - name: localtime
          hostPath:
            type: File
            path: /etc/localtime

如果想要直观一点方便调试，env部分也可以先把数据库相关环境变量写成明文

          env:
            - name: WORDPRESS_DB_HOST
              value: "mysqlsvc.mywebapp.svc.cluster.local:3306"
            - name: WORDPRESS_DB_NAME
              value: "db02"
            - name: WORDPRESS_DB_USER
              value: "wordpress"
            - name: WORDPRESS_DB_PASSWORD
              value: "passw0rd"

5 service声明

wordpress-service.yaml

## Service
apiVersion: v1
kind: Service
metadata:
  name: wordpresssvc
  labels:
    app: wordpresssvc
spec:
  type: NodePort
  ports:
  - name: wordpress
    port: 80
    targetPort: 80
    nodePort: 30080
  selector:
    app: wordpress01

6 apply执行

Secret：

kubectl apply -f wordpress-secret.yaml -n mywebapp --dry-run=client
kubectl apply -f wordpress-secret.yaml -n mywebapp
kubectl -n mywebapp get secret
#回显
NAME                TYPE     DATA   AGE
mysql-root-secret   Opaque   2      45h
wordpress-secret    Opaque   3      6s

Storage：

kubectl apply -f wordpress-storage.yaml -n mywebapp --dry-run=client
kubectl apply -f wordpress-storage.yaml -n mywebapp
kubectl -n mywebapp get pvc
#回显
NAME           STATUS   VOLUME    CAPACITY   ACCESS MODES   STORAGECLASS   AGE
mysqlpvc       Bound    nfspv01   2Gi        RWO                           45h
wordpresspvc   Bound    nfspv02   1Gi        RWX                           7s
###通过回显，看到已经按照既定规划，两个PVC处于Bound状态，绑定到既定的PV之上了

deploy：

kubectl apply -f wordpress-deploy.yaml -n mywebapp --dry-run=client
kubectl apply -f wordpress-deploy.yaml -n mywebapp
kubectl -n mywebapp get pod -o wide
#回显
NAME                             READY   STATUS              RESTARTS   AGE     IP            NODE   NOMINATED NODE   READINESS GATES
mysql01-695cf548cd-5zjbr         1/1     Running             0          45h     10.244.2.26   w02    <none>           <none>
wordpressdpy-7f795b898d-4kx7k    0/1     ContainerCreating   0          8m54s   <none>        w02    <none>           <none>
wordpressdpy-7f795b898d-97pml    0/1     ContainerCreating   0          8m54s   <none>        w03    <none>           <none>
wordpressdpy-7f795b898d-g59tk    0/1     ContainerCreating   0          8m54s   <none>        w01    <none>           <none>
wordpressdpy-7f795b898d-q4m5m    0/1     ContainerCreating   0          8m54s   <none>        w03    <none>           <none>
#创建成功后的回显
NAME                             READY   STATUS    RESTARTS   AGE   IP            NODE   NOMINATED NODE   READINESS GATES
mysql01-695cf548cd-5zjbr         1/1     Running   0          46h   10.244.2.26   w02    <none>           <none>
wordpressdpy-7f795b898d-4kx7k    1/1     Running   0          56m   10.244.2.27   w02    <none>           <none>
wordpressdpy-7f795b898d-97pml    1/1     Running   0          56m   10.244.3.24   w03    <none>           <none>
wordpressdpy-7f795b898d-g59tk    1/1     Running   0          56m   10.244.1.28   w01    <none>           <none>
wordpressdpy-7f795b898d-q4m5m    1/1     Running   0          56m   10.244.3.25   w03    <none>           <none>

查看apply deploy pod的日志

#查看pod和container日志
kubectl -n mywebapp logs wordpressdpy-7f795b898d-4kx7k -c wordpresscontainer
#回显
WordPress not found in /var/www/html - copying now...
Complete! WordPress has been successfully copied to /var/www/html
No 'wp-config.php' found in /var/www/html, but 'WORDPRESS_...' variables supplied; copying 'wp-config-docker.php' (WORDPRESS_DB_HOST WORDPRESS_DB_PASSWORD WORDPRESS_DB_USER)
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 10.244.2.27. Set the 'ServerName' directive globally to suppress this message
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 10.244.2.27. Set the 'ServerName' directive globally to suppress this message
[Tue Jan 02 15:56:40.049660 2024] [mpm_prefork:notice] [pid 1] AH00163: Apache/2.4.57 (Debian) PHP/8.2.14 configured -- resuming normal operations
[Tue Jan 02 15:56:40.049730 2024] [core:notice] [pid 1] AH00094: Command line: 'apache2 -D FOREGROUND'

service：

kubectl apply -f wordpress-service.yaml -n mywebapp --dry-run=client
kubectl apply -f wordpress-service.yaml -n mywebapp
kubectl -n mywebapp get service
#回显
NAME           TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
mysqlsvc       NodePort   10.107.108.12   <none>        3306:30336/TCP   46h
wordpresssvc   NodePort   10.98.60.145    <none>        80:30080/TCP     7s

7 验证wordpress可用

集群外，浏览器中，访问http://192.168.172.141:30080/，出现语言选择的内容，则意味着wordpress已经可以使用，且和数据库连接成功。按照步骤提示，创建应用用户，并开启自己的博客。初始化后，会在mysql的db02中，初始化12张表。

wp_commentmeta
wp_comments
wp_links
wp_options
wp_postmeta
wp_posts
wp_term_relationships
wp_term_taxonomy
wp_termmeta
wp_terms
wp_usermeta
wp_users

至此，wordpress应用部署成功。

六、环境清理

1 清除wordpress所有资源

kubectl -n mywebapp delete service wordpresssvc
kubectl -n mywebapp delete deploy wordpressdpy
kubectl -n mywebapp delete pvc wordpresspvc
kubectl -n mywebapp delete secret wordpress-secret

2 清除mysql所有资源

kubectl -n mywebapp delete service mysqlsvc
kubectl -n mywebapp delete deploy mysql01
kubectl -n mywebapp delete pvc mysqlpvc
kubectl -n mywebapp delete secret mysql-root-secret
kubectl -n mywebapp delete cm mysql-config

delete deploy时，可以同时监控pod日志

kubectl -n mywebapp logs mysql01-8545bf88cf-52xv5 -c mysqlcontainer -f

确认删除deploy时，mysql退出。

3 清除公共资源

至此，所有在mywebapp这个namespace下的资源都应该被清掉了，用下面的命令验证

kubectl get all -n mywebapp

清除namespace

kubectl delete namespace mywebapp

清除全局资源PV

kubectl delete pv nfspv01
kubectl delete pv nfspv02

别忘了清理NFS上的数据文件

#repo01节点上
cd /data/nfs/share01
rm -rf *
cd /data/nfs/share02
rm -rf *

附件

附件一 NFS服务器和客户端

（1）配置独立逻辑卷（可选）

lvcreate -L 5G -n lvdata vg00
mkfs.xfs /dev/vg00/lvdata
mkdir /data
echo "/dev/disk/by-uuid/6f709e18-61d4-4d27-b844-9c9349b5e3e9 /boot xfs defaults 0 1" >> /etc/fstab
mount -a
df -h
mkdir -p /data/nfs/share01

其中，第4行写入fstab中的卷uuid，到/dev/disk/by-uuid目录下，找到和/dev/disk/by-id下，dm-name-vg00-lvdata指向同一个dm的逻辑卷uuid，就是。

后续，将把/data/nfs/share01目录共享出去，作为mysql的数据存储卷。

（2）安装并配置nfs-server

ubuntu中的nfs-server的安装包为nfs-kernel-server，安装后服务为nfs-server，安装后会连带让rpcbind服务监听111端口。

同apt安装的其他带服务的软件一样，nfs-server安装后会自动启动且为开机启动。

ubuntu的nfs-server和其他linux分发版本完全一致，主配置文件/etc/exports，使用showmount命令查看某节点共享的nfs目录。

apt install nfs-kernel-server
cp /etc/exports /etc/exports.bak
echo "/data/nfs/share01 *(rw,sync,no_subtree_check,no_root_squash)" >> /etc/exports
systemctl restart nfs-server

（3）查看nfs支持的协议版本

这里专指nfs协议版本，非nfs-kernel-server包的ubuntu定义版本

cat /proc/fs/nfsd/versions
###回显
-2 +3 +4 +4.1 +4.2
#这里可以看到，ubuntu20+的操作系统中，默认不支持（减号）nfs2，支持（加号）3、4、4.1、4.2

nfs server支持的不同的nfs协议版本，在客户端挂载时，在参数选择上有较大差别，这个后面再客户端配置时会简单说明。

（4）验证nfs-server有效

#netstat验证111端口已经处于监听状态
netstat -tunpl | grep 111
#查看本机的共享出去的目录
showmount -e localhost
###回显
/data/nfs/share01 *
#查看nfsstat状态
nfsstat

（5）客户端

客户端只要保证能够连通服务器端的111端口和2049端口，这是前提。

mkdir /sharefs
apt install nfs-common
showmount -e <服务器端IP或主机名>
mount -t nfs <服务器端IP或主机名>:/data/nfs/share01 /sharefs
df -h | grep share01
umount /sharefs

正常情况下，通过上面的mount命令，无参数挂载服务器端/data/nfs/share01目录到客户端/share01下。注意这里尝试后，umount掉了。

如果客户端需要长期挂载nfs，包括开机就挂载，则需要慎重考虑带参数挂载，因为nfs挂载参数将很大程度上决定是客户端程序重要，还是数据存储重要。

下面给带参数的挂载命令作为参考。

mount -t nfs -o soft,timeo=200,retrans=3,retry=1 <服务器端IP或主机名>:/data/nfs/share01 /sharefs
###注意这里使用了soft软挂载方式，soft和hard（默认）哪种好的争议由来已久
###下面以nfs v4为基础，简要给出-o中的参数解释
soft     - 软挂载，非默认值，默认值为hard。选择soft后，当nfs server宕机后，soft模式client不会一直试图连接server，不会把自己的其他FS夯死。
         - 但选择soft，也就意味着server宕机后，有些等待中的数据传输被放弃了。
timeo    - 数据传输失败的超时时间，单位0.1秒，默认600即60秒。这里设为20秒，即20秒服务器端不响应，则放弃本次传输，转而找retrans参数的重试次数。
retrans  - 重试连接server的次数，默认为2。这里设为3，在soft模式下，重试3次后，client和server彻底断连，不再试图重试。
retry    - 在mount时的重试时间，单位分钟，默认为2分钟。这里设为1，即重试1分钟的mount后还连不上则放弃，如果是开机就启动连接，则这种配置不耽误开机时间。
         - 注意该参数容易和retrans混淆，retry是mount时的重试次数，retrans是建立mount以后如何应对服务器无响应的重试次数。

由于nfs v2、v3、v4版本差异较大，很多网上的攻略的配置参数还是基于v2版的，和现在主流的linux版本的nfs已经不兼容。

生产环境一定要再客户端中，使用man nfs，查看参数说明，谨慎选择参数。

开机就有nfs的挂载，可以将nfs挂载固定到fstab中

#与上面相同参数的fstab挂载
echo "<服务器端IP或主机名>:/data/nfs/share01 /sharefs  nfs  soft,timeo=200,retrans=3,retry=1   0  0" >> /etc/fstab

附件二 deploy环境变量和secret

本次应用部署中，使用了secret资源+在deploy mysql时调用secret资源获取环境变量的方式。这种调用有以下三种选择。

（1）deploy中直接写环境变量的值

        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "123456"

这种直接给出password的值的方式，最直观，也最不安全。

（2）deploy中环境变量使用从secret中获得的某个提前定义的密文的明文值

        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-root-secret
              key: password

正文中就是采取这种方式，value改为了valueFrom，调用secretKeyRef的name为mysql-root-secret，从里面拿到key password的value，作为password。

这种方式相比第一种安全了一些。前提是要先创建一个secret资源。创建该secret资源的方式，在正文中有详细给出，这里不再给。

这里给出手工生成secret声明的yaml内容的方式

kubectl create secret generic mysql-root-secret --from-literal=username=root --from-literal=password=123456 -o yaml
#回显
apiVersion: v1
data:
  password: MTIzNDU2
  username: cm9vdA==
kind: Secret
metadata:
  creationTimestamp: "2023-12-31T17:06:29Z"
  name: mysql-root-secret
  namespace: default
  resourceVersion: "961623"
  uid: cae5bd15-5428-4a1f-9c6e-2f0149745a39
type: Opaque

实际上正文的mysql-root-secret.yaml，就是在这个输出的基础上改的。

（3）同（2），但使用kubectl create手工生成时，不想写明文被操作系统history记录，则可以采用--from-file的方式

kubectl create secret generic try-secret --from-literal=username=root --from-file=password=./password.txt --dry-run=client -o yaml
#回显
apiVersion: v1
data:
  password: MTIzNDU2Cg==
  username: cm9vdA==
kind: Secret
metadata:
  creationTimestamp: "2024-01-01T16:07:38Z"
  name: try-secret
  namespace: default
  resourceVersion: "1094469"
  uid: 4c30a7d4-d50d-40bd-94c9-ccb86a620d33
type: Opaque

之后再组织yaml即可。from file方式也可以用于将私钥文件、证书文件等进行加密。

注：使用base64编码解码

#编码
echo "Welcome to Linux" | base64
#解码
echo "MTIzNDU2Cg==" | base64 --decode

（全文完）

本栏目推荐文章
• Jmeter 如何连接mysql数据库？
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 【LeetCode 2701. 连续递增交易】MySQL用户变量编程得到严格递增连续子序列的开始位置，结束位置，长度等统计信息
• k8s核心组件介绍
• 【Leetcode 2474. 购买量严格增加的客户】MySQL用户变量编程解决严格递增连续子序列问题
• mysql发生连接异常Cause: com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure
• 【LeetCode 2494. 合并在同一个大厅重叠的活动】MySQL用户变量编程解决区间合并问题
• 如何处理Mysql死锁
• k8s安装
• 【LeetCode1747. 应该被禁止的 Leetflex 账户】MySQL用户变量编程；尝试维护一个multiset

wordpress mysql k8s k8 8swordpress mysql k8s k8 实战wordpress案例k8s mysql k8s k8 8s mysql for k8s 8s k8s k8s k8 8s centos7 centos k8s 8s ingress k8s k8 8s k8s pvc k8 8s docker k8s 8s k8