Kubernetes 结构与概念

本文最后更新于 2025年8月7日 下午

Master

Master 是集群的控制节点，在每个Kubernetes集群中都需要有一个或一组Master负责管理和控制整个集群。Master通常占用一台独立的服务器，是整个集群的管理者，Master主要运行下面的一些关键进程

  • Kubernetes API Server(kube-apiserver) : 提供HTTPRESTful API 接口的主要服务，是Kubernetes中对所有资源继续增删改查等操作的唯一入口，也是集群控制的入口进程
  • Kubernetes Controller Manager(kube-controller-manager) : Kubernetes中所有资源对象的自动化控制中心。
  • Kubernetes Scheduler(kube-scheduler) : 负责资源调度（Pod调度）的进程。

Node

Node 是kubernetes中的工作负载节点，每个Node都会被Master分配负载。当某个Node状态异常时，会被Master将服务转移到其他Node上。Node上一般运行着下面这些关键进程

  • kubelet ：负责Pod对应容器的创建，启停等服务，同时与Master密切协作，实现集群管理的基本功能
  • kube-proxy ： 是实现Kubernetes Service 通信与负载均衡机制的服务
  • 容器运行时： 负责本机的容器创建和管理

Node 可以在运行期间被动增加到Kubernetes集群中，前提是这个Node上已正确 安装，配置和启动了这些关键进程

通过以下命令检查集群中的Node数量

1
2
3
# Kubectl  get nodes
NAME             STATUS          ROLES         AGE           VERSION
k8s-node-1       Ready           <none>        1d            v1.29.0

通过kubectl describe node 可以检查Node的状态信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# kubectl describe node work-node-01
Name:               worker-node-01
Roles:              <none>
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    kubernetes.io/arch=amd64
                    kubernetes.io/hostname=worker-node-01
                    kubernetes.io/os=linux
                    node.kubernetes.io/instance-type=m5.large
                    node.kubernetes.io/node-group=worker-nodes
                    topology.kubernetes.io/region=us-west-2
                    topology.kubernetes.io/zone=us-west-2a
Annotations:        kubeadm.alpha.kubernetes.io/cri-socket=unix:///var/run/containerd/containerd.sock
                    node.alpha.kubernetes.io/ttl=0
                    volumes.kubernetes.io/controller-managed-attach-detach=true
CreationTimestamp:  Mon, 15 Jul 2024 10:30:15 +0800
Taints:             <none>
Unschedulable:      false
Lease:
  HolderIdentity:  worker-node-01
  AcquireTime:     <unset>
  RenewTime:       Thu, 07 Aug 2025 14:23:45 +0800
Conditions:
  Type                 Status  LastHeartbeatTime                 LastTransitionTime                Reason                       Message
  ----                 ------  -----------------                 ------------------                ------                       -------
  NetworkUnavailable   False   Mon, 15 Jul 2024 10:32:18 +0800   Mon, 15 Jul 2024 10:32:18 +0800   WeaveIsUp                    Weave pod has set this
  MemoryPressure       False   Thu, 07 Aug 2025 14:24:12 +0800   Mon, 15 Jul 2024 10:30:15 +0800   KubeletHasSufficientMemory   kubelet has sufficient memory available
  DiskPressure         False   Thu, 07 Aug 2025 14:24:12 +0800   Mon, 15 Jul 2024 10:30:15 +0800   KubeletHasNoDiskPressure     kubelet has no disk pressure
  PIDPressure          False   Thu, 07 Aug 2025 14:24:12 +0800   Mon, 15 Jul 2024 10:30:15 +0800   KubeletHasSufficientPID      kubelet has sufficient PID available
  Ready                True    Thu, 07 Aug 2025 14:24:12 +0800   Mon, 15 Jul 2024 10:30:45 +0800   KubeletReady                 kubelet is posting ready status
Addresses:
  InternalIP:  10.0.1.25
  ExternalIP:  52.12.34.56
  Hostname:    worker-node-01
