类型

服务器IP地址

备注

Ansible(2台)

192.168.7.101/102

K8S集群部署服务器，可以和在⼀起

K8S Master(2台)

192.168.7.101/102

K8s控制端，通过⼀个VIP做主备⾼可⽤

Harbor(2台)

192.168.7.103/104

⾼可⽤镜像服务器

Etcd(最少3台)

192.168.7.105/106/107

保存k8s集群数据的服务器

Hproxy(2台)

192.168.7.108/109

⾼可⽤etcd代理服务器

Node节点(2-N台)

192.168.7.111/112/xxx

真正运⾏容器的服务器，⾼可⽤环境⾄少两台

类型

服务器IP

主机名

VIP

K8S Master1

192.168.7.101

k8s-master1.magedu.net

192.168.7.248

K8S Master2

192.168.7.102

k8s-master2.magedu.net

192.168.7.248

Harbor1

192.168.7.103

k8s-harbor1.magedu.net

Harbor2

192.168.7.104

k8s-harbor2.magedu.net

etcd节点1

192.168.7.105

k8s-etcd1.magedu.net

etcd节点2

192.168.7.106

k8s-etcd2.magedu.net

etcd节点3

192.168.7.107

k8s-etcd3.magedu.net

Haproxy1

192.168.7.108

k8s-ha1.magedu.net

Haproxy2

192.168.7.109

k8s-ha2.magedu.net

Node节点1

192.168.7.110

k8s-node1.magedu.net

Node节点2

192.168.7.111

k8s-node2.magedu.net

root@k8s-ha1:~# cat /etc/keepalived/keepalived.conf

vrrp_instance VI_1 {

state MASTER

interface eth0

virtual_router_id 1

priority 100

advert_int 3

unicast_src_ip 192.168.7.108

unicast_peer {

192.168.7.109

}

authentication {

auth_type PASS

auth_pass 123abc

}

virtual_ipaddress {

192.168.7.248 dev eth0 label eth0:1

}

}

#同步证书

root@k8s-harbor2:~# mkdir   /etc/docker/certs.d/harbor.magedu.net -p

root@k8s-harbor1:/usr/local/src# scp /apps/harbor/certs/harbor-ca.crt

172.31.7.105:/etc/docker/certs.d/harbor.magedu.net

#添加host⽂件解析

root@k8s-harbor2:~# vim /etc/hosts

172.31.7.104 harbor.magedu.net

#重启docker

root@k8s-harbor2:~# systemctl  restart docker

k8s-master1:/etc/ansible/bin# pwd

/etc/ansible/bin

k8s-master1:/etc/ansible/bin# tar xvf k8s.1-13-5.tar.gz

k8s-master1:/etc/ansible/bin# mv bin/* .

root@k8s-master1:/etc/ansible# pwd

/etc/ansible

root@k8s-master1:/etc/ansible# ansible-playbook

01.prepare.yml

1.6.4.2 ：部署etcd集群：

可选更改启动脚本路径

root@k8s-master1:/etc/ansible# ansible-playbook

02.etcd.yml

root@k8s-etcd1:~# export NODE_IPS="192.168.7.105 192.168.7.106 192.168.7.107"

root@k8s-etcd1:~# for ip in ${NODE_IPS}; do   ETCDCTL_API=3 /usr/bin/etcdctl   --

--cacert=/etc/kubernetes/ssl/ca.pem   --

--key=/etc/etcd/ssl/etcd-key.pem   endpoint health; done

healthy: successfully committed proposal: took =

healthy: successfully committed proposal: took =

healthy: successfully committed proposal: took =

root@k8s-master1:/etc/ansible# vim roles/kube-node/defaults/main.yml

# 基础容器镜像

SANDBOX_IMAGE: "harbor.magedu.net/baseimages/pause-amd64:3.1"

root@k8s-master1:/etc/ansible# ansible-playbook  05.kube-node.yml

root@k8s-master1:/etc/ansible# calicoctl  node status

Calico process is running.

IPv4 BGP status

+---------------+-------------------+-------+----------+-------------+

| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |

+---------------+-------------------+-------+----------+-------------+

| 192.168.7.110 | node-to-node mesh | up    | 14:22:44 | Established |

+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status

No IPv6 peers found.

[kube-master]

192.168.7.101

[new-master] # 预留组，后续添加master节点使⽤

192.168.7.102

root@k8s-master1:/etc/ansible# ansible-playbook  21.addmaster.yml

root@k8s-master1:/etc/ansible# calicoctl  node status

Calico process is running.

IPv4 BGP status

+---------------+-------------------+-------+----------+-------------+

| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |

+---------------+-------------------+-------+----------+-------------+

+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status

No IPv6 peers found.

root@k8s-master1:/etc/ansible# kubectl  get nodes

NAME            STATUS                     ROLES    AGE   VERSION

192.168.7.101   Ready,SchedulingDisabled   master   37m   v1.13.5

192.168.7.102   Ready,SchedulingDisabled   master   41s   v1.13.5

192.168.7.110   Ready                      node     33m   v1.13.5

192.168.7.111   Ready                      node     15m   v1.13.5

NAME

READY

STATUS

RESTARTS

AGE

calico-kube-controllers-77d9f69cdd-rbml2

1/1

Running

0

25m

calico-node-rk6jk

1/1

Running

1

20m

calico-node-vjn65

1/1

Running

0

25m

calico-node-wmj48

1/1

Running

0

25m

calico-node-wvsxb

1/1

Running

0

5m14s

kubernetes-dashboard-cb96d4fd8-th6nw

1/1

Running

0

37s

--proxy-mode=ipvs \

--ipvs-scheduler=sh

算法：

rr: round-robin

lc: least connection

dh: destination hashing

sh: source hashing

sed: shortest expected delay

nq: never queue

# vim dashboard/kubernetes-dashboard.yaml

image: 192.168.200.110/baseimages/kubernetes-dashboard-amd64:v1.10.1

ports:

- containerPort: 8443 protocol: TCP

args:

- --auto-generate-certificates

- --token-ttl=43200

# kubectl  apply  -f .

在浏览器输⼊  http://your-host-ip:80 即可访问  Kuboard v3.x 的界⾯，登录⽅式：

⽤户名：    admin

密  码：    Kuboard123

该端⼝⽤于接收HTTP请求；

该端⼝默认值为8080，可以通过API Server的启动参数“--insecure-port”的值来修改默认值；

默认的IP地址为“localhost”，可以通过启动参数“--insecure-bind-address”的值来修改该IP地址；

⾮认证或未授权的 HTTP请求通过该端⼝访问API Server(kube-controller-manager、kube-scheduler)。

该端⼝默认值为6443，可通过启动参数“--secure-port”的值来修改默认值；

默认IP地址为⾮本地(Non-Localhost)⽹络端⼝，通过启动参数“--bind-address”设置该值； 该端⼝⽤于接收客户端、  dashboard等外部HTTPS请求；

⽤于基于Tocken⽂件或客户端证书及HTTP Base的认证；

⽤于基于策略的授权；

提供了集群管理的REST API接⼝(包括认证授权、数据校验以及集群状态变更)；

提供其他模块之间的数据交互和通信的枢纽(其他模块通过API Server查询或修改数据，只有API Server才直接操 作etcd)  ;

是资源配额控制的⼊⼝；

拥有完备的集群安全机制 .

# curl 127.0.0.1:8080/apis #分组api

# curl 127.0.0.1:8080/api/v1 #带具体版本号的api

# curl  127.0.0.1:8080/  #返回核⼼ api列表

# curl  127.0.0.1:8080/version #api 版本信息

# curl 127.0.0.1:8080/healthz/etcd #与etcd的⼼跳监测

# curl 127.0.0.1:8080/apis/autoscaling/v1 #api的详细信息

# curl  127.0.0.1:8080/metrics #指标数据

# vim /etc/systemd/system/kube-controller-manager.service

[Unit]

Description=Kubernetes Controller Manager

Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]

ExecStart=/usr/bin/kube-controller-manager \

--address=127.0.0.1 \

--master=http://127.0.0.1:8080 \ #调⽤ kube-api-server的本地端⼝进⾏通信

--allocate-node-cidrs=true \

--service-cluster-ip-range=10.20.0.0/16 \

--cluster-cidr=172.31.0.0/16 \

--cluster-name=kubernetes \

--cluster-signing-cert-file=/etc/kubernetes/ssl/ca.pem \

--cluster-signing-key-file=/etc/kubernetes/ssl/ca-key.pem \

--service-account-private-key-file=/etc/kubernetes/ssl/ca-key.pem \

--root-ca-file=/etc/kubernetes/ssl/ca.pem \

--horizontal-pod-autoscaler-use-rest-clients=true \

--leader-elect=true \

--v=2

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target

# vim /etc/systemd/system/kube-scheduler.service

[Unit]

Description=Kubernetes Scheduler

Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]

