在上文 K8s Docker实践一 中我们已经基于K8s实现了最简部署，下面我们对K8s进行深入学习。
云原生-k8s核心概念
-
namespace
Namespace是kubernetes系统中的一种非常重要资源，它的主要作用是用来实现多套环境的资源隔离或者多租户的资源隔离
-
Pod
Pod可以认为是容器的封装，一个Pod中可以存在一个或者多个容器。Pod是k8s中最小的可部署单元。
-
Deployment
kubernetes很少直接控制Pod，一般都是通过Pod控制器来完成的。Pod控制器用于pod的管理，确保pod资源符合预期的状态，当pod的资源出现故障时，会尝试进行重启或重建pod。
-
Service
Service可以看作是一组同类Pod对外的访问接口。借助Service，应用可以方便地实现服务发现和负载均衡。
基础操作
namespace
默认情况下，kubernetes集群中的所有的Pod都是可以相互访问的。但是在实际中，可能不想让两个Pod之间进行互相的访问，那此时就可以将两个Pod划分到不同的namespace下。
kubernetes通过将集群内部的资源分配到不同的Namespace中，可以形成逻辑上的"组"，以方便不同的组的资源进行隔离使用和管理。
可以通过kubernetes的授权机制，将不同的namespace交给不同租户进行管理，这样就实现了多租户的资源隔离。此时还能结合kubernetes的资源配额机制，限定不同租户能占用的资源，例如CPU使用量、内存使用量等等，来实现租户可用资源的管理。
kubernetes在集群启动之后，会默认创建4个namespace：
java
# kubectl get namespace
NAME STATUS AGE
default Active 45h # 所有未指定Namespace的对象(容器)都会被分配在default命名空间
kube-node-lease Active 45h # 集群节点之间的心跳维护，v1.13开始引入
kube-public Active 45h # 此命名空间下的资源可以被所有人访问（包括未认证用户）
kube-system Active 45h # 所有由Kubernetes系统创建的资源都处于这个命名空间下面来看namespace资源（简写ns）的具体操作：
1，查看
java
# 1 查看所有的ns
[root@master ~]# kubectl get ns
NAME STATUS AGE
default Active 45h
kube-node-lease Active 45h
kube-public Active 45h
kube-system Active 45h
# 2 查看指定的ns
[root@master ~]# kubectl get ns default
NAME STATUS AGE
default Active 45h
# 3 指定输出格式 命令：kubectl get ns 名称 -o 格式参数
# kubernetes支持的格式有很多，比较常见的是wide、json、yaml（wide显示更多详细参数，json，yaml是网页格式）
[root@master ~]# kubectl get ns default -o yaml
apiVersion: v1
kind: Namespace
metadata:
creationTimestamp: "2021-05-08T04:44:16Z"
name: default
resourceVersion: "151"
selfLink: /api/v1/namespaces/default
uid: 7405f73a-e486-43d4-9db6-145f1409f090
spec:
finalizers:
- kubernetes
status:
phase: Active
# 4 查看ns详情 命令：kubectl describe ns 名称
[root@master ~]# kubectl describe ns default
Name: default
Labels: <none>
Annotations: <none>
Status: Active # Active 命名空间正在使用中 Terminating 正在删除命名空间
# ResourceQuota 针对namespace做的资源限制
# LimitRange针对namespace中的每个组件做的资源限制
No resource quota.
No LimitRange resource.2，创建删除
java
# 创建namespace
[root@master ~]# kubectl create ns dev
namespace/dev created
# 删除namespace
[root@master ~]# kubectl delete ns dev
namespace "dev" deleted3，使用配置文件（.yaml）进行管理
java
apiVersion: v1
kind: Namespace
metadata:
name: dev创建：kubectl create -f ns-dev.yaml
删除：kubectl delete -f ns-dev.yaml
Pod
Pod可以认为是容器的封装，一个Pod中可以存在一个或者多个容器。
kubernetes在集群启动之后，集群中的各个组件也都是以Pod方式运行的。可以通过下面命令查看：
java
[root@master ~]# kubectl get pod -n kube-system
NAMESPACE NAME READY STATUS RESTARTS AGE
kube-system coredns-6955765f44-68g6v 1/1 Running 0 2d1h
kube-system coredns-6955765f44-cs5r8 1/1 Running 0 2d1h
kube-system etcd-master 1/1 Running 0 2d1h
kube-system kube-apiserver-master 1/1 Running 0 2d1h
kube-system kube-controller-manager-master 1/1 Running 0 2d1h
kube-system kube-flannel-ds-amd64-47r25 1/1 Running 0 2d1h
kube-system kube-flannel-ds-amd64-ls5lh 1/1 Running 0 2d1h
kube-system kube-proxy-685tk 1/1 Running 0 2d1h
kube-system kube-proxy-87spt 1/1 Running 0 2d1h
kube-system kube-scheduler-master 1/1 Running 0 2d1h1， 创建并运行
kubernetes没有提供单独运行Pod的命令，都是通过Pod控制器来实现的
java
# 命令格式： kubectl run (pod控制器名称) [参数]
# --image 指定Pod的镜像
# --port 指定端口
# --namespace 指定namespace
[root@master ~]# kubectl run nginx --image=nginx:latest --port=80 --namespace dev
deployment.apps/nginx created
（此处就新建了一个名为nginx的pod控制器，而生成的pod名为nginx-****-****）2， 查看pod信息
java
# 查看Pod基本信息
[root@master ~]# kubectl get pods -n dev //这个pod加不加s都可以
NAME READY STATUS RESTARTS AGE
nginx 1/1 Running 0 43s
# 查看Pod的详细信息
[root@master ~]# kubectl describe pod nginx -n dev
Name: nginx
Namespace: dev
Priority: 0
Node: node1/192.168.5.4
Start Time: Wed, 08 May 2021 09:29:24 +0800
Labels: pod-template-hash=5ff7956ff6
run=nginx
Annotations: <none>
Status: Running
IP: 10.244.1.23
IPs:
IP: 10.244.1.23
Controlled By: ReplicaSet/nginx
Containers:
nginx:
Container ID: docker://4c62b8c0648d2512380f4ffa5da2c99d16e05634979973449c98e9b829f6253c
Image: nginx:latest
Image ID: docker-pullable://nginx@sha256:485b610fefec7ff6c463ced9623314a04ed67e3945b9c08d7e53a47f6d108dc7
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Wed, 08 May 2021 09:30:01 +0800
Ready: True
Restart Count: 0
Environment: <none>
Mounts:
/var/run/secrets/kubernetes.io/serviceaccount from default-token-hwvvw (ro)
Conditions:
Type Status
Initialized True
Ready True
ContainersReady True
PodScheduled True
Volumes:
default-token-hwvvw:
Type: Secret (a volume populated by a Secret)
SecretName: default-token-hwvvw
Optional: false
QoS Class: BestEffort
Node-Selectors: <none>
Tolerations: node.kubernetes.io/not-ready:NoExecute for 300s
node.kubernetes.io/unreachable:NoExecute for 300s
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled <unknown> default-scheduler Successfully assigned dev/nginx-5ff7956ff6-fg2db to node1
Normal Pulling 4m11s kubelet, node1 Pulling image "nginx:latest"
Normal Pulled 3m36s kubelet, node1 Successfully pulled image "nginx:latest"
Normal Created 3m36s kubelet, node1 Created container nginx
Normal Started 3m36s kubelet, node1 Started container nginx3， 访问Pod
java
# 获取podIP
[root@master ~]# kubectl get pods -n dev -o wide
NAME READY STATUS RESTARTS AGE IP NODE ...
nginx 1/1 Running 0 190s 10.244.1.23 node1 ...
#访问pod中部署的服务
[root@master ~]# curl 10.244.1.23:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
</head>
<body>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>4， 删除指定Pod
java
# 删除指定Pod
[root@master ~]# kubectl delete pod nginx -n dev
pod "nginx" deleted
# 此时，显示删除Pod成功，但是再查询，发现又新产生了一个
[root@master ~]# kubectl get pods -n dev
NAME READY STATUS RESTARTS AGE
nginx 1/1 Running 0 21s
# 这是因为当前Pod是由Pod控制器创建的，控制器会监控Pod状况，一旦发现Pod死亡，会立即重建
# 此时要想删除Pod，必须删除Pod控制器
# 先来查询一下当前namespace下的Pod控制器
[root@master ~]# kubectl get deploy -n dev //deploy加不加ment都可以
NAME READY UP-TO-DATE AVAILABLE AGE
nginx 1/1 1 1 9m7s
# 接下来，删除此PodPod控制器
[root@master ~]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted
# 稍等片刻，再查询Pod，发现Pod被删除了
[root@master ~]# kubectl get pods -n dev
No resources found in dev namespace.5，配置操作
创建一个pod-nginx.yaml，内容如下：
java
apiVersion: v1
kind: Pod
metadata:
name: nginx
namespace: dev
spec:
containers:
- image: nginx:latest
name: pod
ports:
- name: nginx-port
containerPort: 80
protocol: TCP创建：kubectl create -f pod-nginx.yaml
删除：kubectl delete -f pod-nginx.yaml
Label
Label是kubernetes系统中的一个重要概念。它的作用就是在资源上添加标识，用来对它们进行区分和选择。
Label的特点：
- 一个Label会以key/value键值对的形式附加到各种对象上，如Node、Pod、Service等等
- 一个资源对象可以定义任意数量的Label ，同一个Label也可以被添加到任意数量的资源对象上去
- Label通常在资源对象定义时确定，当然也可以在对象创建后动态添加或者删除
可以通过Label实现资源的多维度分组，以便灵活、方便地进行资源分配、调度、配置、部署等管理工作。一些常用的Label 示例如下：
- 版本标签："version":"release", "version":"stable"...
- 环境标签："environment":"dev"，"environment":"test"，"environment":"pro"
- 架构标签："tier":"frontend"，"tier":"backend"
Label Selector(标签选择器)用于查询和筛选拥有某些标签的资源对象
当前有两种Label Selector：
- 基于等式的Label Selector
- 基于集合的Label Selector
标签的选择条件可以使用多个，此时将多个Label Selector进行组合，使用逗号","进行分隔即可。例如：
java
name=slave，env!=production
name not in (frontend)，env!=production1，命令方式
java
# 为pod资源打标签
[root@master ~]# kubectl label pod nginx-pod version=1.0 -n dev
pod/nginx-pod labeled
# 为pod资源更新标签（--overwrite）
[root@master ~]# kubectl label pod nginx-pod version=2.0 -n dev --overwrite
pod/nginx-pod labeled
# 查看标签（--show-labels）
[root@master ~]# kubectl get pod nginx-pod -n dev --show-labels
NAME READY STATUS RESTARTS AGE LABELS
nginx-pod 1/1 Running 0 10m version=2.0
# 筛选标签(-l 标签对)
[root@master ~]# kubectl get pod -n dev -l version=2.0 --show-labels
NAME READY STATUS RESTARTS AGE LABELS
nginx-pod 1/1 Running 0 17m version=2.0
[root@master ~]# kubectl get pod -n dev -l version!=2.0 --show-labels
No resources found in dev namespace.
#删除标签（指定pod 标签的键加一个减号）
[root@master ~]# kubectl label pod nginx-pod version- -n dev
pod/nginx-pod labeled2，配置方式
java
apiVersion: v1
kind: Pod
metadata:
name: nginx
namespace: dev
labels:
version: "3.0" //标签一
env: "test" //标签二
spec:
containers:
- image: nginx:latest
name: pod
ports:
- name: nginx-port
containerPort: 80
protocol: TCPkubectl apply -f pod-nginx.yaml
Deployment
在kubernetes中，Pod是最小的控制单元，但是kubernetes很少直接控制Pod，一般都是通过Pod控制器来完成的。Pod控制器用于pod的管理，确保pod资源符合预期的状态，当pod的资源出现故障时，会尝试进行重启或重建pod。
1，命令操作
java
# 命令格式: kubectl create deployment 名称 [参数]
# --image 指定pod的镜像
# --port 指定端口
# --replicas 指定创建pod数量
# --namespace 指定namespace
[root@master ~]# kubectl run nginx --image=nginx:latest --port=80 --replicas=3 -n dev
deployment.apps/nginx created
# 查看创建的Pod
[root@master ~]# kubectl get pods -n dev
NAME READY STATUS RESTARTS AGE
nginx-5ff7956ff6-6k8cb 1/1 Running 0 19s
nginx-5ff7956ff6-jxfjt 1/1 Running 0 19s
nginx-5ff7956ff6-v6jqw 1/1 Running 0 19s
# 查看deployment的信息(简写为deploy)
[root@master ~]# kubectl get deploy -n dev
NAME READY UP-TO-DATE AVAILABLE AGE
nginx 3/3 3 3 2m42s
# UP-TO-DATE成功升级的副本数量，AVAILABLE可用副本的数量
[root@master ~]# kubectl get deploy -n dev -o wide
NAME READY UP-TO-DATE AVAILABLE AGE CONTAINERS IMAGES SELECTOR
nginx 3/3 3 3 2m51s nginx nginx:latest run=nginx
# 查看deployment的详细信息
[root@master ~]# kubectl describe deploy nginx -n dev
Name: nginx
Namespace: dev
CreationTimestamp: Wed, 08 May 2021 11:14:14 +0800
Labels: run=nginx
Annotations: deployment.kubernetes.io/revision: 1
Selector: run=nginx
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 25% max unavailable, 25% max surge
Pod Template:
Labels: run=nginx
Containers:
nginx:
Image: nginx:latest
Port: 80/TCP
Host Port: 0/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets: <none>
NewReplicaSet: nginx-5ff7956ff6 (3/3 replicas created)
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal ScalingReplicaSet 5m43s deployment-controller Scaled up replicaset nginx-5ff7956ff6 to 3
# 删除
[root@master ~]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted2，配置操作
java
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx
namespace: dev
spec:
replicas: 3
selector:
matchLabels:
run: nginx
template:
metadata:
labels:
run: nginx
spec:
containers:
- image: nginx:latest
name: nginx
ports:
- containerPort: 80
protocol: TCPtemplate：相当于模板（有点java构造函数的味道，deployment通过tmplate格式，生成pod）
replicas: 3------指副本数量
然后就可以执行对应的创建和删除命令了：
创建：kubectl create -f deploy-nginx.yaml
删除：kubectl delete -f deploy-nginx.yaml
Service
上面已经能够利用Deployment来创建一组Pod来提供具有高可用性的服务。虽然每个Pod都会分配一个单独的Pod IP，然而却存在如下两问题：
- Pod IP 会随着Pod的重建产生变化
- Pod IP 仅仅是集群内可见的虚拟IP，外部无法访问
这样对于访问这个服务带来了难度。因此，kubernetes设计了Service来解决这个问题。
Service可以看作是一组同类Pod对外的访问接口。借助Service，应用可以方便地实现服务发现和负载均衡。
1，创建集群内部可访问的Service
java
# 暴露Service（通过暴露pod管理器deployment来暴露其管理的pod）
[root@master ~]# kubectl expose deploy nginx --name=svc-nginx1 --type=ClusterIP --port=80 --target-port=80 -n dev
service/svc-nginx1 exposed
#--type=ClusterIP指定服务类型为集群内部IP------ClusterIP
# 查看service（可以简写为svc）
[root@master ~]# kubectl get svc svc-nginx1 -n dev -o wide
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
svc-nginx1 ClusterIP 10.109.179.231 <none> 80/TCP 3m51s run=nginx
# 这里产生了一个CLUSTER-IP，这就是service的IP，在Service的生命周期中，这个地址是不会变动的
# 可以通过这个IP访问当前service对应的POD（只能在当前集群内的几个结点上使用）
[root@master ~]# curl 10.109.179.231:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
</head>
<body>
<h1>Welcome to nginx!</h1>
.......
</body>
</html>2，创建集群外部也可访问的Service
java
# 上面创建的Service的type类型为ClusterIP，这个ip地址只用集群内部可访问
# 如果需要创建外部也可以访问的Service，需要修改type为NodePort
[root@master ~]# kubectl expose deploy nginx --name=svc-nginx2 --type=NodePort --port=80 --target-port=80 -n dev
service/svc-nginx2 exposed
# 此时查看，会发现出现了NodePort类型的Service，而且有一对Port（80:31928/TC）
[root@master ~]# kubectl get svc svc-nginx2 -n dev -o wide
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
svc-nginx2 NodePort 10.100.94.0 <none> 80:31928/TCP 9s run=nginx
# 接下来就可以通过集群外的主机访问 节点IP:31928访问服务了
# 例如在的电脑主机上通过浏览器访问下面的地址
http://192.168.90.100:31928/3，配置方式
创建一个svc-nginx.yaml，内容如下：
java
apiVersion: v1
kind: Service
metadata:
name: svc-nginx
namespace: dev
spec:
clusterIP: 10.109.179.231 #固定svc的内网ip
ports:
- port: 80
protocol: TCP
targetPort: 80
selector:
run: nginx
type: ClusterIP创建：kubectl create -f svc-nginx.yaml
删除：kubectl delete -f svc-nginx.yaml
单机部署实践
部署单节点mysql
基础模板
1 ，首先检查下k8s集群的系统pod状态，确保所有系统pod运行正常：
java
# kubectl get pods -n kube-system
NAME READY STATUS RESTARTS AGE
coredns-5d78c9869d-fqtjh 1/1 Running 0 2d19h
coredns-5d78c9869d-hrt4g 1/1 Running 0 2d19h
etcd-docker-desktop 1/1 Running 0 2d19h
kube-apiserver-docker-desktop 1/1 Running 0 2d19h
kube-controller-manager-docker-desktop 1/1 Running 0 2d19h
kube-proxy-rlflb 1/1 Running 0 2d19h
kube-scheduler-docker-desktop 1/1 Running 0 2d19h
storage-provisioner 1/1 Running 0 2d19h
vpnkit-controller 1/1 Running 0 2d19h2，应用mysql-deployment.yaml文件，快速创建部署一个数据库服务：
java
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-mysql
labels:
app: mysql
spec:
replicas: 3 # 副本数量
selector:
matchLabels:
app: mysql
template: # deployment通过template格式生成pod
metadata:
labels:
app: mysql
spec:
containers: # 定义容器部分
- image: mysql:latest
name: mysql
ports:
- containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: "1234"
---
apiVersion: v1
kind: Service
metadata:
name: my-db
spec:
ports:
- port: 3306
nodePort: 30011
selector:
app: mysql
type: NodePort # 集群外可访问，ClusterIP不可访问执行：
java
# kubectl apply -f mysql-deployment.yaml
deployment.apps/my-mysql created
service/my-db created查看：
java
# kubectl get all -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
pod/my-mysql-bd9978b94-gjjjd 1/1 Running 0 2m30s 10.1.0.26 docker-desktop <none> <none>
pod/my-mysql-bd9978b94-q5z5h 1/1 Running 0 2m30s 10.1.0.25 docker-desktop <none> <none>
pod/my-mysql-bd9978b94-rc9v6 1/1 Running 0 2m30s 10.1.0.24 docker-desktop <none> <none>
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
service/kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 2d19h <none>
service/my-db NodePort 10.102.141.35 <none> 3306:30011/TCP 2m30s app=mysql
NAME READY UP-TO-DATE AVAILABLE AGE CONTAINERS IMAGES SELECTOR
deployment.apps/my-mysql 3/3 3 3 2m30s mysql mysql:latest app=mysql
NAME DESIRED CURRENT READY AGE CONTAINERS IMAGES SELECTOR
replicaset.apps/my-mysql-bd9978b94 3 3 3 2m30s mysql mysql:latest app=mysql,pod-template-hash=bd9978b943，外部客户端远程访问mysql成功：
java
# mysql -h 192.168.1.6 -uroot -p1234 -P30011
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 12
Server version: 8.2.0 MySQL Community Server - GPL
Copyright (c) 2000, 2023, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql> quit
Bye1.本次实践的yaml文件可作为后续进阶学习的基础模板。
2.mysql的存储可以配置持久存储来保存数据，使用storageclass来配置持久存储；
3.安全性方面，可以配置secret来确保数据库的安全性；
4.还可以配置初始化容器，来检查pod的运行环境是否正常；
5.对于本次yaml文件，可以增加更多的功能及高级特性，进行不断的优化升级；
持久化
ConfigMap 是一种 API 对象，用来将非机密性的数据保存到键值对中。使用时， Pod 可以将其用作环境变量、命令行参数或者存储卷中的配置文件。ConfigMap 将你的环境配置信息和容器镜像解耦，便于应用配置的修改。但是注意：ConfigMap 并不提供保密或者加密功能。 如果你想存储的数据是机密的，请使用 Secret， 或者使用其他第三方工具来保证你的数据的私密性，而不是用 ConfigMap。
Secret与ConfigMap都是用来存储配置信息的，不同之处在于ConfigMap是明文存储的，而Secret用来保存敏感信息，如：密码、OAuth令牌，ssh key等等。Secret常用有三种类型：
- Opaque：使用base64编码格式存储密码等信息，加密性很弱。
- kubernetes.io/dockerconfigjson：用来存储私有docker registry的认证信息（仓库地址、登录用户名密码）。
- kubernetes.io/service-account-token：用来创建服务账号（Service Account），是一种自动被启用的用户认证机制，用来验证请求的合法性。
另外，容器中的数据是需要保留的，否则容器重启就没了，需要创建数据目录，存储 MySQL 数据；在本地创建 MySQL 数据文件夹，然后挂载到 MySQL 容器，实现 MySQL 数据的可以持久化。
下面我们通过创建 Secret 对象，将 MySQL 的用户名、密码传递到镜像中使用。
1，创建secret对象：
java
# kubectl create secret generic mysql-auth --from-literal=username=root --from-literal=password=1234
secret/mysql-auth created
# kubectl get secret mysql-auth
NAME TYPE DATA AGE
mysql-auth Opaque 2 14s
# kubectl get secret mysql-auth -o yaml
apiVersion: v1
data:
password: MTIzNA==
username: cm9vdA==
kind: Secret
metadata:
creationTimestamp: "2023-11-18T07:48:50Z"
name: mysql-auth
namespace: default
resourceVersion: "82836"
uid: 7e767963-840f-4bb6-8e9c-f452478cc8d9
type: Opaque
# echo MTIzNA== | base64 -d
1234% 2 ，yaml文件部署：
修改引用mysql-auth中的password值，并且增加volumes数据卷进行持久化：
java
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-mysql
labels:
app: mysql
spec:
replicas: 1 # 副本数量
selector:
matchLabels:
app: mysql
template: # deployment通过template格式生成pod
metadata:
labels:
app: mysql
spec:
containers: # 定义容器部分
- image: mysql:latest
name: mysql
ports:
- containerPort: 3306
volumeMounts: #挂载数据卷
- name: mysql-data
mountPath: "/mysql" #挂载到容器内的目录
env:
- name: MYSQL_ROOT_PASSWORD
valueFrom: # 读取密码
secretKeyRef:
name: mysql-auth
key: password #引用mysql-auth中的password值
volumes: #数据卷
- name: mysql-data
hostPath: #宿主机路径
path: /Users/Shared/Data #宿主机的目录
type: Directory
---
apiVersion: v1
kind: Service
metadata:
name: my-db
spec:
ports:
- port: 3306
nodePort: 30011
selector:
app: mysql
type: NodePort # 集群外可访问，ClusterIP不可访问执行：
kubectl apply -f mysql-deployment.yaml
3，验证：
java
# kubectl get all
NAME READY STATUS RESTARTS AGE
pod/my-mysql-5cdb7f574f-8nwsb 1/1 Running 0 11s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 3d1h
service/my-db NodePort 10.102.104.177 <none> 3306:30011/TCP 11s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/my-mysql 1/1 1 1 11s
NAME DESIRED CURRENT READY AGE
replicaset.apps/my-mysql-5cdb7f574f 1 1 1 11s
# 进入容器新建测试文件
# kubectl exec -it my-mysql-5cdb7f574f-8nwsb /bin/sh
kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
sh-4.4# touch /mysql/test.log
sh-4.4# exit
exit
command terminated with exit code 127
# 对应节点上可以看到文件已存在
# ls /Users/Shared/Data
test.log部署redis集群
一般来说，REDIS部署有三种模式：
- 单实例模式。一般用于测试环境。
- 哨兵模式
在redis3.0以前，要实现集群一般是借助哨兵sentinel工具来监控master节点的状态。
如果master节点异常，则会做主从切换，将某一台slave作为master。
引入了哨兵节点，部署更复杂，维护成本也比较高，并且性能和高可用性等各方面表现一般。 - 集群模式
3.0 后推出的 Redis 分布式集群解决方案
主节点提供读写操作，从节点作为备用节点，不提供请求，只作为故障转移使用
如果master节点异常，也是会自动做主从切换，将slave切换为master。
总的来说，集群模式明显优于哨兵模式。
因为redis集群，最终需要对应的文件有，redis.conf、data等
redis.conf可以是一个相同的，其他两个肯定是不一样的。因此如果同一个node的pod镜像使用 Volume 挂载文件夹部署是不能满足的。所以这里，就引出了SC、PV了。
- StorageClass：简称sc，存储类，是k8s平台为存储提供商提供存储接入的一种声明。通过sc和相应的存储插件(csi)为容器应用提供持久存储卷的能力。
- PersistentVolume简称pv，持久化存储，是k8s为云原生应用提供一种拥有独立生命周期的、用户可管理的存储的抽象设计。
1，创建SC
java
# cat redis-sc.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: redis-sc
provisioner: nfs-storage
java
# kubectl apply -f redis-sc.yaml
# kubectl get sc
NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE
hostpath (default) docker.io/hostpath Delete Immediate false 3d3h
redis-sc nfs-storage Delete Immediate false 25m2，创建PV关联SC
java
# cat redis-pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: nfs-pv1
spec:
storageClassName: redis-sc
capacity:
storage: 200M
accessModes:
- ReadWriteMany
nfs:
server: 192.168.1.6
path: "/User/Shard/Data/pv1"
---
apiVersion: v1
kind: PersistentVolume
metadata:
name: nfs-pv2
spec:
storageClassName: redis-sc
capacity:
storage: 200M
accessModes:
- ReadWriteMany
nfs:
server: 192.168.1.6
path: "/User/Shard/Data/pv2"名称为nfs-pv1，对应的storageClassName为redis-sc，capacity容器200M，accessModes访问模式可被多节点读写
对应nfs服务器192.168.1.6，对应文件夹路径path（对应安装的nfs服务器），这里我们创建2个pv.
java
# kubectl apply -f redis-pv.yaml
# kubectl get pv
NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE
nfs-pv1 200M RWX Retain Available redis-sc 6s
nfs-pv2 200M RWX Retain Available redis-sc 6s3，利用StatefulSet创建Redis 集群节点。
RC、Deployment、DaemonSet都是面向无状态的服务，它们所管理的Pod的IP、名字，启停顺序等都是随机的，而StatefulSet是什么？顾名思义，有状态的集合，管理所有有状态的服务，比如MySQL、MongoDB集群等。
StatefulSet本质上是Deployment的一种变体，在v1.9版本中已成为GA版本，它为了解决有状态服务的问题，它所管理的Pod拥有固定的Pod名称，启停顺序，在StatefulSet中，Pod名字称为网络标识(hostname)，还必须要用到共享存储。
在Deployment中，与之对应的服务是service，而在StatefulSet中与之对应的headless service。headless service，即无头服务，与service的区别就是它没有Cluster IP，解析它的名称时将返回该Headless Service对应的全部Pod的Endpoint列表。
除此之外，StatefulSet在Headless Service的基础上又为StatefulSet控制的每个Pod副本创建了一个DNS域名，这个域名的格式为：
java
$(pod.name).$(headless server.name).${namespace}.svc.cluster.local也即是说，对于有状态服务，我们最好使用固定的网络标识（如域名信息）来标记节点，当然这也需要应用程序的支持（如Zookeeper就支持在配置文件中写入主机域名）。
StatefulSet基于Headless Service（即没有Cluster IP的Service）为Pod实现了稳定的网络标志（包括Pod的hostname和DNS Records），在Pod重新调度后也保持不变。同时，结合PV/PVC，StatefulSet可以实现稳定的持久化存储，就算Pod重新调度后，还是能访问到原先的持久化数据。
以下为使用StatefulSet部署Redis的架构，无论是Master还是Slave，都作为StatefulSet的一个副本，并且数据通过PV进行持久化，对外暴露为一个Service，接受客户端请求。
java
# cat redis.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: my-redis
labels:
app: redis
spec:
replicas: 1 # 副本数量
selector:
matchLabels:
app: redis
template: # deployment通过template格式生成pod
metadata:
labels:
app: redis
spec:
containers: # 定义容器部分
- image: redis:latest
name: redis
ports:
- containerPort: 6379
volumeMounts: #挂载数据卷
- name: redis-conf
mountPath: "/etc/redis/redis.conf"
- name: redis-data
mountPath: "/data"
volumes: #数据卷
- name: redis-conf
hostPath:
path: "/Users/Shared/Data/redis.conf"
type: FileOrCreate
volumeClaimTemplates:
- metadata:
name: redis-data
spec:
accessModes: [ "ReadWriteMany" ]
resources:
requests:
storage: 200M
storageClassName: redis-sc
---
apiVersion: v1
kind: Service
metadata:
name: my-redis
spec:
ports:
- port: 6379
nodePort: 30012
selector:
app: redis
type: NodePort # 集群外可访问，ClusterIP不可访问部署springboot应用
1，dockefile准备好镜像:
java
FROM openjdk:8-jdk-alpine
COPY target/demospringboot-0.0.1-SNAPSHOT.jar F:\docker
WORKDIR F:\docker
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "demospringboot-0.0.1-SNAPSHOT.jar"]执行：
java
# docker build -f my-app-dockfile -t my-springboot-img:v1 .参考：
https://blog.csdn.net/weixin_48751167/article/details/123507306
https://zhuanlan.zhihu.com/p/631315345
https://blog.csdn.net/jks212454/article/details/130201521
https://kubernetes.io/zh-cn/docs/concepts/configuration/configmap/