Capacity:
  cpu:                2
  ephemeral-storage:  20Gi
  hugepages-1Gi:      0
  hugepages-2Mi:      0
  memory:             8Gi
  pods:               110
Allocatable:
  cpu:                1900m
  ephemeral-storage:  18Gi
  hugepages-1Gi:      0
  hugepages-2Mi:      0
  memory:             7.5Gi
  pods:               110
System Info:
  Machine ID:                 ec2a1b2c3d4e5f6789012345678901ab
  System UUID:                EC2A1B2C-3D4E-5F67-8901-234567890123
  Boot ID:                    12345678-90ab-cdef-1234-567890abcdef
  Kernel Version:             5.4.0-150-generic
  OS Image:                   Ubuntu 20.04.6 LTS
  Operating System:           linux
  Architecture:               amd64
  Container Runtime Version:  containerd://1.6.21
  Kubelet Version:            v1.27.3
  Kube-Proxy Version:         v1.27.3
PodCIDR:                      10.244.1.0/24
PodCIDRs:                     10.244.1.0/24
Non-terminated Pods:          (8 in total)
  Namespace                   Name                                CPU Requests  CPU Limits  Memory Requests  Memory Limits  Age
  ---------                   ----                                ------------  ----------  ---------------  -------------  ---
  default                     nginx-deployment-7d79c4f8c9-abc12  100m (5%)     200m (10%)  128Mi (1%)       256Mi (3%)     25d
  default                     redis-master-6bf6d99f8-xyz34       100m (5%)     500m (26%)  256Mi (3%)       512Mi (6%)     25d
  kube-system                 coredns-5d78c9869d-def56           100m (5%)     0 (0%)      70Mi (0%)        170Mi (2%)     25d
  kube-system                 kube-proxy-gh78i                   0 (0%)        0 (0%)      0 (0%)           0 (0%)         25d
  kube-system                 weave-net-jkl90                    100m (5%)     0 (0%)      200Mi (2%)       0 (0%)         25d
  monitoring                  prometheus-node-exporter-mno12     100m (5%)     200m (10%)  50Mi (0%)        100Mi (1%)     20d
  logging                     fluentd-pqr34                      100m (5%)     500m (26%)  200Mi (2%)       500Mi (6%)     18d
  ingress-nginx              nginx-ingress-controller-stu56      100m (5%)     0 (0%)      90Mi (1%)        0 (0%)         15d
Allocated resources:
  (Total limits may be over 100 percent, i.e., overcommitted.)
  Resource           Requests     Limits
  --------           --------     ------
  cpu                700m (36%)   1400m (73%)
  memory             994Mi (13%)  1538Mi (20%)
  ephemeral-storage  0 (0%)       0 (0%)
  hugepages-1Gi      0 (0%)       0 (0%)
  hugepages-2Mi      0 (0%)       0 (0%)
Events:
  Type    Reason                   Age                From             Message
  ----    ------                   ----               ----             -------
  Normal  NodeHasSufficientMemory  23d                kubelet          Node worker-node-01 status is now: NodeHasSufficientMemory
  Normal  NodeHasNoDiskPressure    23d                kubelet          Node worker-node-01 status is now: NodeHasNoDiskPressure
  Normal  NodeHasSufficientPID     23d                kubelet          Node worker-node-01 status is now: NodeHasSufficientPID
  Normal  Starting                 23d                kubelet          Starting kubelet.
  Normal  NodeAllocatableEnforced  23d                kubelet          Updated Node Allocatable limit across pods
  Normal  NodeReady                23d                kubelet          Node worker-node-01 status is now: NodeReady
  Normal  Rebooted                 5d                 kubelet          Node worker-node-01 has been rebooted, boot id: 12345678-90ab-cdef-1234-567890abcdef
  Normal  Starting                 5d                 kube-proxy       Starting kube-proxy.