ExecStart=/usr/bin/kube-scheduler \

--address=127.0.0.1 \

--master=http://127.0.0.1:8080 \ #调⽤ kube-api-server的本地端⼝进⾏通信

--leader-elect=true \

--v=2

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target

通过调度算法为待调度Pod列表的每个Pod从可⽤Node列表中选择⼀个最适合的Node，并将信息写⼊etcd中

node节点上的kubelet通过API Server监听到kubernetes Scheduler产⽣的Pod绑定信息，然后获取对应的Pod 清单，下载Image，并启动容器。

优选策略

1.LeastRequestedPriority

优先从备选节点列表中选择资源消耗最⼩的节点(CPU+内存)。

2.CalculateNodeLabelPriority

优先选择含有指定Label的节点。

3.BalancedResourceAllocation

优先从备选节点列表中选择各项资源使⽤率最均衡的节点。

PLEG：即Pod Lifecycle Event Generator,pleg会记录Pod⽣命周期中的各种事件 ,如容器的启动、终⽌等。

Container GC：Kubernetes 垃圾回收(Garbage Collection)机制由kubelet完成，  kubelet定期清理不再 使⽤的容器和镜像，每分钟进⾏⼀次容器的GC，每五分钟进⾏⼀次镜像的GC。

Pod Eviction 是k8s⼀个特⾊功能，它在某些场景下应⽤，如节点NotReady、Node节点资源不⾜，把pod驱逐⾄其

它Node节点。

Kube-controller-manager: 周期性检查所有节点状态，当节点处于NotReady状态超过⼀段时间后，驱逐该 节点上所有  pod。

Kubelet: 周期性检查本节点资源，当资源不⾜时，按照优先级驱逐部分  pod。

SyncLoop：控制pod ⽣命周期的制循环，驱动整个控制循环的事件有：  pod更新事件、  pod⽣命周期变化、  kubelet

本身设置的执⾏周期、定时清理事件等。

handlepods: kubelet针对pod的处理程序，创建pod、删除pod等。

UserSpace

k8s v1.2 及以后就已经淘汰

IPtables

⽬前默认⽅式，  1.1开始⽀持，  1.2开始为默认

IPVS

1.9引⼊到1.11正式版本，需要安装ipvsadm、ipset ⼯具包和加载  ip_vs 内核模块

root@k8s-node2:~# cat  /etc/systemd/system/kube-proxy.service

[Unit]

Description=Kubernetes Kube-Proxy Server

Documentation=https://github.com/GoogleCloudPlatform/kubernetes

After=network.target

[Service]

WorkingDirectory=/var/lib/kube-proxy

ExecStart=/usr/bin/kube-proxy \

--bind-address=192.168.7.111 \

--hostname-override=192.168.7.111 \

--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig \ #配置⽂件

--logtostderr=true \

--proxy-mode=iptables #配置转发模式

Restart=on-failure

RestartSec=5

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

使⽤IPVS模式，  Kube-Proxy会监视Kubernetes Service对象和Endpoints，调⽤宿主机内核Netlink接⼝以相 应地创建IPVS规则并定期与Kubernetes Service对象  Endpoints对象同步IPVS规则，以确保IPVS状态与期望⼀

致，访问服务时，流量将被重定向到其中⼀个后端  Pod,IPVS使⽤哈希表作为底层数据结构并在内核空间中⼯作，这意 味着IPVS可以更快地重定向流量，并且在同步代理规则时具有更好的性能，此外，  IPVS 为负载均衡算法提供了更多选 项，例如：  rr (轮询调度)、lc (最⼩连接数)、dh (⽬标哈希)、sh (源哈希)、sed (最短期望延迟 )、nq(不排队 调度)等。

# cat  /var/lib/kube-proxy/kube-proxy-config.yaml

kind: KubeProxyConfiguration

apiVersion: kubeproxy.config.k8s.io/v1alpha1

bindAddress: 172.31.7.111

clientConnection:

kubeconfig: "/etc/kubernetes/kube-proxy.kubeconfig"

clusterCIDR: "10.100.0.0/16"

conntrack:

maxPerCore: 32768

min: 131072

tcpCloseWaitTimeout: 1h0m0s

tcpEstablishedTimeout: 24h0m0s

healthzBindAddress: 172.31.7.111:10256

hostnameOverride: "172.31.7.111"

metricsBindAddress: 172.31.7.111:10249

mode: "ipvs"

ipvs:

scheduler: sh

kind: Service

apiVersion: v1

metadata:

labels:

app: magedu-nginx-service-label

name: magedu-nginx-service

namespace: magedu

spec:

type: NodePort

ports:

- name: http

port: 80

protocol: TCP

targetPort: 80

nodePort: 30004

selector:

app: nginx

sessionAffinity: ClientIP

sessionAffinityConfig:

clientIP:

timeoutSeconds: 1800

root@k8s-etcd1:~# cat /etc/systemd/system/etcd.service

[Unit]

Description=Etcd Server

After=network.target

After=network-online.target

Wants=network-online.target

Documentation=https://github.com/coreos

[Service]

Type=notify

WorkingDirectory=/var/lib/etcd/ #数据保存⽬录

ExecStart=/usr/bin/etcd \ #⼆进制⽂件路径

--name=etcd1 \  #当前node 名称

--cert-file=/etc/etcd/ssl/etcd.pem \

--key-file=/etc/etcd/ssl/etcd-key.pem \

--peer-cert-file=/etc/etcd/ssl/etcd.pem \

--peer-key-file=/etc/etcd/ssl/etcd-key.pem \

--trusted-ca-file=/etc/kubernetes/ssl/ca.pem \

--peer-trusted-ca-file=/etc/kubernetes/ssl/ca.pem \

--initial-advertise-peer-urls=https://192.168.7.105:2380 \ #通告⾃⼰的集群端⼝ --listen-peer-urls=https://192.168.7.105:2380 \ #集群之间通讯端⼝

--listen-client-urls=https://192.168.7.105:2379,http://127.0.0.1:2379 \ #客户端访问地址 --advertise-client-urls=https://192.168.7.105:2379 \ #通告⾃⼰的客户端端⼝

--initial-cluster-token=etcd-cluster-0 \  #创建集群使⽤的token，⼀个集群内的节点保持⼀致 --initial-

cluster=etcd1=https://192.168.7.105:2380,etcd2=https://192.168.7.106:2380,etcd3=https:/

/192.168.7.107:2380 \  #集群所有的节点信息

--initial-cluster-state=new \ #新建集群的时候的值为new,如果是已经存在的集群为existing。 --data-dir=/var/lib/etcd #数据⽬录路径

Restart=on-failure

RestartSec=5

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

root@k8s-etcd1:~# ETCDCTL_API=3 etcdctl --help

root@k8s-etcd1:~# ETCDCTL_API=3 etcdctl member --help

NAME:

etcdctl member - member add, remove and list subcommands

USAGE:

etcdctl member command [command options] [arguments...]

enumerate existing cluster members

add a new member to the etcd cluster

remove an existing member from the etcd cluster

update an existing member in the etcd cluster

OPTIONS:

--help, -h  show help

root@k8s-etcd1:~# export NODE_IPS="172.31.7.106 172.31.7.107 172.31.7.108"

root@k8s-etcd1:~# for ip in ${NODE_IPS}; do   ETCDCTL_API=3 /usr/bin/etcdctl   --

endpoints=https://${ip}:2379    --cacert=/etc/kubernetes/ssl/ca.pem   --

cert=/etc/kubernetes/ssl/etcd.pem   --key=/etc/kubernetes/ssl/etcd-key.pem   endpoint

health; done

root@k8s-etcd1:~# export NODE_IPS="172.31.7.106 172.31.7.107 172.31.7.108"

root@k8s-etcd1:~# for ip in ${NODE_IPS}; do   ETCDCTL_API=3 /usr/bin/etcdctl --write-

out=table endpoint status   --endpoints=https://${ip}:2379    --

cacert=/etc/kubernetes/ssl/ca.pem   --cert=/etc/kubernetes/ssl/etcd.pem   --

key=/etc/kubernetes/ssl/etcd-key.pem; done

root@etcd1:~# ETCDCTL_API=3 etcdctl  get --keys-only --prefix /calico | grep local  #查 看etcd中calico的相关数据

/calico/resources/v3/projectcalico.org/nodes/k8s-master1.magedu.local.priview

/calico/resources/v3/projectcalico.org/nodes/k8s-master2.magedu.local.priview

/calico/resources/v3/projectcalico.org/nodes/k8s-master3.magedu.local.priview

/calico/resources/v3/projectcalico.org/nodes/k8s-node1.magedu.local.priview

/calico/resources/v3/projectcalico.org/nodes/k8s-node2.magedu.local.priview

/calico/resources/v3/projectcalico.org/nodes/k8s-node3.magedu.local.priview

