k8s教程

一、k8s安装教程

1.安装要求

• 3台以上机器，操作系统 CentOS7.7以上64位系统
• 硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多
• 集群中所有机器之间网络互通
• 可以访问外网，需要拉取镜像
• 禁止swap分区

2. centos7兼容版本(7.7~7.9)

3.三台主机

搭建k8s集群，三台主机，每台至少2G以上

备注：本次装机选用k8s 1.19.16版本，dokcer1.18.09版本

4.安装docker(三台主机都需要安装)

#卸载旧版本
sudo yum remove docker \
                docker-client \
                docker-client-latest \
                docker-common \
                docker-latest \
                docker-latest-logrotate \
                docker-logrotate \
                docker-engine

sudo yum update -y

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

#配置docker的yum地址
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#安装指定docker版本
sudo yum -y install docker-ce-18.09.9 docker-ce-cli-18.09.9 containerd.io


#启动dokcer并开机自启
sudo systemctl start docker
sudo systemctl enable docker


#Docker配置修改
vim /etc/docker/daemon.json

{
  "graph": "/data/docker",
  "registry-mirrors": [
  		"https://xv8xjvpp.mirror.aliyuncs.com",
        "https://docker.m.daocloud.io/",
        "https://dockerproxy.com/",
        "https://mirror.baidubce.com/",
        "https://docker.nju.edu.cn/",
        "https://ccr.ccs.tencentyun.com/"	
  ],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
#加载配置文件并重启docker
sudo systemctl daemon-reload
sudo systemctl restart docker




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

5.主机环境配置(三台都需要)

#1.关闭防火墙
sudo systemctl stop firewalld
sudo systemctl disable firewalld

#2.关闭selinux
#selinux禁用
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

#2.关闭swap分区
swapoff -a   
vim /etc/fstab # 注释到swap那一行  永久关闭

#3.设置主机名
hostnamectl set-hostname k8s-master
hostnamectl set-hostname k8s-node1
hostnamectl set-hostname k8s-node2

#4.添加host,IP需要改成你自己机器的IP
cat >> /etc/hosts << EOF
192.168.2.201 k8s-master
192.168.2.202 k8s-node1
192.168.2.203 k8s-node2
EOF

#5.允许iptables 检查桥接流量
cat > /etc/sysctl.d/k8s.conf << EOF
net.ipv4.ip_forward = 1
net.ipv4.tcp_tw_recycle = 0
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system

#6.设置时间同步
yum install -y ntpdate
ntpdate time.windows.com
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

6.安装kubelet,kubeadm,kubectl(三台机器都需要执行)

#1.配置k8s的yum源
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

#2.如果之前安装了k8s,先卸载旧版本
yum -y remove kubelet kubeadm kubectl

#3.查看可以安装的版本
 #可以将 kubelet 替换为 kubeadm 或 kubectl，以查看相应组件的可用版本
yum list --showduplicates kubelet | sort -r   

#4，安装指定的kubelet，kubeadm，kubectl版本
sudo yum install -y kubelet-1.19.16 kubeadm-1.19.16 kubectl-1.19.16

# 启动kubelet并卡机自启
sudo systemctl start kubelet
sudo systemctl enable kubelet

#检查k8s是否启动
sudo systemctl status kubelet

#排查错误
journalctl -xefu kubelet


#master主机上执行
sudo kubeadm init \
--control-plane-endpoint=k8s-master
--pod-network-cidr=192.168.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.2.201 \
--kubernetes-version=v1.19.16 \
--image-repository registry.aliyuncs.com/google_containers

#master主机上执行
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


#手动拉取(三台机器都要)
docker pull docker.io/calico/cni:v3.20.6
docker pull docker.io/calico/kube-controllers:v3.20.6
docker pull docker.io/calico/node:v3.20.6


#安装网络插件 Calico(仅master主机需要)
#下载calico.yaml
mkdir /root/k8s
cd /root/k8s
wget https://docs.projectcalico.org/v3.20/manifests/calico.yaml
kubectl apply -f calico.yaml


#申请一个新令牌
kubeadm token create --print-join-command

#加入node节
#复制新生成的令牌
kubeadm join 192.168.2.201:6443 --token xxxx     --discovery-token-ca-cert-hash sha256:xxxxx

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

二、k8s基础命令

2.1 kubectl命令使用

使用kubectl 查看

Cluster Management Commands:
  certificate   修改 certificate 资源.
  cluster-info  显示集群信息
  top           Display Resource (CPU/Memory/Storage) usage.
  cordon        标记 node 为 unschedulable
  uncordon      标记 node 为 schedulable
  drain         Drain node in preparation for maintenance
  taint         更新一个或者多个 node 上的 taints

Troubleshooting and Debugging Commands:
  describe      显示一个指定 resource 或者 group 的 resources 详情
  logs          输出容器在 pod 中的日志
  attach        Attach 到一个运行中的 container
  exec          在一个 container 中执行一个命令
  port-forward  Forward one or more local ports to a pod
  proxy         运行一个 proxy 到 Kubernetes API server
  cp            复制 files 和 directories 到 containers 和从容器中复制 files 和 directories.
  auth          Inspect authorization

Advanced Commands:
  diff          Diff live version against would-be applied version
  apply         通过文件名或标准输入流(stdin)对资源进行配置
  patch         使用 strategic merge patch 更新一个资源的 field(s)
  replace       通过 filename 或者 stdin替换一个资源
  wait          Experimental: Wait for a specific condition on one or many resources.
  convert       在不同的 API versions 转换配置文件
  kustomize     Build a kustomization target from a directory or a remote url.

Settings Commands:
  label         更新在这个资源上的 labels
  annotate      更新一个资源的注解
  completion    Output shell completion code for the specified shell (bash or zsh)

Other Commands:
  alpha         Commands for features in alpha
  api-resources Print the supported API resources on the server
  api-versions  Print the supported API versions on the server, in the form of "group/version"
  config        修改 kubeconfig 文件
  plugin        Provides utilities for interacting with plugins.
  version       输出 client 和 server 的版本信息
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

2.2 Namespace

k8s中，命名空间(Namespace) 提供一种机制同一集群中的资源划分为相互隔离的组，同一命名空间内的资源名称要唯一，命名空间是用来隔离资源的，不隔离网路。

kubernetes启动时会创建四个初始命名空间：

• default

kubernetes包含这个命名空间，以便你无需创建新的命名空间即可开始使用新集群

• kube-node-lease

该命名空间包含用于各个节点关联的**Lease(租约)**对象。节点租约允许kubelet发送心跳，由此控制能够检测到节点故障。

• kube-public

所有的客户端(包括未经身份验证的客户端)都可以读取该命名空间。该命名空间主要预留未集群使用，以便某些资源需要在整个集群中可见可读。该命名空间的公属性是一种约定而非要求。

• kube-system

该命名空间使用kubernetes系统创建的对象。

#查看namespace
kubectl get namespace
#查看kube-system下的pod
kubectl get pods -n kube-system
#查看所有namespace下的pod
kubectl get pods -A
1
2
3
4
5
6

创建Namespace

• 命令行方式

kubectl create namespace XXXXX
1

• yaml方式

#XXXXX.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace
1
2
3
4
5

运行：

kubectl create -f XXXXX.yaml
1

删除namespace

kubectl delete namespace XXXXX

kubectl delete -f XXXXX.yaml
1
2
3

2.3 Pod

Pod是可以运行在kubernetes中创建和管理的、最小的可部署的计算单元。Pod是一组(一个或多个)容器；这些容器共享存储、网络、以及怎样运行这些 容器的生命。

创建Pod示例：运行一个NGINX容器

• 命令方式

#创建pod
kubectl run mynginx --image=nginx:1.14

#获取pod的信息，-owide 表示更详细的显示信息 -n 命名空间 查询对应namespace下的pod
kubectl get pod
kubectl get pod -owide
kubectl get pod -n <namespace-name>

#查看pod的详情
kubctl describe pod <pod-name>
#查看pod的运行日志
kubectl logs <pod-name>
#删除pod
kubectl delete pod <pod-name>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• yaml方式

#nginx-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: mynginx
  labels:
  	run:mynginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80
1
2
3
4
5
6
7
8
9
10
11
12
13

2.4 Deployment

Deployment负责创建和更新应用程序的实例，使Pod拥有多副本，自愈，扩容等能力。创建Deployment后，kubernetes master将应用程序实列调整到集群中的各个节点上。如果托管实列的节点关闭或被删除，Deployment控制器会将该实例替换为集群中另一个节点上的实例，这提供了一种自我修复机制来解决机器故障维护问腿。

创建一个Tomcat应用程序

• 命令行形式

#my-tomcat表示pod的名称 --image表示镜像的地址
kubectl create deployment  my-tomcat --image=tomcat:9.0.55

#查看deployment的信息
kubectl get deployment

#删除deployment
kubectl delete deployment my-tomcat

#查看Pod日志
kubectl logs my-tomcat-XXXX

#使用exec可以在pod的容器中执行命令
kubectl exec -it <pod_name> -- /bin/bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• yaml方式

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tomcat-deployment
  labels:
    app: tomcat-deployment
spec:
  replicas: 3  # 定义了 3 个副本
  selector:
    matchLabels:
      app: tomcat-deployment
  template:
    metadata:
      labels:
        app: tomcat-deployment
    spec:
      containers:
      - name: tomcat
        image: nginx:1.14.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#修改 replicas
kubectl edit deployment my-tomcat

#扩容和缩容
kubectl scale deployment my-tomcat --replicas=5


#滚动升级
kubectl set image deployment  my-tomcat tomcat=tomcat:10.1.11 --record

#查看版本历史
kubectl rollout history deployment my-tomcat

#回滚上一个版本
kubectl rollout undo deployment my-tomcat

#回滚指定版本
kubectl rollout undo deployment my-tomcat --to-revision=2 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.5 Service

Service是一个抽象层，它定义了一组Pod的逻辑集，并为这些Pod支持外部流量暴露、负载均衡和服务发现。

尽管每个Pod都有一个唯一的IP地址，但是如果没有Service，这些IP不会暴露在集群外部。Service允许您的应用程序接收流量。Service也可以用在ServiceSpect标记type的方式暴露，type类型如下：

• **ClusterIP(默认)：**在集群的内部IP上公开Service。这种类型使得Service只能从集群内访问。
• NodePort: 使用NAT在集群中每个选定的Node的相同端口上公开Service。使用:从集群外部访问Service。是ClusterIP的超集。
• **LoadBalancer:**在当前云中创建一个外部负载均衡器(如果支持的话)，并为Service分配一个固定的外部IP。NodePort的超集。
• ExternalName:通过返回带有该名称的CNAME记录，使用任意名称(由spec中的ExternalName指定)公开Service。不使用代理。

创建service示例

• 命令行形式

kubectl expose deployment my-tomcat --port=8080 --type=NodePort

#查看service信息，port信息冒号后面的端口号就是对集群外暴露的访问接口
#NodePort范围在 30000-32767之间
kubectl get svc -owide
1
2
3
4
5

• yaml形式

apiVersion: v1
kind: Service
metadata:
  labels:
  	app: my-tomcat
  name: my-tomcat  # Service 的名称
spec:
  ports:
  	- port: 8080 #service的虚拟ip对应的端口，在集群内网机器可以访问用service的虚拟ip加该端口号访问
  	  nodePort: 30001 #Service在宿主主机上映射的外网访问端口，端口范围必须在30000~32767
      protocol: TCP
      port: 80  # Service 暴露的端口
      targetPort: 8080  # 被暴露的 Pod 的容器端口，一般与pod内部容器暴露的端口一致
  type: NodePort  # Service 类型，可以是 ClusterIP、NodePort、LoadBalancer 等
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.6存储

Volume

Volume指的是存储卷，包含可被Pod中容器访问的数据目录。容器中的文件在磁盘上是临时存放的，当容器崩溃时文件会丢失，同事无法在多个Pod中共享文件，通过使用存储卷可以解决这问题。

kubernetes 支持很多类型的卷。Pod可以同时使用任意数目的卷类型。临时卷类型的生命周期与Pod相同，但持久卷可以比Pod的存活期长。当Pod不再存在时，kubernetes 也会销毁临时卷；不过kubernetes 不会销毁永久卷。对于给定的Pod中任何类型的卷，在容器重启期间数据都不会丢失。

卷的核心就是一个目录，其中可能存有数据，Pod中的容器可以访问该目录中的数据。所采用的不同卷类型将决定该目录如何形成的、使用何种介质保存数据以及目录中存放的东西。常见有confingMap、emptyDir、local、nfs、secret等。

• ConfingMap：可以将配置文件以键值对的形式保存到ConfigMap中，并且可以在Pod中以文件或环境变量的形式使用。ConfigMap可以用来存储不敏感的配置信息，如应用程序的配置文件。

• EmptyDir：是一个空目录，可以在Pod用来存储临时数据，当Pod删除时，该目录也会删除。

• Local：将本地文件系统的目录或文件映射到Pod中的一个Volume中，可以用来在Pod中共享文件或数据。

• NFS：将网络上的一个或多个NFS共享目录挂载到Pod中的Volume中，可以用来在多个Pod之间共享数据。

• Secret：将敏感信息以密文的形式保存到Secret中，并且可以在Pod中以文件或环境变量的形式使用。Secret可以用来存储敏感信息，如用户的密码、证书等。

使用方式

使用卷时，在**.spec.volumes字段中设置为Pod提供的卷，并在.spec.containers[*].volumeMounts**字段中生明卷在容器中挂载位置。容器中的进程看到的文件系统试图是由他们的容器镜像的初始内容以及挂载在容器中的卷(r如果定义了的话)所组成的。其中根文件系统同容器镜像中的内容相吻合。任何在该文件系统下的写入操作，如果被允许的话，都会影响接下来容器中进程访问文件系统时所看到的内容。

2.7Ingress

Ingress 是一种kubernetes资源类型，它允许kubernetes 集群中暴露HTTP和HTTPS服务。通过Ingress，你可以将流量路由到不同的服务和端口点，而无需使用不同的负载均衡器。Ingress通常使用Ingress Contrller实现，它是一个运行在kubernetes 集群中的负载均衡器，它根据Ingress规则下面是一个将所有流量都发送到同一Service的简单Ingress示例：

Ingress和Service区别

Ingress和Service都是kubernetes中用于将流量路由到应用的机制，但他们是在路由层面上有所不同：

• Service是kubernetes中抽象的应用程序服务，它公开了一个单一的IP地址和端口，可以用于在kubernetes集群内部的Pod之间进行流量路由。
• Ingress是一个kubernetes资源对象，它提供了对集群外部路由的规则。Ingress通过一个公共IP地址和端口将流量路由到一个或多个Service。

安装Ingress

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml

#检查 Ingress 控制器 Pod 状态
kubectl get pods -n ingress-nginx

#检查 Ingress 控制器服务
kubectl get svc -n ingress-nginx

#查看是否安装成功
kubectl get pod,svc -n ingress-nginx -owide
1
2
3
4
5
6
7
8
9
10

使用Ingress

官网地址：https://kubernetes.github.io/ingress-nginx/

三、k8s核心原理

3.1 k8s的网络模型

k8s的网络中主要存在4种类型的通信：

• 同一Pod内的容器通信
• 各个Pod彼此间的通信
• Pod和Service间的通信
• 集群外部流量和Service之间的通信

k8s为Pod和Service资源对象分别使用了各自的专有网络，Pod网络由K8s的网络插件配置实现，而Service网络则由K8s集群进行指定。如下图：

k8s使用的网路插件需要为每个Pod配置至少一个特定的地址，即Pod IP。Pod IP地址实际存在于某个网卡(可以是虚拟机设备)上。

而Service的地址是一个虚拟IP地址，没有任何网络接口配置在此地址上，它由kube-proxy借助iptable规则或ipvs规则重定向到本地端口 ，再将其调度到后端的Pod对象。Service的IP地址是集群提供服务的接口，也称为Cluster IP。

Pod网络和IK8s的网络插件负责和管理，具体使用的网络地址可以再管理网络插件时进行指定，如192.168.0.0/16网络。而Cluster网络和IP是由负责配置和管理，如192.96.0.0/12网络。

从上图进行总结起来，一个k8s集群包含的是三个网络。

• **节点网络：**各主机(Master、Node、ETCD等)自身所属的网络，地址配置在主机的网络接口，用于各主机之间的通信，又称为节点网络。
• **Pod网络 ：**专用于Pod资源对象的网络，它是一个虚拟网络，用于为各个Pod对象设定IP地址等网络参数，其地址配置在Pod种容器的接口上。Pod网络需要借助kubenet插件或CNI插件实现。
• Service网络：专用于Service资源对象的网络，它也是一个虚拟网络，用于k8s集群之中的Service配置IP地址，但是该地址不会配置在任何主机或容器的网络接口上，而是通过Node上的kube-proxy配置为iptable或ipvs规则，从而将发往该地址的所有流量调度到后端的各Pod对象之上。

3.2k8s的 工作流程

用k8s部署Nginx的过程中，k8s内部各组件是如何协同工作的；

我们在master节点上执行一条命令master部署nginx应用(kubectl create deployment nginx –image=nginx)

• 这条命令首先发到master节点的网关api servcer,这是master的唯一入口
• api server将命令请求给controller manager进行控制
• controller manager进行应用部署分析
• controller manager 会生成一次部署信息，并通过api serve将信息存入etcd存储中
• scheduler调度器通过api serverc从etcd存储中，拿到要部署的应用，开始调度看哪个节点由资源适合部署
• scheduler把计算出来的调度信息通过api server 再放到etcd中
• 每个node节点的监控组件kubectl,随时和master保持联系(给api-server发送请求不断获取最新数据)，拿到master节点存储在etcd中的部署信息
• 假设node2的kubectl拿到部署信息，显示他自己节点要部署某某应用
• kubelet就自己run一个应用在当前机器上，并随时给master汇报当前应用的状态信息
• node和master也是通过master的api-server组件联系的
• 每一个机器上的kube-porxy能知道集群的所有网络，只要node访问别人或者别人访问node,node上的kube-porxy网络代理自动计算进行流量转发

k8s是属于Master-Worker架构，即有Master节点负责核心的调度、管理和运维，Worker节点规则执行用户的程序。但是在看k8s中，主节点一般称为Master Node，而从节点则被称为Worker Node或者Node。

注意：Master Node和Work Node分别安装了k8s的Master和Worker组件的实体服务器，每个Node都对应了一台实体服务器(虽然Master Node可以和其中一个Worker Node安装在同一台服务器，但是建议Master Node单独部署)，所有Master Node 和Worker Node组成了K8s集群，同一个集群可能存在多个Master Node 和Worker。Node

3.3 K8s架构六连问

k8s是一个基于容器技术的分布式集群管理系统。既然是个分布式系统，那势必有多个Node节点(物理主机或虚拟机)，它们组成一个分布式集群，并且这些节点中会有一个Master节点，由它来统一管理Node节点。

如图所示：

问题一：主节点和工作节点是如何工作通信的呢？

首先，Master节点启动时，会运行一个kube-apiserver进程，它提供了集群管理的API接口，是集群内各个功能模块之间数据交互和通信的中心枢纽，并且它也提供了完备的集群安全机制。

在Node节点上，使用k8s中的kubelet组件，在每个Node节点上都会运行一个kubelet进程，它负责向Master汇报自身节点的运行情况，如Node节点的注册、终止、定时上报健康状况等，以及接收Master发出的命令，创建相应Pod。

在k8s中，Pod是基本的操作单元，它与docker的容器略微有不同，因为Pod可能包含一个或多个容器(可以是docker容器)，这些内部的容器是共享网络资源的，即可通过locahost进行互相访问。

关于Pod内是如何做到网络共享的，每个Pod启动，内部都会启动一个pause容器(google的一个镜像)，它是使用默认的网络模式，而其他容器的网络都设置给它，以此来完成网络的共享问题。

如图所示：

问题二：Master是如何将Pod调度到指定的Node的？

该工作由kube-scheduler来完成的，整个调度过程通过执行一些列复杂的算法最终为每个Pod计算出一个最佳的目标Pod调度到一个指定的Node上，我们可以通过节点的标签(Label)和Pod的nodeSelcetor属性的相互匹配，来达到指定的效果。

如图所示：

问题三：各节点、Pod的信息都是统一维护在哪里，由谁来维护？

从上面的Pod调度角度看，我们的有一个存储中心，用来储存各节点资源使用情况、健康状态、以及各Pod的基本信息等，这样Pod的调度来能正常进行。

在k8s中采用etcd组件作为高可用强一致性的储存仓库，该组件可以内置在k8s中，也可以外部搭建拱k8s使用。

集群上的所有配置信息都储存在了etcd,为了考虑各个组件的相对独立，以及整体的维护性，对于这些存储数据的增、删、改、查，统一由kube-apiserver来进行调度，apiserver也提供了RESET的支持，不仅对各个内部组件提供服务外，还对集群外部用户暴露服务。

外部用户可以通过REST接口,或者kubectl命令行进行集群管理，其内在都是与apiserver进行通信。

如图所示：

问题四：外部用户如何访问集群内运行的

前面讲了外部用户如何管理k8s，而我们更关心的是内部运行的Pod如何对外访问。使用过Docker的人都应当了解，如果使用bridge模式，在容器创建时，都会分配一个虚拟IP,该IP外部是没法访问到的，就可以访问到内部容器端口了。

那么，k8s的外部访问是否也是实现的？答案是否定的，k8s中情况要复杂些。因为docker是单机模式下的，而且一个容器对外就暴露一个服务。分布式集群下。一个服务往往由多个Application提供，用来分担访问压力，而且这些Application可能分布在多个节点上，这样又涉及了跨主机的通信。

这里，k8s引入了Service的概念，将多个相同的Pod包装成一个完整的service对外提供服务，至于获取到这些相同的Pod，每个Pod启动时都会设置labels属性，在Service中我们通过选择器Selector,选择具有相同Controller来完成。同时，每个节点上会启动一个kube-porxy进程，由它来负责服务地址到Pod地址的代理以及负载均衡等工作。

如图所示：

问题五：Pod如何动态扩容和缩放？

既然知道了服务是由Pod组成的，那么服务的扩容也就意味着Pod的扩容。通俗点讲，就是在需要时将Pod复制多份，在不需要后，将Pod缩减指定的份数。k8s中通过Replication Controller来进行管理，为每个Pod设置一个期望的副本数，当实际副本数与期望不符时，就动态的进行数量调整，以达到期望数值。期望数值可以由我们手动更新，或自动扩容代理来完成。

如图所示：

问题六：各个组件之间是如何相互协作的？

最后，讲一下 kube-controller-manager这个进程的作用。我们知道了ectd是作为集群的储存中心，apiserver是管理数据中心，作为其他进程与数据中心通信的桥梁。而Service Controller、Replication Controller这些统一交由kube-controller-manager来管理，kube-controller-manager作为一个守护进程，每个Controller都是一个控制循环，通过apiserver监视集群的共享状态，并尝试将实际状态与期望状态不符合的进行改变。关于Controller，manager中包含了Node节点控制器(Node Controller)、资源配置额管控制器(Replication Controller)、命名空间控制器(Namespace Controller)等。

如图所示：

相关链接：【【K8S极简教程】4小时快速学会Kubernetes(k8s)，史上用时最短，效率最高！】 https://www.bilibili.com/video/BV1fm41117Uk/?p=15&share_source=copy_web&vd_source=34570e49561682c238bef0eeb26c6367

g-zpYPK5Tb-1718944341610)]

问题六：各个组件之间是如何相互协作的？

最后，讲一下 kube-controller-manager这个进程的作用。我们知道了ectd是作为集群的储存中心，apiserver是管理数据中心，作为其他进程与数据中心通信的桥梁。而Service Controller、Replication Controller这些统一交由kube-controller-manager来管理，kube-controller-manager作为一个守护进程，每个Controller都是一个控制循环，通过apiserver监视集群的共享状态，并尝试将实际状态与期望状态不符合的进行改变。关于Controller，manager中包含了Node节点控制器(Node Controller)、资源配置额管控制器(Replication Controller)、命名空间控制器(Namespace Controller)等。

如图所示：

[外链图片转存中…(img-4pWUS93R-1718944341610)]

相关链接：【【K8S极简教程】4小时快速学会Kubernetes(k8s)，史上用时最短，效率最高！】 https://www.bilibili.com/video/BV1fm41117Uk/?p=15&share_source=copy_web&vd_source=34570e49561682c238bef0eeb26c6367

Kubernetes文档：Kubernetes 文档 | Kubernetes