其中包含了 以下信息

  • Node的基本信息 名称，角色，标签，创建时间等
  • Annotations ： Node上的注解，主要用于内部控制
  • Conditions ： Node的当前状况，“Ready” 表示Node处于健康状态
  • Addresses ： Node的主机地址与主机名
  • Capacity & Allocatable ： Capacity 给出Node可用的系统资源，包括CPU，内存数量，最大可调度Pod数量等，Allocatable 给出Node 可用于分配的资源量
  • System Info ： 包括主机ID，系统UUID，Linux Kernel版本号，操作系统类型与版本，容器运行时的版本，kubelet与kube-proxy 的版本号等
  • Non-terminated Pods ： 当前运行的Pod列表概要信息
  • Allocated resources ： 已分配的资源使用概要信息，例如资源申请的最小，最大允许使用量占系统总量的百分比
  • Events ： Node相关的Event信息

NameSpace

namespace 是一种用于进行租户间资源隔离的一种资源对象，在一个集群中可以创建多个命名空间，每个命名空间都是互相独立的存在，属于不同命名空间的资源对象从逻辑上相互隔离。kubernetes 会自动创建两个命名空间 ，一个是默认的 ，一个是系统级的。用户创建的资源对象如果没有指定命名空间，则默认存放在 default命名空间中。在yaml中定义一个命名空间

1
2
3
4
apiVersion: v1
kind: Namespace
metadata: 
	name: development

通过kubectl get pods 只能看到默认命名空间中的 容器资源， 需要添加对应的namesapce 来查询某个命名空间中的对象。

1
2
3
# kubectl get pods --namespace=development
NAME            READY          STATUS           RESTARTS         AGE
busybox         1/1            Running          0                1m

Service

Service具有一个全局唯一的虚拟Cluster地址，Service一旦被创建，Kubernetes就会自动为它分配一个可用的ClusterIP地址，而且在Service的整个生命周期内，它的ClusterIP地址都不会变，客户端可用通过“虚拟IP地址+服务的端口”的形式直接访问该服务。

Pod

每个Pod中都有一个被称为“根容器”的Pause容器,并组合了多个业务容器

  • 为多进程之间的协作提供一个抽象模型，将Pod作为基本的调度，复制等管理工作的最小单位，能让多个应用进程一起有效地调度和伸缩
  • Pod中的多个业务容器共享Pause容器的IP，并且共享Pause容器挂接的Volume，这样既简化了密切关联的业务容器之间的通信问题，也很好地解决了它们之间的文件共享问题

Kubernetes为每个Pod都分配了唯一的IP地址，称之为”Pod IP”。 Pod中的多个容器共享Pod IP地址

Pod分为普通Pod和静态Pod。

静态Pod被存放在某个具体的Node上的一个具体文件中，并且只能在此Node上启动，运行

普通Pod一旦被创建，就会被存放在etcd中，随后被Master调度到某个具体的Node上并绑定，该Pod对应的Node上的kubelet进程实例化成一组相关的Docker容器并启动。当Pod中的某个容器停止时，Kubernetes会自动检查问题，并尝试重新启动Pod，如果Pod所在的Node宕机，则会由Master将所有Pod 重新调度到其他Node上。

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: v1
kind: Pod
metadata:
	name: myweb
	labels:
		name: myweb
spec:
	containers:
	- name: myweb
		image: kubeguide/tomcat-app:v1
		ports:
		- containerPort: 8080

Pod的IP地址家伙是那个容器端口 组成了一个Endpoint，代表此Pod中的一个服务进程的对外通信地址。

Event

Event是一个事件记录，记录了事件的最早产生时间，最后重现时间，重复次数，发起者，类型，以及导致此事件的原因等众多信息。

Label与Label Selector

Label用于对给某个资源添加信息标签。再通过表达式完成对某个资源对象的筛选

1
2
3
4
5
6
基于等式的Label Selector表达式匹配 label :
name = redis-slave : 匹配所有具有 "name = redis-slave" Label 的资源对象
env! = production: 匹配所有不具有 "env=production" Label 的资源对象
基于集合的Label Selector表达式匹配 label :
name in (redis-master, redis-slave): 匹配所有具有 "name=redis-master" Label或者 "name=redis-slave" Label的资源对象
name not in (php-frontend): 匹配所有不具有 "name=php-frontend" Label的资源对象