接⼝通过grpc提供rpc接⼝，放弃了v2的http接⼝，优势是⻓连接效率提升明显，缺点是使⽤不如以前⽅便，尤其对

不⽅便维护⻓连接的场景。

废弃了原来的⽬录结构，变成了纯粹的kv，⽤户可以通过前缀匹配模式模拟⽬录。

内存中不再保存value，同样的内存可以⽀持存储更多的key。

watch机制更稳定，基本上可以通过watch机制实现数据的完全同步。

提供了批量操作以及事务机制，⽤户可以通过批量事务请求来实现Etcd v2的CAS机制(批量事务⽀持if条件判断)。

#在etcd node1上watch⼀个key，没有此key也可以执⾏watch，后期可以再创建：

root@etcd1:~# ETCDCTL_API=3  /usr/bin/etcdctl watch  /name

#在etcd node2修改数据，验证etcd node1是否能够发现数据变化

root@etcd2:~# ETCDCTL_API=3  /usr/bin/etcdctl put  /data "data v1"

OK

root@etcd2:~# ETCDCTL_API=3  /usr/bin/etcdctl put  /data "data v2"

OK

V3版本备份数据：

root@k8s-etcd2:~# ETCDCTL_API=3 etcdctl  snapshot save  snapshot.db

Snapshot saved at snapshot.db

V3版本恢复数据：

root@k8s-etcd2:~#  ETCDCTL_API=3  etcdctl snapshot restore  snapshot.db  --data- dir=/opt/etcd-testdir #将数据恢复到⼀个新的不存在的⽬录中

2019-07-11 18:57:46.526757 I | mvcc: restore compact to 74541

2019-07-11 18:57:46.536114 I | etcdserver/membership: added member 8e9e05c52164694d

[http://localhost:2380] to cluster cdf818194e3a8c32

#⾃动备份数据

root@k8s-etcd2:~# mkdir /data/etcd-backup-dir/ -p

root@k8s-etcd2:~# cat  script.sh

#!/bin/bash

source /etc/profile

DATE=`date +%Y-%m-%d_%H-%M-%S`

ETCDCTL_API=3 /usr/bin/etcdctl  snapshot save  /data/etcd-backup-dir/etcd-snapshot-

${DATE}.db

root@k8s-master1:/etc/kubeasz# ./ezctl backup  k8s-01

root@k8s-master1:/etc/kubeasz# kubectl  delete pod net-test4

pod "net-test4" deleted

root@k8s-master1:/etc/kubeasz# ./ezctl restore k8s-01

1、恢复服务器系统

2、重新部署ETCD集群

3、停⽌kube-apiserver/controller-manager/scheduler/kubelet/kube-proxy

4、停⽌ETCD集群

5、各ETCD节点恢复同⼀份备份数据

6、启动各节点并验证ETCD集群

7、启动kube-apiserver/controller-manager/scheduler/kubelet/kube-proxy

8、验证k8s master状态及pod数据

Felix：calico的agent，运⾏在每⼀台node节点上，其主要是维护路由规则、汇报当前节点状态以确保pod的夸主 机通信。

BGP Client：每台node都运⾏，其主要负责监听node节点上由felix⽣成的路由信息，然后通过BGP协议⼴播⾄其他 剩余的node节点，从⽽相互学习路由实现pod通信。

Route Reflector：集中式的路由反射器，  calico v3.3开始⽀持，当Calico BGP客户端将路由从其                  FIB(Forward Information dataBase，转发信息库)通告到Route Reflector时，  Route Reflector会将这 些路由通告给部署集群中的其他节点，  Route Reflector专⻔⽤于管理BGP⽹络路由规则，不会产⽣pod数据通信。

注：  calico默认⼯作模式是BGP的node-to-node mesh，如果要使⽤Route Reflector需要进⾏相关配置。 https://docs.projectcalico.org/v3.4/usage/routereflector                          https://docs.projectcalico.org/v3.2/usage/routereflector/calico-routereflector

root@k8s-node2:~# calicoctl  node status

Calico process is running.

IPv4 BGP status

+---------------+-------------------+-------+----------+-------------+

| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |

+---------------+-------------------+-------+----------+-------------+

+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status

No IPv6 peers found.

开启IPIP：

root@k8s-master1:~# route -n

Kernel IP routing table

root@k8s-master1:~# kubectl  exec -it net-test1-68898c85b7-z7rgs    sh

/ # traceroute 172.31.58.83

traceroute to 172.31.58.83 (172.31.58.83), 30 hops max, 46 byte packets

1  192.168.7.111 (192.168.7.111)  0.011 ms  0.010 ms  0.004 ms

2  172.31.58.64 (172.31.58.64)  0.300 ms  0.505 ms  0.324 ms

3  172.31.58.83 (172.31.58.83)  0.498 ms  0.619 ms  0.422 ms

/ #

UDP：早期版本的Flannel使⽤UDP封装完成报⽂的跨越主机转发，其安全性及性能略有不⾜。

VXLAN：Linux 内核在在2012年底的v3.7.0之后加⼊了VXLAN协议⽀持，因此新版本的Flannel也有UDP转换为       VXLAN，VXLAN本质上是⼀种tunnel (隧道)协议，⽤来基于3层⽹络实现虚拟的2层⽹络，⽬前flannel 的⽹络模型 已经是基于VXLAN的叠加(覆盖)⽹络，⽬前推荐使⽤vxlan作为其⽹络模型。                                                               Host-gw：也就是Host GateWay，通过在node节点上创建到达各⽬标容器地址的路由表⽽完成报⽂的转发，因此这   种⽅式要求各node节点本身必须处于同⼀个局域⽹(⼆层⽹络 )中，因此不适⽤于⽹络变动频繁或⽐较⼤型的⽹络环境， 但是其性能较好。

Cni0:⽹桥设备，每创建⼀个pod都会创建⼀对  veth pair，其中⼀端是pod中的eth0，另⼀端是Cni0⽹桥中的端⼝ (⽹卡)，  Pod中从⽹卡eth0发出的流量都会发送到Cni0⽹桥设备的端⼝(⽹卡)上，  Cni0 设备获得的ip地址是该

节点分配到的⽹段的第⼀个地址。

Flannel.1: overlay⽹络的设备，⽤来进⾏vxlan报⽂的处理(封包和解包)，不同node之间的pod数据流量都从 overlay设备以隧道的形式发送到对端。

root@k8s-master1:~# kubectl  get  pod -o wide

NAME                         READY   STATUS    RESTARTS   AGE   IP           NODE

NOMINATED NODE   READINESS GATES

root@k8s-node2:~# cat

/var/lib/cni/flannel/a77f70994d452ea66c06f0cec194d937dacac1b69c07d31b478f844f216e84c7

{"hairpinMode":true,"ipMasq":false,"ipam":{"routes":

[{"dst":"172.31.0.0/16"}],"subnet":"172.31.2.0/24","type":"host-

local"},"isDefaultGateway":true,"isGateway":true,"mtu":1

450,"name":"cbr0","type":"bridge"}

root@k8s-node2:~# route -n

Kernel IP routing table

kind: ConfigMap

metadata:

annotations:

kubectl.kubernetes.io/last-applied-configuration: |

{"apiVersion":"v1","data":{"cni-conf.json":"{\n

\"cniVersion\": \"0.3.1\",\n  \"plugins\": [\n    {\n

\"delegate\": {\n        \"hairpinMode\": true,\n

}\n    },\n    {\n      \"type\": \"portmap\",\n

\"portMappings\": true\n      }\n    }\n  ]\n}\n","net-conf.json":"{\n  \"Network\":

\"10.200.0.0/16\",\n  \"Backend\": {\n    \"Type\": \"vxlan\"\n

}\n}\n"},"kind":"ConfigMap","metadata":{"annotations":{},"labels":

{"app":"flannel","tier":"node"},"name":"kube-flannel-cfg","namespace":"kube-system"}}

root@k8s-master1:/etc/ansible# vim roles/flannel/templates/kube-flannel.yaml.j2

net-conf.json: |

