容器编排工具之Kubernetes -- k8s

一、容器与容器编排

1、容器技术的优势：

1.资源消耗少
2.启动速度快
3.扩展非常方便
4.管理非常方便
1
2
3
4

2、常见的容器编排工具

1.compose--》单台机器上编排容器
2.swarm--》多台机器上编排容器
3.k8s-》多台机器上编排容器，性能和功能比swarm更加好
1
2
3

二、负载均衡

1、负载均衡的作用

1.能够将大量的请求比较均匀的分散到后端，不会导致某台服务器访问量过大，某台服务器又没有访问量
2.高可用（对后端的服务器进行健康检测，如果后端那台服务器出现问题，就不会再将请求转发给它，从而避免用户访问不了服务器，起到一个容错的功能）
1
2

2、nginx实现负载均衡
nginx是一个web服务器，可用来实现http功能，但他也可以对http访问进行负载均衡

1.安装nginx
	[root@load-balancer ~]# yum install nginx -y
	[root@load-balancer ~]# nginx  	--启动nginx
	查看你nginx服务是否启动
	[root@load-balancer ~]# ps aux|grep nginx
		root        1632  0.0  0.2 119152  2168 ?        Ss   17:30   0:00 nginx: master process nginx
		nginx       1633  0.0  1.0 151840  8060 ?        S    17:30   0:00 nginx: worker process
		root        1635  0.0  0.1  12348  1096 pts/0    R+   17:30   0:00 grep --color=auto nginx
	nginx监听的是哪一个端口
	[root@load-balancer ~]# ss -anplut|grep nginx
		tcp   LISTEN 0      128          0.0.0.0:80        0.0.0.0:*    users:(("nginx",pid=1633,fd=9),("nginx",pid=1632,fd=9))  
		tcp   LISTEN 0      128             [::]:80           [::]:*    users:(("nginx",pid=1633,fd=10),("nginx",pid=1632,fd=10))