在Pod中定义标签信息

1
2
3
4
5
6
apiVersion: v1
kind: Pod
metadata:
	name: myweb
	labels:
		app: myweb

对应的Service myweb 通过Label Selector 与 pod发生关联

1
2
3
spec:
	selector:
		app: myweb

Pod 与 Deployment

Deployment 提供了一个Pod 资源对象的部署模板

1
2
3
4
5
6
7
8
9
10
11
apiVersion: apps/v1
kind: Deployment
spec:
	replicas: 2
	selector:
		matchLabels:
			app: myweb
		template:
			labels:
				app: myweb
			spec

replicas : pod 副本数量

selector: 目标Pod的Label Selector

template: 用于自动创建新Pod副本的模板

以一个单容器的tomcat pod资源对象为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
apiVersion: apps/v1
kind: Deployment
metadata:
	name: tomcat-deploy
spec:
	replicas: 1
	selector: 
		matchLables:
			tier: frontend
		matchExpressions:
			- (key: tier , operator: In , values: [frontend])
	template:
		metadata:
			labels:
				app: app-demo
				tier: frontend
			spec:
				containers:
				- name: tomcat-demo
					image: tomcat
					imagePullPolicy: IfNotPresent
					ports:
					- containerPort: 8080

运行创建对象

1
2
# kubectl create -f tomcat-deployment.yaml
deployment  "tomcat-deploy" created

查看deployment 对象

1
2
3
# kubectl get deployments
NAME              DESIRED      CURRENT   UP-TO-DATE     AVAILABLE      AGE
tomcat-deploy     1            1         1              1              4m

DESIRED: Pod副本数量的期望值，既Deployment中描述的副本数量

CURRENT: 当前实际的副本数量

UP-TO-DATE: 最新版本的Pod的副本数量，用于指示在滚动更新的过程中，有多少Pod副本已经成功工薪

AVAILABLE: 当前集群中可用的Pod副本数量

可用通过查看 replicaset 查看 配置模板与副本的对应关系

1
2
3
# kubectl get replicaset
NAME                       DESIRED     CURRENT   AGE
tomcat-deploy-1640611518   1           1         1m

Service的ClusterIP地址

每个Pod都会被分配一个单独的IP地址，并且每个Pod都提供了一个独立的Endpoint 以供客户端访问。Kubenetes在内部的每个Node上都运行了一套全局的虚拟负载均衡器，自动地注入并实时更新集群中所有Service的路由表，通过iptables或IPVS机制，将Service的请求转发到后端对应的某个Pod实例上，并在内部实现服务的负载均衡与会话保持机制。同时Kubernetes为Service提供了与服务绑定的ClusterIP 地址。这样就可以将服务发现变为TCP/IP通信。

但是 ClusterIP 是一个虚拟的IP地址

  • ClusterIP地址仅仅作用于Kubernetes Services 这个对象，并由Kubernetes管理和分配IP地址，与Node和Master所在的物理网络无关
  • 因为没有一个”实体的网络对象“来响应，所以ClusterIP 无法被Ping通。ClusterIP地址只能与Service Port组成一个具体的服务访问端点。
  • ClusterIP属于Kubernetes集群这个封闭的空间，集群外的节点若想访问这个通信端口，则要做一些额外的工作。
1
2
3
4
5
6
7
8
9
apiVersion： v1
kind: Service
metadata:
	name: tomcat-service
spec:
	ports:
	- port: 8080
	selector:
		tier: frontend

创建服务

1
2
# kubectl create -f tomcat-service.yaml 
service "tomcat-service" created

通过查看端点列表，可以看到对应的pods实例

1
2
3
4
# kubectl get endpoints
NAME            ENDPOINTS                AGE
kubernetes      192.168.18.131:6443      15d
tomcat-service  172.17.1.3:8080          1m