{

"Network": "{{ CLUSTER_CIDR }}",

"Backend": {

"Type": "{{ FLANNEL_BACKEND }}",

"Directrouting": true

}

->: pod中产⽣数据，根据pod的路由信息，将数据发送到Cni0

->: Cni0 根据节点的路由表，将数据发送到隧道设备flannel.1

->: Flannel.1查看数据包的⽬的ip，从flanneld获得对端隧道设备的必要信息，封装数据包。 ->: Flannel.1将数据包发送到对端设备 ,对端节点的⽹卡接收到数据包

->: 对端节点发现数据包为overlay数据包，解开外层封装，并发送到到本机flannel.1设备。 ->: Flannel.1设备查看数据包，根据路由表匹配，将数据发送给Cni0设备。

->: Cni0匹配路由表，发送数据给⽹桥上对应的端⼝ (pod)。

# 设置flannel 后端

FLANNEL_BACKEND: "host-gw"

#FLANNEL_BACKEND: "vxlan"

#DIRECT_ROUTING: true

/ # traceroute 10.10.4.6 #跨主机容器

traceroute to 10.10.4.6 (10.10.4.6), 30 hops max, 46 byte packets

1  10.10.3.1 (10.10.3.1)  0.003 ms  0.004 ms  0.001 ms

2  172.31.6.210 (172.31.6.210)  1.166 ms  0.495 ms  0.579 ms

3  10.10.4.6 (10.10.4.6)  0.307 ms  0.335 ms  0.322 ms

/ #

/ # traceroute 172.31.6.207

traceroute to 172.31.6.207 (172.31.6.207), 30 hops max, 46 byte packets

1  10.10.3.1 (10.10.3.1)  0.003 ms  0.004 ms  0.001 ms

2  172.31.6.207 (172.31.6.207)  1.290 ms  0.776 ms  2.041 ms

# route -n

Kernel IP routing table

# kubectl  exec -it busybox sh

/ # traceroute 172.31.2.21

traceroute to 172.31.2.21 (172.31.2.21), 30 hops max, 46 byte packets

1  172.31.3.1 (172.31.3.1)  0.110 ms  0.008 ms  0.018 ms

2  *  *  *

3  *  *  *

4  172.31.2.0 (172.31.2.0)  2.801 ms  0.672 ms  0.915 ms

5  172.31.2.21 (172.31.2.21)  1.006 ms  0.736 ms  1.190 ms

# cd /opt/k8s-data/ #dockerfile与yaml ⽬录

# cd dockerfile/system/centos/ #系统镜像⽬录

root@k8s-master1:/opt/k8s-data/dockerfile/system/centos# tree

.

├──  build-command.sh

├──  Dockerfile

L──  filebeat-6.8.1-x86_64.rpm

0 directories, 3 files

root@k8s-master1:/opt/k8s-data/dockerfile/system/centos#

root@k8s-master1:/opt/k8s-data/dockerfile/system/centos# cat Dockerfile

#制作基础镜像,centos:v7.5是基于官⽅centos 7.5镜像更改tag并上传到Harbor服务器的最原始官⽅镜像 FROM harbor.magedu.net/baseimages/centos:7.6.1810

MAINTAINER zhangshijie "zhangshijie@magedu.ent"

ADD  filebeat-6.8.1-x86_64.rpm /tmp/

RUN  yum install -y epel-release /tmp/filebeat-6.5.4-x86_64.rpm && rm -rf

/tmp/filebeat-6.5.4-x86_64.rpm

RUN  yum install -y vim wget tree  pcre pcre-devel gcc gcc-c++  zlib zlib-devel openssl

openssl-devel net-tools iotop unzip zip iproute ntpdate nfs-utils tcp

dump telnet traceroute

RUN rm -rf /etc/localtime && ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

root@k8s-master1:/opt/k8s-data/dockerfile/system/centos# cat build-command.sh

#!/bin/bash

docker build -t harbor.magedu.net/baseimages/centos-base:v7.6 .

sleep 1

docker push harbor.magedu.net/baseimages/centos-base:v7.6

# pwd

/opt/k8s-data/dockerfile/pub-images/nginx-base

# tree

.

├──  build-command.sh

├──  Dockerfile

L──  nginx-1.14.2.tar.gz

0 directories, 3 files

# cat Dockerfile

#Nginx Base Image

FROM harbor.magedu.net/baseimages/centos-base:v7.6

MAINTAINER  zhangshijie@magedu.net

RUN yum install -y vim wget tree  lrzsz gcc gcc-c++ automake pcre pcre-devel zlib zlib-

devel openssl openssl-devel iproute net-tools iotop

ADD nginx-1.14.2.tar.gz /usr/local/src/

RUN cd /usr/local/src/nginx-1.14.2 && ./configure  && make && make install && ln -sv

/usr/local/nginx/sbin/nginx /usr/sbin/nginx && useradd nginx -u 2001

# cat build-command.sh

#!/bin/bash

docker build -t harbor.magedu.net/pub-images/nginx-base:v1.14.2  .

sleep 1

docker push  harbor.magedu.net/pub-images/nginx-base:v1.14.2

# pwd

/opt/k8s-data/dockerfile/linux36/nginx

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  index.html

├──  nginx.conf

webapp

L──  index.html

1 directory, 5 files

# cat  Dockerfile

#Nginx Base Image

FROM harbor.magedu.net/pub-images/nginx-base:v1.14.2

ADD nginx.conf /usr/local/nginx/conf/nginx.conf

ADD webapp/*  /usr/local/nginx/html/webapp/

ADD index.html  /usr/local/nginx/html/index.html

#RUN mkdir /usr/local/nginx/html/webapp/about /usr/local/nginx/html/webapp/images

EXPOSE 80 443

CMD ["nginx"]

# pwd

/opt/k8s-data/yaml/

# mkdir namespaces

# cd namespaces

# cat linux36.yaml

apiVersion: v1 #API版本

kind: Namespace #类型为namespac

metadata:  #定义元数据

name: linux36 #namespace名称

# kubectl  apply -f linux36.yaml

namespace/linux36 created

# kubectl  get namespaces

NAME          STATUS   AGE

default       Active   21d

kube-public   Active   21d

kube-system  Active   21d

linux36       Active   45s

{ "⼈员名单 '":

{ "张三": { "年龄": 18, "职业": "Linux运维⼯程师", "爱好": [ "看书", "学习", "加班" ] }, #

"李四": { "年龄": 20, "职业": "Java开发⼯程师", "爱好": [ "开源技术", "微服务", "分布式存 储 "] } } }

#json特点：

json 不能注释

json 可读性较差

json 语法很严格

⽐较适⽤于API 返回值，也可⽤于配置⽂件

⼈员名单 :

张三 :

年龄 : 18 #

职业 : Linux运维⼯程师

爱好 :

- 看书

- 学习

- 加班

李四 :

年龄 : 20

职业 : Java开发⼯程师  # 这是职业

爱好 :

- 开源技术

- 微服务

- 分布式存储

⼤⼩写敏感

使⽤缩进表示层级关系

缩进时不允许使⽤Tal键，只允许使⽤空格

缩进的空格数⽬不重要，只要相同层级的元素左侧对⻬即可

使⽤ ”#” 表示注释，从这个字符⼀直到⾏尾，都会被解析器忽略

⽐ json更适⽤于配置⽂件

# pwd

/opt/k8s-data/dockerfile/pub-images #共⽤镜像⽬录

# cd jdk-1.8.212/

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  jdk-8u212-linux-x64.tar.gz

L──  profile

0 directories, 4 files

# pwd

/opt/k8s-data/dockerfile/pub-images/tomcat-base

# tree

.

├──  apache-tomcat-8.5.43.tar.gz

├──  build-command.sh

L──  Dockerfile

0 directories, 3 files

# cat Dockerfile

#JDK Base Image

FROM harbor.magedu.net/pub-images/jdk-base:v8.212

MAINTAINER zhangshijie "zhangshijie@magedu.net"

RUN mkdir /apps /data/tomcat/webapps /data/tomcat/logs -pv

ADD apache-tomcat-8.5.43.tar.gz  /apps

RUN ln -sv /apps/apache-tomcat-8.5.43 /apps/tomcat && chown -R tomcat.tomcat /apps

/data -R

#ADD  filebeat-6.4.2-x86_64.rpm /tmp/

#RUN  yum install -y /tmp/filebeat-6.4.2-x86_64.rpm && rm -rf /tmp/filebeat-6.4.2-

x86_64.rpm

# cat build-command.sh

#!/bin/bash

docker build -t harbor.magedu.net/pub-images/tomcat-base:v8.5.43  .

sleep 3

docker push  harbor.magedu.net/pub-images/tomcat-base:v8.5.43

# docker run -it --rm -p 8801:8080 harbor.magedu.net/pub-images/tomcat-base:v8.5.43

/apps/tomcat/bin/catalina.sh  start

/apps/tomcat

/apps/tomcat

/apps/tomcat/temp

/usr/local/jdk/jre

/apps/tomcat/bin/bootstrap.jar:/apps/tomcat/bin/tomcat-juli.jar

# pwd

/opt/k8s-data/dockerfile/linux36/tomcat-app1

# tree

.

├──  app1.tar.gz

├──  build-command.sh

├──  catalina.sh

├──  Dockerfile

├──  filebeat.yml

├──  myapp

L──  index.html

├──  run_tomcat.sh

L──  server.xml

1 directory, 8 files

# cat Dockerfile

#tomcat web1

FROM harbor.magedu.net/pub-images/tomcat-base:v8.5.43

ADD catalina.sh /apps/tomcat/bin/catalina.sh

ADD server.xml /apps/tomcat/conf/server.xml

#ADD myapp/* /data/tomcat/webapps/myapp/

ADD app1.tar.gz /data/tomcat/webapps/myapp/

ADD run_tomcat.sh /apps/tomcat/bin/run_tomcat.sh

#ADD filebeat.yml /etc/filebeat/filebeat.yml

RUN chown  -R tomcat.tomcat /data/ /apps/

EXPOSE 8080 8443

CMD ["/apps/tomcat/bin/run_tomcat.sh"]

# cat  build-command.sh

#!/bin/bash

TAG=$1

docker build -t  harbor.magedu.net/linux36/tomcat-app1:${TAG} .

sleep 3

docker push  harbor.magedu.net/linux36/tomcat-app1:${TAG}

# pwd

/opt/k8s-data/yaml/linux36/tomcat-app1

# kubectl  apply  -f  tomcat-app1.yaml

deployment.extensions/linux36-tomcat-app1-deployment created

service/linux36-tomcat-app1-service created

upstream  tomcat_webserver {

server  linux36-tomcat-app1-service.linux36.svc.linux36.local:80;

}

server {

location /myapp {

proxy_pass  http://tomcat_webserver;

proxy_set_header   Host    $host;

proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_set_header X-Real-IP $remote_addr;

}

}

# pwd

/opt/k8s-data/yaml/linux36/nginx

# kubectl  delete -f nginx.yaml

# vim nginx.yaml

image: harbor.magedu.net/linux36/nginx-web1:v1 #更新镜像地址

# kubectl  apply -f nginx.yaml

# kubectl set image deployment/linux36-nginx-deployment  linux36-nginx-

container=harbor.magedu.net/linux36/n

ginx-web1:v2 -n linux36deployment.extensions/linux36-nginx-deployment image updated

# mkdir  /data/linux36 -p  #数据总⽬录

# mkdir /data/linux36/images  #图⽚⽬录

# mkdir /data/linux36/static  #静态⽂件⽬录

# vim  /etc/exports

/data/linux36 *(rw,no_root_squash)

# systemctl  restart nfs-server

root@k8s-master1:/opt/k8s-data/yaml/linux36/tomcat-app1# kubectl  apply -f tomcat-

app1.yaml

deployment.extensions/linux36-tomcat-app1-deployment configured

service/linux36-tomcat-app1-service unchanged

控制管理器默认每隔15s (可以通过–horizontal-pod-autoscaler-sync-period修改)查询metrics的资源使

⽤情况

⽀持以下三种metrics指标类型：

->预定义metrics (⽐如Pod的CPU)以利⽤率的⽅式计算

-> ⾃定义的Pod metrics，以原始值(raw value)的⽅式计算

-> ⾃定义的 object metrics

⽀持两种metrics查询⽅式：

->Heapster

-> ⾃定义的REST API

⽀持多metrics

测试系统⾃带的指标数据：

# curl http://localhost:8080/apis/metrics.k8s.io/v1beta1/nodes

# curl http://localhost:8080/apis/metrics.k8s.io/v1beta1/pods

测试指标数据：

# kubectl  top

# kubectl  top nodes #报错如下

Error from server (NotFound): the server could not find the requested resource (get

services http:heapster:)

解决⽅案：

# docker pull  k8s.gcr.io/metrics-server-amd64:v0.3.5 #google镜像仓库

# docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server- amd64:v0.3.5 #阿⾥云镜像仓库

或者

# docker tag k8s.gcr.io/metrics-server-amd64:v0.3.5

harbor.magedu.net/baseimages/metrics-server-amd64:v0.3.5

# docker push harbor.magedu.net/baseimages/metrics-server-amd64:v0.3.5

The push refers to repository [harbor.magedu.net/baseimages/metrics-server-amd64]

5f70bf18a086: Mounted from baseimages/heapster-influxdb-amd64

a41f1d5bc0e0: Pushed

3c0f8dc299d8: Pushed

v0.3.3: digest: sha256:e8efd0115ca97461715981072148cc1c8f33a06c9e0d3a34b18396cd1e7623a4

size: 944

# kubectl  apply  -f deploy/1.8+/

clusterrole.rbac.authorization.k8s.io/system:aggregated-metrics-reader created

clusterrolebinding.rbac.authorization.k8s.io/metrics-server:system:auth-delegator

created

rolebinding.rbac.authorization.k8s.io/metrics-server-auth-reader created

apiservice.apiregistration.k8s.io/v1beta1.metrics.k8s.io created

serviceaccount/metrics-server created

deployment.extensions/metrics-server created

service/metrics-server created

clusterrole.rbac.authorization.k8s.io/system:metrics-server created

clusterrolebinding.rbac.authorization.k8s.io/system:metrics-server created

root@k8s-master1:/opt# kubectl  top nodes

NAME           CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%

172.31.7.101   285m         7%     1802Mi          55%

172.31.7.102   249m         6%     1853Mi          57%

172.31.7.103   226m         5%     1780Mi          55%

172.31.7.111   138m         3%     1463Mi          28%

172.31.7.112   132m         3%     1478Mi          28%

172.31.7.113   117m         2%     1469Mi          28%

root@k8s-master1:/opt# kubectl  top pods  -n default

NAME        CPU(cores)   MEMORY(bytes)

busybox     0m           0Mi

net-test1   0m           1Mi

net-test2   0m           1Mi

net-test3   0m           0Mi

net-test4   0m           0Mi

# kubectl  autoscale deployment/nginx-deployment --min=2 --max=10 --cpu-percent=80 -n

magedu

horizontalpodautoscaler.autoscaling/nginx-deployment autoscaled

# kubectl  autoscale deployment/linux36-nginx-deployment    --min=2 --max=10 --cpu-

percent=80 -n linux36

horizontalpodautoscaler.autoscaling/linux36-nginx-deployment autoscaled

验证信息：

# kubectl describe  deployment/linux36-nginx-deployment    -n linux36

desired 最终期望处于READY状态的副本数

updated 当前完成更新的副本数

total 总计副本数

available 当前可⽤的副本数

unavailable 不可⽤副本数

root@k8s-master1:~# kubectl  get hpa -n linux36

NAME                                REFERENCE                                   TARGETS

M

INPODS   MAXPODS   REPLICAS   AGElinux36-tomcat-app1-podautoscaler

Deployment/linux36-tomcat-app1-deployment   <unknown>/200Mi, 0%/80%   2

5         4          10m

root@k8s-master1:~# kubectl   describe hpa linux36-tomcat-app1-podautoscaler  -n

linux36

Events:

Type    Reason             Age    From                       Message

----    ------             ----   ----                       -------

Normal  SuccessfulRescale  5m52s  horizontal-pod-autoscaler  New size: 5; reason:

Current number of replicas above Spec.MaxReplicas

Normal  SuccessfulRescale  8s     horizontal-pod-autoscaler  New size: 1; reason: All

metrics below target

# kubectl  get deployment -n linux36

NAME                             READY   UP-TO-DATE   AVAILABLE   AGE

linux36-nginx-deployment         4/4     4            4           5h48m

linux36-tomcat-app1-deployment   5/5     5            5           19m

# kubectl  edit deployment linux36-nginx-deployment -n linux36 #修改副本数/镜像地址

# kubectl  get  pods  -n linux36 #验证副本数是否与edit编辑之后的⼀致

NAME                                              READY   STATUS    RESTARTS   AGE

linux36-nginx-deployment-9968c6f5c-8twhk          1/1     Running   0          5h14m

linux36-nginx-deployment-9968c6f5c-r97xm          1/1     Running   0          38m

linux36-nginx-deployment-9968c6f5c-txlmm          1/1     Running   0          109m

# kubectl  label node  192.168.7.110 project=linux36

node/192.168.7.110 labeled

# kubectl label nodes 192.168.7.110  test_label=test

node/192.168.7.110 labeled

# pwd

/opt/k8s-data/yaml/linux36/nginx

apply  -f  nginx.yaml

get pods  -o wide -n linux36 #验证pod运⾏到了指定的node节点上

READY   STATUS             RESTARTS   AGE

NODE            NOMINATED NODE   READIN

ESS GATESlinux36-nginx-deployment-768c7fcb8-5dcq2   0/1     CrashLoopBackOff   5

3m32s   172.31.58.121   192.168.7.110   <none>           <none

deployment控制器⽀持两种更新策略：默认为滚动更新

1.滚动更新(rolling update)：

滚动更新是默认的更新策略，滚动更新是基于新版本镜像创建新版本pod，然后删除⼀部分旧版本pod，然后再创建 新版本pod，再删除⼀部分旧版本pod，直到就版本pod删除完成，滚动更新优势是在升级过程当中不会导致服务不可 ⽤，缺点是升级过程中会导致两个版本在短时间内会并存。

具体升级过程是在执⾏更新操作后k8s会再创建⼀个新版本的ReplicaSet控制器，在删除旧版本的ReplicaSet控 制器下的pod的同时会在新版本的ReplicaSet控制器下创建新的pod，直到旧版本的pod全部被删除完后再把就版本的 ReplicaSet控制器也回收掉。

在执⾏滚动更新的同时，为了保证服务的可⽤性，当前控制器内不可⽤的pod(pod需要拉取镜像执⾏创建和执⾏探针 探测期间是不可⽤的)不能超出⼀定范围，因为需要⾄少保留⼀定数量的pod以保证服务可以被客户端正常访问，可以通 过以下参数指定：    #kubectl  explain  deployment.spec.strategy

deployment.spec.strategy.rollingUpdate.maxSurge #指定在升级期间pod总数可以超出定义好的期望的 pod数的个数或者百分⽐，默认为25%，如果设置为10%，假如当前是100个pod，那么升级时最多将创建110个pod即额 外有10%的pod临时会超出当前(replicas)指定的副本数限制。

deployment.spec.strategy.rollingUpdate.maxUnavailable #指定在升级期间最⼤不可⽤的pod数，可 以是整数或者当前pod的百分⽐，默认是25%，假如当前是100个pod，那么升级时最多可以有25个(25%)pod不可⽤即 还要75个(75%)pod是可⽤的。

#注意：以上两个值不能同时为0，如果maxUnavailable最⼤不可⽤pod为0，maxSurge超出pod数也为0，那么将 会导致pod⽆法进⾏滚动更新。

2.重建更新(recreate):

先删除现有的pod，然后基于新版本的镜像重建，优势是同时只有⼀个版本在线，不会产⽣多版本在线问题，缺点是 pod删除后到pod重建成功中间的时间会导致服务⽆法访问，因此较少使⽤。

# kubectl apply -f nginx.yaml --record=true #v1版本，  --record=true为记录执⾏的kubectl

#镜像更新命令格式为：

# kubectl set image  deployment/deployment-name containers-name=image -n namespace

#V2

#  kubectl set image  deployment/linux36-nginx-deployment   linux36-nginx-

container=harbor.magedu.net/linux36/nginx-web1:v2  -n linux36

deployment.extensions/linux36-nginx-deployment image updated

#V3

#  kubectl set image  deployment/linux36-nginx-deployment   linux36-nginx-

container=harbor.magedu.net/linux36/nginx-web1:v3  -n linux36

deployment.extensions/linux36-nginx-deployment image updated

查看历史版本信息：

# kubectl  rollout history deployment/linux36-nginx-deployment -n linux36

deployment.extensions/linux36-nginx-deployment

CHANGE-CAUSE

kubectl apply --filename=nginx.yaml --record=true

kubectl apply --filename=nginx.yaml --record=true

kubectl apply --filename=nginx.yaml --record=true

# kubectl   --help | grep cordon #警戒线

cordon         Mark node as unschedulable #标记为警戒，即不参加pod调度

uncordon       Mark node as schedulable #去掉警戒，即参加pod调度

#设置 192.168.7.110不参加调度

root@k8s-master1:/opt/k8s-data/yaml/linux36/nginx#  kubectl  cordon 192.168.7.110

node/192.168.7.110 cordoned

root@k8s-master1:/opt/k8s-data/yaml/linux36/nginx# kubectl  get node

#设置 192.168.7.110参加调度

root@k8s-master1:/opt/k8s-data/yaml/linux36/nginx#  kubectl  uncordon 192.168.7.110

node/192.168.7.110 uncordoned

root@k8s-master1:/opt/k8s-data/yaml/linux36/nginx# kubectl  get node

root@s4:/usr/local/src# tar xvf jdk-8u192-linux-x64.tar.gz

root@s4:/usr/local/src# ln  -sv /usr/local/src/jdk1.8.0_192 /usr/local/jdk

root@s4:~# vim /etc/profile

export JAVA_HOME=/usr/local/jdk

export JRE_HOME=$JAVA_HOME/jre

export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

export CLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:.

root@s4:~# source  /etc/profile

root@s4:~# java -version

java version "1.8.0_192"

Java(TM) SE Runtime Environment (build 1.8.0_192-b12)

Java HotSpot(TM) 64-Bit Server VM (build 25.192-b12, mixed mode)

root@s4:~# apt install daemon

root@s4:~# dpkg -i jenkins_2.138.4_all.deb

使⽤key-value的多维度格式保存数据

数据不使⽤MySQL这样的传统数据库，⽽是使⽤时序数据库，⽬前是使⽤的TSDB

⽀持第三⽅dashboard实现更⾼的图形界⾯，如grafana(Grafana 2.5.0版本及以上)

功能组件化

不需要依赖存储，数据可以本地保存也可以远程保存

服务⾃动化发现

强⼤的数据查询语句功(PromQL,Prometheus Query Language)

prometheus server：主服务，接受外部http请求，收集、存储与查询数据等

prometheus targets: 静态收集的⽬标服务数据

service discovery：动态发现服务

prometheus alerting：报警通知

push gateway：数据收集代理服务器(类似于zabbix proxy)

data visualization and export：    数据可视化与数据导出(访问客户端)

# pwd

/root/kube-prometheus/manifests

# vim grafana-service.yaml

apiVersion: v1

kind: Service

metadata:

labels:

app: grafana

name: grafana

namespace: monitoring

spec:

type: NodePort

ports:

- name: http

port: 3000

targetPort: http

nodePort: 33000

selector:

app: grafana

# kubectl apply  -f  grafana-service.yaml

# pwd

/usr/local/src

# tar xvf prometheus-2.24.1.linux-amd64.tar.gz

# ln -sv /apps/prometheus-2.24.1.linux-amd64 /apps/prometheus

'/apps/prometheus' -> '/apps/prometheus-2.24.1.linux-amd64'

# cd /apps/prometheus

# ll

prometheus.yml #配置⽂件

prometheus #prometheus服务可执⾏程序

promtool  #测试⼯具，⽤于检测配置prometheus配置⽂件、检测metrics数据等

./promtool check config prometheus.yml

Checking prometheus.yml

SUCCESS: 0 rule files found

# vim /etc/systemd/system/prometheus.service

[Unit]

Description=Prometheus Server

Documentation=https://prometheus.io/docs/introduction/overview/

After=network.target

[Service]

Restart=on-failure

WorkingDirectory=/apps/prometheus/

ExecStart=/apps/prometheus/prometheus   --config.file=/apps/prometheus/prometheus.yml

[Install]

WantedBy=multi-user.target

# mkdir  /apps

# cd /apps/

# tar xvf node_exporter-1.0.1.linux-amd64.tar.gz

# ln -sv /apps/node_exporter-1.0.1.linux-amd64 /apps/node_exporter

# cd /apps/node_exporter

node_exporter #可执⾏程序

# vim   /etc/systemd/system/node-exporter.service

[Unit]

Description=Prometheus Node Exporter

After=network.target

[Service]

ExecStart=/apps/node_exporter/node_exporter

[Install]

WantedBy=multi-user.target

瞬时向量 (instant vector):是⼀组时间序列，每个时间序列包含单个数据样本，⽐如                                             node_memory_MemTotal_bytes查询当前剩余内存就是⼀个瞬时向量，该表达式的返回值中只会包含该时间序列中的 最新的⼀个样本值，⽽相应的这样的表达式称之为瞬时向量表达式。

范围向量(range vector):是指在任何⼀个时间范围内，抓取的所有度量指标数据 . ⽐如最近⼀天的⽹卡流量趋势图。 标量 (scalar)：是⼀个浮点数类型的数据值，使⽤node_load1获取到时⼀个瞬时向量，但是可⽤使⽤内置函数         scalar()将瞬时向量转换为标量。

字符串 (string):字符串类型的数据，⽬前使⽤较少

#查询格式<metric name>{<label name>=<label value>, ...}

node_load1{instance="172.31.7.111:9100"}

node_load1{job="promethues-node"}

node_load1{job="promethues-node",instance="172.31.7.111:9100"}

node_load1{job="promethues-node",instance!="172.31.7.111:9100"}

s - 秒

m - 分钟

h - ⼩时

d - 天

w - 周

y - 年

node_memory_MemTotal_bytes{} # 瞬时向量表达式，选择当前最新的数据                                     node_memory_MemTotal_bytes{}[5m] # 区间向量表达式，选择以当前时间为基准，  5分钟内的数据 node_memory_MemTotal_bytes{instance="172.31.7.111:9100"}[5m]

+ 加法

- 减法

* 乘法 / 除法 % 模   ^ 幂等

node_memory_MemFree_bytes/1024/1024 #将内存进⾏单位转换                                                                     node_disk_read_bytes_total{device="sda"} + node_disk_written_bytes_total{device="sda"}

#计算磁盘每秒读写数据量

sum (求和 )

min (最⼩值 )

max (最⼤值 )

avg (平均值 )

stddev (标准差)

stdvar (标准差异)

count (计数 )

count_values (对  value 进⾏计数 )

bottomk (样本值最⼩的  k 个元素 )

topk (样本值最⼤的k个元素 )

quantile (分布统计)

max(node_memory_MemFree_bytes) #获5分钟内的最⼤值

sum(http_requests_total) #计算http_requests_total最近的请求总量

# vim /etc/grafana/grafana.ini

[server]

# Protocol (http, https, socket)

protocol = http

# The ip address to bind to, empty will bind to all interfaces

http_addr = 0.0.0.0

# The http port  to use

http_port = 3000

在线安装：

# grafana-cli plugins install grafana-piechart-panel

离线安装：

# pwd

/var/lib/grafana/plugins

# unzip grafana-piechart-panel-v1.3.8-0-g4f34110.zip

# mv grafana-piechart-panel-4f34110 grafana-piechart-panel

# systemctl  restart grafana-server

# docker load -i  cadvisor-v0.38.7.tar.gz

# docker tag gcr.io/cadvisor/cadvisor:v0.38.7

harbor.magedu.net/linux46/cadvisor:v0.38.7

# docker push harbor.magedu.net/linux46/cadvisor:v0.38.7

# docker run -it -d  \

--volume=/:/rootfs:ro \

--volume=/var/run:/var/run:ro \

--volume=/sys:/sys:ro \

--volume=/var/lib/docker/:/var/lib/docker:ro \

--volume=/dev/disk/:/dev/disk:ro \

--publish=8080:8080 \

--detach=true \

--name=cadvisor \

--privileged \

--device=/dev/kmsg \

harbor.magedu.net/linux46/cadvisor:v0.38.7

global:

smtp_from:      #发件⼈邮箱地址

smtp_smarthost: #邮箱smtp地址。

smtp_auth_username:  #发件⼈的登陆⽤户名，默认和发件⼈地址⼀致。

smtp_auth_password:  #发件⼈的登陆密码，有时候是授权码。

smtp_require_tls:    #是否需要tls协议。默认是true。

wechart_api_url:     #企业微信API 地址。

wechart_api_secret：    #企业微信API secret

wechat_api_corp_id:  #企业微信corp id信息。

resolve_timeout:  #在指定时间内没有产⽣新的事件就发送恢复通知

# systemctl  restart  alertmanager.service

#验证alertmanager的9093端⼝已经监听

# lsof  -i:9093

COMMAND      PID USER

alertmana 127083 root

# cd  /usr/local/prometheus

# vim prometheus.yml

# Alertmanager configuration

alerting:

alertmanagers:

- static_configs:

- targets:

- 192.168.7.102:9093  #alertmanager地址

# Load rules once and periodically evaluate them according to the global

'evaluation_interval'.

rule_files:

- "/apps/prometheus/rule.yml" #指定规则⽂件

# - "second_rules.yml"

# pwd

/usr/local/prometheus

#验证报警规则设置：

#  ./promtool check rules  rule-linux36.yml  #监测rule规则⽂件是否正确

Checking rule-linux36.yml

SUCCESS: 3 rules found

# pwd

/usr/local/src

# tar xvf haproxy_exporter-0.9.0.linux-amd64.tar.gz

# ln -sv /usr/local/src/haproxy_exporter-0.9.0.linux-amd64 /usr/local/haproxy_exporter

# cd /usr/local/haproxy_exporter

# ./haproxy_exporter --haproxy.scrape-uri=unix:/run/haproxy/admin.sock

# ./haproxy_exporter --haproxy.scrape-

uri="http://haadmin:q1w2e3r4ys@127.0.0.1:9999/haproxy-status;csv" &

# vim /usr/local/prometheus/prometheus.yml

# cd /usr/local/prometheus/

#  grep -v "#"  prometheus.yml  | grep -v "^$"

global:

alerting:

alertmanagers:

- static_configs:

- targets: ["192.168.7.102:9093"]

rule_files:

- "/usr/local/prometheus/rule-linux36.yml"

scrape_configs:

- job_name: 'prometheus'

static_configs:

- targets: [ 'localhost:9090']

- job_name: 'promethues-node'

static_configs:

- targets: [ '192.168.7.110:9100', '192.168.7.111:9100']

- job_name: 'prometheus-containers'

static_configs:

- targets: ["192.168.7.110:8080","192.168.7.111:8080"]

- job_name: 'prometheus-haproxy'

static_configs:

- targets: ["192.168.7.108:9101"]

# git clone https://github.com/vozlt/nginx-module-vts.git

# wget http://nginx.org/download/nginx-1.18.0.tar.gz

# tar xvf nginx-1.18.0.tar.gz

# cd nginx-1.18.0/

# ./configure --prefix=/apps/nginx --add-module=/usr/local//src/nginx-module-vts/

# cd /apps/nginx/conf/

# vim nginx.conf

#gzip  on;

vhost_traffic_status_zone; #

server {

listen       80;

server_name  localhost;

#charset koi8-r;

#access_log  logs/host.access.log  main;

location / {

root   html;

index  index.html index.htm;

}

location /status {

vhost_traffic_status_display;

vhost_traffic_status_display_format html;

}

}

root@grafana-server:/apps/nginx/conf# /apps/nginx/sbin/nginx  -t

nginx: the configuration file /apps/nginx/conf/nginx.conf syntax is ok

nginx: configuration file /apps/nginx/conf/nginx.conf test is successful

root@grafana-server:/apps/nginx/conf# /apps/nginx/sbin/nginx

# wget https://github.com/hnlq715/nginx-vts-exporter/releases/download/v0.10.3/nginx-

vts-exporter-0.10.3.linux-amd64.tar.gz

# tar xvf nginx-vts-exporter-0.10.3.linux-amd64.tar.gz

# ln -sv /apps/nginx-vts-exporter-0.10.3.linux-amd64 /apps/nginx-vts-exporter

'/apps/nginx-vts-exporter' -> '/apps/nginx-vts-exporter-0.10.3.linux-amd64'

# cd /apps/nginx-vts-exporter

# ./nginx-vts-exporter  -nginx.scrape_uri http://172.31.7.162/status/format/json

curl 'https://oapi.dingtalk.com/robot/send?

access_token=ba217ad9d1b70a9c8b10a88f46bb5e0e04fbcfd36bf80d22ee7cd99c79648dad' \

-H 'Content-Type: application/json' \

-d '{"msgtype": "text",

"text": {

"content": "业务运维报警机器⼈ -Node01 is down"

}

} '

PersistentVolume ( PV)是集群中已由管理员配置的⼀段⽹络存储，集群中的存储资源就像⼀个node节点是⼀个集 群资源，  PV是诸如卷之类的卷插件，但是具有独⽴于使⽤ PV的任何单个pod的⽣命周期，    该API对象捕获存储的实现细 节，即NFS，  iSCSI或云提供商特定的存储系统，  PV是由管理员添加的的⼀个存储的描述，是⼀个全局资源即不⾪属于

任何namespace，包含存储的类型，存储的⼤⼩和访问模式等，它的⽣命周期独⽴于Pod，例如当使⽤它的Pod销毁时 对PV没有影响。

PersistentVolumeClaim ( PVC)是⽤户存储的请求，它类似于pod，Pod消耗节点资源，  PVC消耗存储资源，    就像 pod可以请求特定级别的资源(CPU和内存)，  PVC是namespace中的资源，可以设置特定的空间⼤⼩和访问模式。

kubernetes 从1.0版本开始⽀持PersistentVolume和PersistentVolumeClaim。

PV是对底层⽹络存储的抽象，即将⽹络存储定义为⼀种存储资源，将⼀个整体的存储资源拆分成多份后给不同的业务使

⽤。

PVC是对PV资源的申请调⽤，就像POD消费node节点资源⼀样 ,pod是通过PVC将数据保存⾄PV，PV在保存⾄存储。

# pwd

/opt/k8s-data/yaml/linux36/zookeeper

# tree

.

├──  pv

│      ├──  zookeeper-persistentvolumeclaim.yaml

│      L──  zookeeper-persistentvolume.yaml

L──  zookeeper.yaml

1 directory, 3 files

# kubectl  apply  -f  zookeeper-persistentvolumeclaim.yaml

persistentvolumeclaim/zookeeper-datadir-pvc-1 created

persistentvolumeclaim/zookeeper-datadir-pvc-2 created

persistentvolumeclaim/zookeeper-datadir-pvc-3 created

# pwd

/opt/k8s-data/yaml/linux36/zookeeper

# kubectl  apply  -f zookeeper.yaml

service/zookeeper created

service/zookeeper1 created

service/zookeeper2 created

service/zookeeper3 created

deployment.extensions/zookeeper1

deployment.extensions/zookeeper2

deployment.extensions/zookeeper3

# kubectl  get pod -n linux36

NAME

。。。。。。。。。。。。

zookeeper1-5f458745bf-lxsww

zookeeper2-5844958588-9gvjh

zookeeper3-7b646949f-w52cr

# kubectl  exec -it zookeeper2-5844958588-9gvjh  sh -n linux36

# pwd

/opt/k8s-data/dockerfile/linux36/redis

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  redis-4.0.14.tar.gz

├──  redis.conf

L──  run_redis.sh

0 directories, 5 file

# pwd

/opt/k8s-data/yaml/linux36/redis/pv

# kubectl  apply  -f .

persistentvolume/redis-datadir-pv-1 created

persistentvolumeclaim/redis-datadir-pvc-1 created

# pwd

/opt/k8s-data/yaml/linux36/redis

# tree

.

├──  pv

│      ├──  redis-persistentvolumeclaim.yaml

│      L──  redis-persistentvolume.yaml

L──  redis.yaml

1 directory, 3 files

# kubectl  apply  -f redis.yaml

deployment.extensions/deploy-devops-redis created

service/srv-devops-redis created

# pwd

/opt/k8s-data/yaml/linux36/redis

# kubectl  delete -f  redis.yaml

deployment.extensions "deploy-devops-redis" deleted

service "srv-devops-redis" deleted

# kubectl  apply  -f  redis.yaml

deployment.extensions/deploy-devops-redis created

service/srv-devops-redis created

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 特点：

-> 给每个pod分配固定且唯⼀的⽹络标识符

-> 给每个pod分配固定且持久化的外部存储

-> 对pod进⾏有序的部署和扩展

-> 对pod进有序的删除和终⽌

-> 对pod进有序的⾃动滚动更新

#准备xtrabackup镜像

# docker pull registry.cn-hangzhou.aliyuncs.com/hxpdocker/xtrabackup:1.0

# docker tag registry.cn-hangzhou.aliyuncs.com/hxpdocker/xtrabackup:1.0

harbor.magedu.net/linux36xtrabackup:1.0

# docker push harbor.magedu.net/linux36/xtrabackup:1.0

#准备mysql 镜像

# docker pull mysql:5.7

# docker tag mysql:5.7 harbor.magedu.net/baseimages/mysql:5.7

# docker push harbor.magedu.net/baseimages/mysql:5.7

# pwd

/opt/k8s-data/yaml/linux36/mysql

# ll

total 28

drwxr-xr-x 3 root root 4096 Aug  4 18:22 ./

drwxr-xr-x 7 root root 4096 Aug  4 18:19 ../

-rw-r--r-- 1 root root  364 Aug  4 17:34 mysql-configmap.yaml

-rw-r--r-- 1 root root  529 Aug  4 17:38 mysql-services.yaml

-rw-r--r-- 1 root root 5510 Aug  4 17:53 mysql-statefulset.yaml

drwxr-xr-x 2 root root 4096 Aug  4 18:20 pv/

# kubectl  create -f . -n linux36

configmap/mysql created

service/mysql created

service/mysql-read created

statefulset.apps/mysql created

# kubectl get pod -n linux36

STATUS

Running

Running

Running

# kubectl  delete pod mysql-0 -n linux36

pod "mysql-0" deleted

# kubectl get pod -n linux36

STATUS

Running

Running

Running

# kubectl  delete pod mysql-1 -n linux36

pod "mysql-1" deleted

# pwd

/opt/k8s-data/dockerfile/linux36/jenkins

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  jenkins-2.164.3.war

L──  run_jenkins.sh

0 directories, 4 files

root@k8s-ha1:/data/linux36# ll  /data/k8sdata/linux36/jenkins-data

root@k8s-ha1:/data/linux36# ll /data/k8sdata/linux36/jenkins-root-data

# kubectl  apply  -f pv/

persistentvolume/jenkins-datadir-pv created

persistentvolume/jenkins-root-datadir-pv created

persistentvolumeclaim/jenkins-datadir-pvc created

persistentvolumeclaim/jenkins-root-data-pvc created

# kubectl  get pv -n linux36

NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS

jenkins-datadir-pv 100Gi   RWO   Retain    Bound

jenkins-root-datadir-pv 100Gi RWO  Retain  Bound

root@k8s-master1:/opt/k8s-data/yaml/linux36/jenkins# kubectl  get pvc  -n linux36

NAME           STATUS  VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS   AGE

jenkins-datadir-pv

jenkins-root-datadir-pv

# pwd

/opt/k8s-data/yaml/linux36/jenkins

root@k8s-master1:/opt/k8s-data/yaml/linux36/jenkins# tree

.

├──  jenkins.yaml

L──  pv

├──  jenkins-persistentvolumeclaim.yaml

L──  jenkins-persistentvolume.yaml

1 directory, 3 files

# pwd

/opt/k8s-data/yaml/linux36/jenkins

# kubectl  apply  -f jenkins.yaml

deployment.extensions/linux36-jenkins-deployment created

service/linux36-jenkins-service created

# kubectl  get pods -n  linux36

NAME

linux36-jenkins-deployment-74c4b55576-ssxdv

# kubectl  describe pods linux36-jenkins-deployment-74c4b55576-ssxdv  -n linux36

Events:

Type    Reason     Age   From                    Message

----    ------     ----  ----                    -------

Normal  Scheduled  60s   default-scheduler       Successfully assigned

linux36/linux36-jenkins-deployment-74c4b55576-ssxdv to 192.168.7.111

Normal  Pulling    58s   kubelet, 192.168.7.111  pulling image

"harbor.magedu.net/linux36/jenkins:v2.164.3"

Normal  Pulled     55s   kubelet, 192.168.7.111  Successfully pulled image

"harbor.magedu.net/linux36/jenkins:v2.164.3"

7.3.5：  k8s 示例之WordPress:

LNMP案例之基于Nginx+PHP实现WordPress博客站点，要求Nginx+PHP运⾏在同⼀个Pod的不同容器，

运⾏与default的namespace并可以通过service name增删改查数据库。

https://cn.wordpress.org/

https://cn.wordpress.org/download/releases/

wordpress-5.0.2-zh_CN.tar.gz

7.3.5.1 ：准备PHP镜像：

7.3.5.1.1：官⽅PHP镜像：

https://hub.docker.com/

MySQL

# docker pull php:5.6.40-fpm

# docker tag php:5.6.40-fpm  harbor.magedu.net/linux36/php:5.6.40-fpm

# docker push harbor.magedu.net/linux36/php:5.6.40-fpm

# pwd

/opt/k8s-data/dockerfile/linux36/wordpress/php

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  run_php.sh

L── www.conf

0 directories, 4 files

# bash build-command.sh  v1

# pwd

/opt/k8s-data/dockerfile/linux36/wordpress/nginx

# tree

.

├──  build-command.sh

├──  Dockerfile

├──  index.html

├──  nginx.conf

L──  run_nginx.sh

0 directories, 5 files

# bash build-command.sh  v1

# pwd

/opt/k8s-data/yaml/linux36/wordpress

# kubectl  apply -f .

deployment.extensions/wordpress-app-deployment created

service/wordpress-app-spec created

# pwd

/data/k8sdata/linux36/wordpress

# cat test.php

<?php

phpinfo();

?>

linux36# chown  2001.2001 wordpress/ -R

# kubectl  exec -it mysql-0 sh -n linux36

.....

mysql> CREATE DATABASE wordpress;

Query OK, 1 row affected (0.01 sec)

mysql>  GRANT ALL PRIVILEGES ON wordpress.* TO "wordpress"@"%"  IDENTIFIED BY

"wordpress";

Query OK, 0 rows affected, 1 warning (0.01 sec)

pwd

/opt/k8s-data/yaml/linux36/dubbo/consumer

# kubectl  apply  -f .

deployment.extensions/linux36-consumer-deployment created

service/linux36-consumer-spec created

# pwd

/opt/k8s-data/dockerfile/linux36/dubbo/dubboadmin

# vim dubboadmin/WEB-INF/dubbo.properties

# zip -r  dubboadmin.war dubboadmin/*

# bash build-command.sh

#cat build-command.sh

#!/bin/bash

#echo "nameserver 223.6.6.6" > /etc/resolv.conf

#echo "192.168.7.248 k8s-vip.example.com" >> /etc/hosts

/usr/share/filebeat/bin/filebeat -c /etc/filebeat/filebeat.yml -path.home

/usr/share/filebeat -path.config /etc/filebeat -path.data /var/lib/filebeat -path.logs

/var/log/filebeat  &

su - tomcat -c "/apps/tomcat/bin/catalina.sh start"

tail -f /etc/hosts

filebeat.inputs:

- type: log

enabled: true

paths:

- /apps/tomcat/logs/catalina.out

fields:

type: tomcat-catalina

filebeat.config.modules:

path: ${path.config}/modules.d/*.yml

reload.enabled: false

setup.template.settings:

index.number_of_shards: 1

setup.kibana:

output.redis:

hosts: ["172.31.2.105:6379"]

key: "k8s-magedu-app1"

db: 1

timeout: 5

password: "123456"