2.配置nginx里的负载均衡功能
	[root@load-balancer ~]# cd /etc/nginx/	 	进入配置文件的命令
	[root@load-balancer nginx]# ls
		conf.d                  koi-utf             scgi_params
		default.d               koi-win             scgi_params.default
		fastcgi.conf            mime.types          uwsgi_params
		fastcgi.conf.default    mime.types.default  uwsgi_params.default
		fastcgi_params          nginx.conf          win-utf
		fastcgi_params.default  nginx.conf.default
	#修改nginx的配置文件
	[root@load-balancer nginx]# vim nginx.conf
		http{
			   #定义一个负载均衡器，名字叫scweb
		    upstream scweb {
		    server 192.168.243.135;   #nginx代理的三台服务器
		    server 192.168.243.136;
		    server 192.168.243.137;
		    }
		    server {
		        listen       80 default_server;	
		        server_name  www.sc.com;
		        location / {
		                proxy_pass http://scweb；  #调用负载均衡器
		        }
		}
3.重启一下nginx服务
	[root@load-balancer nginx]# service nginx restart
	Redirecting to /bin/systemctl restart nginx.service
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

3、负载均衡的相关算法

1.轮询 roundrobin   --》rr
2.加权轮询
3.ip_hash     --》基于客户端的ip地址做负载均衡，相同的ip地址转发到同一个服务器
4.least-connected   --》最小连接数
1
2
3
4

4、keepalived
4.1、keepalived两大功能

1.high-availability 高可用高可用性是通过VRRP实现的协议。VRRP是路由器故障转移的基础
2.loadbalancing  --》负载均衡
1
2

4.2、脑裂：就是2台或者多台LB上都有vip地址

1.出现脑裂的原因：
	1.防火墙阻止了keepalived的vrrp消息的通告
	2.virtual_router_id 不一样的时候
2.出现脑裂现象的影响和危害：
	1.如果是防火墙原因导致脑裂，会导致80端口也不能访问，这是有影响的，因为web服务也不能访问了
	2.如果是虚拟路由器id不一样导致脑裂，是没有影响的，因为web服务可以访问
3.用户如何知道自己访问的是那台服务器上的vip的呢
	查看客户机里的arp缓存表，查看ip对应的mac地址
	vip会使用真实机器的ens33接口上的mac地址
	通过mac地址来判断我们的客户机使用的是那台机器上的vip
1
2
3
4
5
6
7
8
9
10

三、compose

1、compose定义：

是docker官方推出的一个容器编排工具。也可以理解为，是一个启动容器的脚本，在脚本里指明启动容器的顺序，启动多少容器，每个容器具体的参数，例如，启动容器时，可以指定端口，卷，链接，使用那个镜像等
1

2、compose的好处：

1.快速批量的启动容器，效率高
2.不容易出错，可靠
1
2

3、compose 是python编写的一个容器编排工具
4、compose 的安装

1.下载compose：
	curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
2.授予可执行权限
	chmod +x /usr/local/bin/docker-compose
3.执行查看一下版本
	[root@lhj-docker ~]# docker-compose -v
	docker-compose version 1.29.2, build 5becea4c
1
2
3
4
5
6
7

5、compose官方文档：https://docs.docker.com/compose/gettingstarted/
6、compose相关命令

1.docker-compose up
	-d 选项：放在后台运行
2.docker-compose down
	--volumes 选项：删除容器，并且删除容器相关的卷和网络等
3.docker-compose ps
4.docker-compose stop
5.docker-compose --help  --》遇到不会的就使用这个命令
1
2
3
4
5
6
7

四、Kubernetes – k8s

1、k8s里的准备知识

1、k8s是什么：生产级别的容器编排工具，自动化的容器部署、扩展和管理
2、swap分区的作用：交换分区--》从磁盘里划分出一块空间来充当内存使用，性能比真正的物理内存要差
3、为什么要关闭swap分区：docker容器在内存里运行--》不允许容器到swap分区里去运行--》为了追求性能
	#查看swap分区
	[root@worker-2 ~]# cat /proc/swaps 
		Filename				Type		Size	Used	Priority
		/dev/dm-1                               partition	4128764	0	-2
	#关闭所有swap分区	
	[root@worker-2 ~]# swapoff -a
	#开启所有swap分区
	[root@worker-2 ~]# swapon -a
	永久关闭swap分区
	[root@lhj-k8s ~]# vim /etc/fstab 
		#/dev/mapper/centos-swap swap                    swap    defaults        0 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、关于kubeadm、kubelet和kubectl

1.kubeadm --》k8s的管理程序--》在master上运行的--》建立整个k8s集群
2.kubelet --》在node节点上用来管理容器的--》管理docker，告诉docker程序去启动容器；也可以理解为master和node通信用的
3.kunbectl --》在master上用来给node节点发号施令的程序，用来控制node节点的，是命令行操作的工具
1
2
3

3、搭建一个k8s集群，并测试是否可用

1.确保集群里的集群都安装了docker，然后执行下面命令
	yum install -y kubeadm kubectl kubelet
2.初始化master节点
	kubeadm init \
	--apiserver-advertise-address=192.168.243.138 \ #master主机ip
	--image-repository registry.aliyuncs.com/google_containers \
	--service-cidr=10.1.0.0/16 \
	--pod-network-cidr=10.244.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/
		Then you can join any number of worker nodes by running the following on each as root:
		kubeadm join 192.168.243.138:6443 --token f82edc.imaj74pbbipcqn38 \
			--discovery-token-ca-cert-hash sha256:fca002f8a0892af1a211f833207d16456378822b83d1fc7ef31bb3a1a890d11e 
	
	其他节点加入是需要的密钥：
		kubeadm join 192.168.243.138:6443 --token f82edc.imaj74pbbipcqn38 \
			--discovery-token-ca-cert-hash sha256:fca002f8a0892af1a211f833207d16456378822b83d1fc7ef31bb3a1a890d11e
			
3.在node节点上执行加入的密钥
	kubeadm join 192.168.243.138:6443 --token f82edc.imaj74pbbipcqn38 \
			--discovery-token-ca-cert-hash sha256:fca002f8a0892af1a211f833207d16456378822b83d1fc7ef31bb3a1a890d11e 
	
	node节点加入成功的执行结果：
		This node has joined the cluster:
		* Certificate signing request was sent to apiserver and a response was received.
		* The Kubelet was informed of the new secure connection details.
		Run 'kubectl get nodes' on the control-plane to see this node join the cluster.
4.查看master机器上有多少节点
	[root@k8s-master ~]# kubectl get nodes
		NAME      STATUS     ROLES                  AGE   VERSION
		lhj-k8s   NotReady   control-plane,master   29h   v1.23.6
		node-1    NotReady   <none>                 27h   v1.23.6
		node-2    NotReady   <none>                 27h   v1.23.6
5.创建nginx的pod测试k8s集群是否可用
	创建nginx的pod
	[root@k8s-master ~]# kubectl run sc-nginx --image=nginx --port=8080
		pod/sc-nginx created
	[root@k8s-master ~]# kubectl get pod
		NAME       READY   STATUS    RESTARTS   AGE
		sc-nginx   1/1     Running   0          94s
	[root@k8s-master ~]# kubectl get pod -o wide 	显示详细的内容
		NAME       READY   STATUS    RESTARTS   AGE    IP           NODE     NOMINATED NODE   READINESS GATES
		sc-nginx   1/1     Running   0          111s   10.244.1.2   node-1   <none>           <none>

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

4、k8s里面的组件/进程

1.master上面的
	1、etcd--》存放数据的
	2、scheduler--》调度器--》例如：容器（pod）到底在哪个node服务器上启动
	3、api-server--》接口：master和node之间通信和交换数据的
	4、controller--》控制器：deployment 部署控制器，replicaSET 副本控制器等
2.node上面的组件
	1、kubelet--》帮助启动容器的
	2、kubu-proxy--》负责网络通信和负载均衡的
1
2
3
4
5
6
7
8

5、k8s里的相关镜像及功能

kube-apiserver      	 外交部长：对外的一个接口服务
kube-proxy 				 负责暴露服务后的负载均衡，将流量导入到各个容器
kube-controller-manager  控制管理程序：副本数量20个pod等
kube-scheduler			 调度器：负载容器被分配到那个node节点上启动容器
etcd					 数据库：整个k8s存储数据的地方
coredns					 内部dns服务器，内部域名查询使用的
pause 					 pod里都会启动一个pause容器，让整个pod共享一个命名空间（网络，mount，进程等），整个pod里的容器可以相互访问
flannel					 集群里的节点服务器之间通信使用的
1
2
3
4
5
6
7
8

6、k8s里的相关命令

1、创建nginx pod：
	kubectl run sc-nginx --image=nginx --port=8080 pod/sc-nginx created
2、查看pod：
	kubectl get pod
		 -o wide   #显示更详细的内容
3、删除pod：
	kubectl delete pod sc-nginx
4、查看有哪些命名空间：
	kubectl get namespace
5、查看所有命名空间里的pod：
	kubectl get pod -A
6、创建一个deployment控制器，名字为d-sc-nginx：
	kubectl create deployment d-sc-nginx --image nginx:latest 
7、启动nginx的pod，里面的副本数量是5个，用d-sc-nginx这个控制器：
	kubectl create deployment d-sc-nginx --image nginx：latest -r 5
8、查看pod的日志，可以用来排错：
	kubectl logs d-sc-nginx-57cc4b4c6f-twc8c(具体的pod名)
9、查看deployment：
	kubectl get deployment
10、删除deployment：
	kubectl delete deployment d-sc-nginx
11、扩展副本控制器数量：
	kubectl scale --replicas 5 deployment d-sc-nginx 
12、查看副本控制器数量：
	kubectl get rs
13、发布服务，让别人能够访问k8s里的pod：
	kubectl expose deployment/d-sc-nginx --type="NodePort" --port 8090
14、查看服务：
	kubectl get service
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

7、有状态应用和无状态应用

1、有状态：
	1.在创建、删除、扩容、缩容和更新pod的时，是讲究顺序的
	2.特点：pod的编号是有顺序的；缩容的时候是顺序进行的，不是随机的；每个实例都需要有自己独立的持久化存储
	3.例子：redis、kafka或者Mysql服务
2、无状态：
	1.是指该服务运行的事例不会在本地存储需要持久化的数据，并且多个实例对于同一个请求响应的结果是完全一致的
	2.多个实例可以共享相同的持久化数据。
	3.特点：随便访问那个pod都会得到一样的结果；pod的序号是随机的；缩容的时候是随机进行的，删除或者增加的顺序是随机的；
	4.例子web服务
1
2
3
4
5
6
7
8
9

8、数据的保存

1、ConfigMap
	1.是k8s里保存数据的一个地方，里面的数据是没有加密的--》就像一个普通的箱子，里面可以存放一些配置：例如用户名和密码，或者nginx.conf等不是特别大的内容
	2.key：value 的形式保存数据
2、Secret
	是k8s里保存数据的一个地方，里面的数据是加密的
1
2
3
4
5

9、k8s里的控制器

1.node controller 节点控制器
2.job controller 任务控制器
3.endpoints controller 端点控制器
4.服务账户和令牌控制器
	更加细致的控制器：
	deployment、replicaset、daemonSet、cronjob、job
1
2
3
4
5
6

五、pod

1、pod定义：

pod：是k8s里容器调度的最小的单元，一个pod里可以有多个容器，这些容器可以使用一样的镜像，也可以使用不一样的镜像，可以全部是nginx，也可以是有nginx，Mysql，redis等容器组合成一个pod，pod里的容器数量大于等于1。
1

2、pod里的容器共享一个ip地址（网络命名空间），共享mount空间等命名空间
3、pod调度策略和方法

1.deployment：全自动调度  --》根据node的算力（cpu，内存，带宽，已经运行的pod等 ）
2.node selector：定向调度
3.nodeaffinity   --》尽量把pod放到一台node上
4.podaffinity    --》尽量把相同的pod放到一起
5.taints和tolerations
1
2
3
4
5

4、pod的状态

1、Pending（悬决）
	Pod 已被 Kubernetes 系统接受，但有一个或者多个容器尚未创建亦未运行。此阶段包括等待 Pod 被调度的时间和通过网络下载镜像的时间。
2、Running（运行中）
	Pod 已经绑定到了某个节点，Pod 中所有的容器都已被创建。至少有一个容器仍在运行，或者正处于启动或重启状态。
3、Succeeded（成功）
	Pod 中的所有容器都已成功终止，并且不会再重启。
4、Failed（失败）
	Pod 中的所有容器都已终止，并且至少有一个容器是因为失败终止。也就是说，容器以非 0 状态退出或者被系统终止。
5、Unknown（未知）
	因为某些原因无法取得 Pod 的状态。这种情况通常是因为与 Pod 所在主机通信失败。
1
2
3
4
5
6
7
8
9
10

5、pod的启动流程

1、管理员使用命令行或者yam文件去启动pod
2、API server会接收到请求，并且将我们的数据存入etcd数据库
3、我们的控制器会发现etcd数据库里有新的数据，马上根据新的数据去执行任务
4、我们的副本控制器根据输入的副本数量去启动相应数量的pod
5、调度控制器根据相应的算法，去分配哪些pod在哪些node节点上启动
6、kubelet从api server 里获取相应的任务，去调用容器运行时，例如docker去启动pod
7、kubeproxy 会给pod分配网络资源，也可以给pod做负载均衡，例如：将pod的网络和k8s里面的网络相连通，发布pod对应的服务
1
2
3
4
5
6
7

6、pod的重启策略：Always、OnFailure 和 Never
7、pod里的容器可以共享哪些资源

1.共享存储，当作卷
2.共享网络，作为唯一的集群ip地址
3.有关每个容器如何运行的信息，例如容器映像版本或要使用的特定端口
1
2
3

六、service服务的类型

1、常见的服务类型

1、ClusterIP：提供一个集群内部的虚拟IP以供Pod访问（service默认类型）
2、NodePort：在每个Node上打开一个端口以供外部访问
3、LoadBalancer：负载均衡
4、headless service：有时不需要或者不想要负载均衡，以及单独的service IP

1
2
3
4
5

2、expose 暴露：发布服务出去，让别人能够访问k8s里的pod

kubectl expose deployment/d-sc-nginx --type="NodePort" --port 8090
1

3、创建一个服务的流程

1.先创建一个deployment，启动nginx的pod
	kubectl create deployment d-sc-nginx --image nginx:latest --replicas 5
2.再创建service，去暴露我们的deployment部署的pod
	kubectl expose deployment/d-sc-nginx --type="NodePort" --port 80
3.查看服务：
	[root@k8s-master ~]# kubectl get service
		NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
		d-sc-nginx   NodePort    10.1.26.57   <none>        80:31997/TCP   4d11h
		kubernetes   ClusterIP   10.1.0.1     <none>        443/TCP        7d18h
1
2
3
4
5
6
7
8
9

4、使用yaml文件去部署deployment或者service等资源的时候的优势:

1.复用
2.真正的实现编排的意义，同时启动很多的pod等操作
1
2

5、使用yaml文件部署服务及暴露pod

使用nginx.yml文件
	[root@k8s-master liu]# vim nginx.yml
	apiVersion: apps/v1
	kind: Deployment
	metadata:
	  name: sc-nginx-deployment
	spec:
	  selector:
	    matchLabels:
	      app: liu-nginx
	  replicas: 5 # tells deployment to run 2 pods matching the template
	  template:
	    metadata:
	      labels:
	        app: liu-nginx
	    spec:
	      containers:
	      - name: liu-nginx
	        image: nginx:latest
	        ports: 
	        - containerPort: 80

	[root@k8s-master liu]# kubectl apply -f nginx.yml 
	deployment.apps/sc-nginx-deployment configured
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24