查询ClusterIP信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# kubectl get service tomcat-service -o yaml
apiVersion: v1
kind: Service
spec:
	clusterIP: 10.245.85.70
	ports:
	- port: 8080
		protocol: TCP
		targetPort: 8080
	selector:
		tier: frontend
	sessionAffinity: None
	type: ClusterIP
status:
	loadBalancer: ()

targetPort 用于确定提供该服务的容器所暴露的端口号，即具体的业务进程在容器内的targetPort提供TCP/IP 接入；port属性则定义了Service 的端口。

还有一种特殊的Service: Headless Service 这时的服务不具备Cluster地址，而是通过DNS直接返回该Service对应的全部Pod的Endpoint列表

多端口

在多Endpoint的情况下，每个Endpoint都定义了一个名称进行区分

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: v1
kind: Service
metadata:
	name: tomcat-service
spec:
	ports:
	- port: 8080
		name: service-port
	- port: 8005
		name: shutdown-port
	selector:
		tier: frontend

外网访问

如何从集群外访问服务

  • Node IP : Node的IP地址。
  • Pod IP : Pod的IP 地址
  • Service IP： Service的IP 地址

Node IP 对应的是Node的物理网卡地址，所以的服务访问必然需要通过Node IP进行通信

Pod IP是每个Pod的IP地址，Pod IP间的通信是通过虚拟二层网络进行的

Service IP 使用的是集群中的地址，无法直接使用这个地址。通过Node Port 来完成对外的内部IP暴露过程。 NodePort 的实现是，在Kubernetes集群的每个Node上都为需要外部访问的Service开启一个对应的TCP监听端口，外部系统只要用任意一个Node的IP地址+NodePort端口号即可访问该服务。

通过负载均衡器来完成IP请求的分发过程。

Ingress

通过Ingress提供对多个Service的代理服务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
kind: Ingress
metadata:
	name: name-virtual-host-ingress
spec:
	rules:
	- host: foo.bar.com
	  http:
		  paths:
			- backend:
				serviceName: service1
				servicePort: 80
	- host: bar.foo.com
		paths: 
		  - backend:
				serviceName: service2
				servicePort: 80

有状态应用集群

有状态集群的特征

  • 每个节点都有固定的身份ID，通过这个ID，集群中的成员可以相互发现并通信
  • 集群的规模是比较固定的，集群规模不能随意变动
  • 集群中的每个节点都是有状态的，通常会持久化数据到永久存储中，每个节点在重启后都需要使用原有的持久化数据
  • 集群中成员节点的启动顺序通常也是确定的
  • 如果磁盘损坏，则集群中的某个节点无法正常运行，集群功能受损

通过StatefulSet提供状态控制

  • StatefulSet 里的每个Pod都有稳定，唯一的网络标识，可用于发现集群中的其他成员。
  • StatefulSet控制的Pod副本的启停顺序是受控的，在操作第n个Pod时，前n-1个Pod已经是运行且准备好的状态
  • StatefulSet里的Pod采用稳定的持久化存储卷，通过PV或者PVC来实现，在删除Pod时默认不会删除StatefulSet相关的存储卷

批处理应用

批处理应用特点是由一个或多个进程处理一组数据，在数据处理完成后，批处理任务自动结束。kubernetes 通过Job 完成 这类应用的支持

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: batch/v1
kind: Job
metadata:
	name: pi
spec:
	containers:
	- name: pi
		image: perl
		command: ["perl","-Mbignum=bpi","-wle","print bpi(100)"]
	restartPolicy: Never
parallelism: 1
completions: 5

completions : 需要运行的任务总数

parallelism : 并发运行的数量

周期性运行批处理任务

通过使用CronJob 可以周期性的执行某个任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
apiVersion: batch/v1
kind: CronJob
metadata:
	name: hello
	spec: 
		schedule: ""
		jobTemplate:
			spec:
				template: 
					spec:
						containers:
						- name: hello
							image: busybox:1.28
							imagePullPolicy: IfNotPresent
							command:
							- /bin/sh
							- -c
							- data: echo Hello from the Kubernetes cluster
						restartPolicy: OnFailure

应用配置

ConfigMap

  • 用户将配置文件的内容保存到ConfigMap中，文件名可作为key,value就是整个文件的内容，多个配置文件都可以被放入同一个ConfigMap
  • 在建模用户应用时，在Pod中将ConfigMap定义为特殊的Volume进行挂载。在Pod被调度到某个具体的Node上时，ConfigMap里的配置文件会被自动还原到本地目录下，如何映射到Pod中指定的配置目录下，这样用户的程序就可以无感知地读取配置了
  • 在ConfigMap修改后，Kubernetes会自动重新获取ConfigMap的内容，并在目标Node上更新对应的文件

Secret

  • Secret用于解决应用配置问题。

存储

Volume

Volume是Pod中能够被多个容器访问的共享目录。

Kubernetes中的Volume被定义在Pod中，被一个Pod中的多个容器挂载到具体的文件目录下；Kubernetes中的Volume与Pod的生命周期相同，但与容器的生命周期不想管

Kubernetes支持多种类型的Volume

对Volume的声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template:
	metedata:
		labels:
			app: app-demo
			tier: frontend
		spec:
			volumes:
				- name: datavol
					emptyDir: {}
			containers:
				- name: tomcat-demo
					image: tomcat
					volumeMounts:
						- mountPath: /mydata-data
							name: datavol
					imagePullPolicy: IfNotPresent

emptyDir

emptyDir 是用于进行临时存储的空间，由Kubernetes自动分配的一个目录

当Pod从Node上移除时，emptyDir中的数据也被永久移除，它可以作为：

  • 临时空间，用于某些应用程序运行时所需的临时目录，且无须永久保留
  • 在长时间任务执行过程中使用的临时目录
  • 一个容器需要从另一个容器中获取的数据目录

hostPath

hostPath类型用于将Node文件系统的目录或文件挂载到容器内部使用

  • 在容器应用程序生成的日志文件需要永久保存时，可以使用宿主机上的告诉文件系统对其进行存储
  • 在需要访问宿主机上Docker引擎内部数据结构的容器应用时，可以通过定义hostPath为宿主机/var/lib/docker目录，使容器内的应用直接访问Docker的文件系统

需要注意的地方

  • 在不同的Node上具有相同配置的Pod，可能会因为宿主机上的目录和文件不同，导致对Volume上目录和文件的访问结果不一致
  • 如果使用了资源配额管理，则Kubernetes无法将hostPath在宿主机上使用的资源纳入管理
1
2
3
4
volumes:
- names : "presisent-storage"
	hostPath:
		path: "/data"

动态存储管理

Persistent Volume

PV 是一个由系统动态创建的存储卷。

1
2
3
4
5
6
7
8
9
10
11
12
apiVersoin: storage.k8s.io/v1
kind: StorageClass
metadata:
	name: standard
provisioner: kubernetes.io/aws-ebs
parameters:
	type: gp2
reclaimPolicy: Retain
allowVolumeExpansion: true
mountOptions:
	- debug
volumeBindingMode: Immediate

provisioner : 代表了创建PV的第三方存储插件

parameters : 创建PV时的必要参数

reclaimPolicy : PV回收策略

PVC（persistent volume claim）

PVC表示应用希望申请的PV规格，包括

accessModes: 存储访问模式

storageClassName: 用哪种StorageClass 实现动态创建

resources: 存储的具体规格

1
2
3
4
5
6
7
8
9
10
11
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
	name: claim1
spec:
	accessMode:
		- ReadWriteOnce
	storageClassName: standard
	resources:
		requests:
			storage: 30Gi

通过在Pod中引用PVC 来进行PV的绑定

1
2
3
4
5
6
7
8
9
10
11
spec:
	containers:
	- name: myapp
		image: tomcat:8.5.38-jre8
		volumeMounts:
			- name: tomcatedata
				mountPath : "/data"
			volumes:
				- name: tomcatedata
					persistentVolumeClaim:
						claimName: claim1

示例

创建Deployment , 定义微服务结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
apiVersion: app/v1
kind: Deployment
metadata:
	labels:
		app: mysql
	name: mysql
spec:
	replicas: 1
	selector:
		matchLables:
			app: mysql
	template:
		metadata:
			labels:
				app: mysql
		spec:
			containers:
			- image: mysql:5.7
				name: mysql
				ports:
				- containerPort:3306
				env:
				- name: MYSQL_ROOT_PASSWORD
				  value: "123456"

创建Deployment

1
2
# kubectl apply -f mysql-deploy.yaml
deployment.apps/mysql created

通过命令查看Deployment:

1
2
3
# kubectl get deployments
NAME    READY     UP-TO-DATE   AVAILABLE       AGE
mysql   1/1       1            1               4m13s

检查Pod

1
2
3
# kubectl get pods
NAME                    READY      STATUS      RESTARTS        AGE
mysql-85f4b4cdf4-k97    1          Running     0               13s

查看docker中的容器情况

1
2
3
4
5
6
# docker ps  | grep mysql
72ca992535b4 mysql
"docker-entrypoint.sh"    12minutes age      UP  12 minutes
k8s_mysql.86dc506e_mysql-c95jc_default_511d6705-5051-1le6-a9d8-000c29ed42c1_9f89d0b4
 76c1790aad27  k8s.gcr.io/pause:3.2  "/pause"   12 minutes age   UP 12 minutes   k8s_POD.16b
 20365_mysql-c95jc_default_511d6705-5051-lie6-a9d8-000c29ed42c1_28520aba

创建一个与之关联的service文件

1
2
3
4
5
6
7
8
9
apiVersion: v1
kind: Service
metadata:
	name: mysql
spec:
	ports:
		-port: 3306
	selector:
		app: mysql

创建服务对象

1
2
# kubectl create -f mysql-svc.yaml
service "mysql" created

查看Service 对象

1
2
3
# kubectl get service mysql
NAME             CLUSTER-IP           EXTERNAL-IP         PORT           AGE
mysq             10.245.161.22        <none>              3306/TCP       48s

启动Tomcat

定义deployment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
apiVersion: apps/v1
kind: Deployment
metadata:
	labels:
		app: myweb
	name: myweb
spec:
	replicas: 2
	selector:
		matchLabels:
			app: myweb
		template:
			metadata:
				labels:
					app: myweb
			spec:
				containers:
				- image: kubeguide/tomcat-app:v1
					name: myweb
					ports:
					- containerPort: 8080
					env: 
						- name: MYSQL_SERVICE_HOST
						value: 10.245.161.22

创建

1
2
3
4
5
6
7
8
# kubectl apply -f myweb-deploy.yaml
deployment.apps/myweb created

# kubectl get pods 
NAME                       READY        STATUS            RESTARTS           AGE
mysql-85f4b4cdf4-k97wh     1/1          Running           0                  23m
myweb-6557d8b869-gdc7g     1/1          Running           0                  2m56s
myweb-6557d8b869-w5wwx     1/1          Running           0                  2m56s

创建对应Service

1
2
3
4
5
6
7
8
9
10
11
12
apiVersion: v1
kind: Service
metadata: 
	name: myweb
spec:
	- port: 8080
	  nodePort: 30001
	selector:
		app: myweb

# kubectl create -f myweb-svc.yaml
service/myweb created

通过kubectl get 命令查看已创建的Service

1
2
3
4
5
# kubectl get svc
NAME          TYPE          CLUSTER-IP      EXTERNAL-IP   PORT(S)     AGE
kuberntes     ClusterIP     10.245.0.1      <none>        443/TCP     174m
mysql         ClusterIP     10.245.161.22   <none>        3306/TCP    18m
myweb         NodePort      10.245.46.172   <none>        8080:30001/TCP  2m35s

完成了一个简易的微服务搭建。

架构图

Kubernetes
#虚拟化 #微服务 #Kubernetes
Kubernetes 结构与概念
http://gadoid.io/2025/08/07/Kubernetes-结构与概念/
作者
Codfish
发布于
2025年8月7日
许可协议