学习k8s（一）
一、安装及介绍
1、k8s架构
2、核心组件
3、其他组件
4、安装方式
yum安装： 1.5 最简单，版本低，适合学习
二进制安装： 最繁琐，可以用saltstack安装
kubeadm安装： 谷歌推荐的自动化安装工具，网络有要求
go源码编译安装： 最难，需要go环境
minikube： 单机版，只适合体验
5、环境介绍
|
主机 |
ip地址 |
cpu核数 |
内存 |
swap |
host解析 |
软件版本 |
|
k8s-master |
192.168.4.11 |
1+ |
2G+ |
关闭 |
需要 |
docker-1.12.6-71 |
|
k8s-node |
192.168.4.12 |
1+ |
2G+ |
关闭 |
需要 |
kubernetes-1.5.2 |
# hostnamectl set-hostname k8s-master
# hostnamectl set-hostname k8s-node 192.168.4.11 k8s-master
192.168.4.12 k8s-node # setenforce 0
# systemctl stop firewalld.service
# systemctl stop NetworkManager.service
6、配置yum源
# cat /etc/yum.repos.d/mnt.repo
[old-os]
name=old
baseurl=https://mirrors.aliyun.com/centos/7/os/x86_64/
enabled=1
gpgcheck=0 [new-os]
name=os
baseurl=https://mirrors.aliyun.com/centos/7.7.1908/os/x86_64/
enabled=0
gpgcheck=0 [extras]
name=extras
baseurl=https://mirrors.aliyun.com/centos/7.7.1908/extras/x86_64/
enabled=0
gpgcheck=0 [epel]
name=epel
baseurl=https://mirrors.aliyun.com/epel/7Server/x86_64/
enabled=0
gpgcheck=0 [vault]
name=va
baseurl=http://vault.centos.org/7.4.1708/extras/x86_64
enabled=1
gpgcheck=0
7、安装配置k8s-master
1）安装配置etcd
1、安装etcd（数据库kv类型存储，原生支持做集群）
# yum install -y etcd 2、配置etcd
# grep '^[a-Z]' /etc/etcd/etcd.conf
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"
ETCD_NAME="default"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.4.11:2379" 3、启动服务
# systemctl enable etcd
# systemctl start etcd 4、取值检验
# etcdctl set testdir/testkey test
# etcdctl get testdir/testkey 5、健康状态检查
# etcdctl -C http://192.168.4.11:2379 cluster-health
6、netstat -lntp | grep etcd
# 2379：对外提供服务,k8s写入数据
# 2380：集群间数据同步
2）安装配置K8s-master
1、安装
# yum install kubernetes-master -y 2、修改api配置文件
# grep '^[a-Z]' /etc/kubernetes/apiserver 8:KUBE_API_ADDRESS="--insecure-bind-address=0.0.0.0"
17:KUBE_ETCD_SERVERS="--etcd-servers=http://192.168.4.11:2379"
20:KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.254.0.0/16"
23:KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"
26:KUBE_API_ARGS=""
#删除23行ServiceAccount 服务认证，会很坑。 3、修改config配置文件（公共配置文件）
# grep '^[a-Z]' /etc/kubernetes/config 13:KUBE_LOGTOSTDERR="--logtostderr=true"
16:KUBE_LOG_LEVEL="--v=0"
19:KUBE_ALLOW_PRIV="--allow-privileged=false"
22:KUBE_MASTER="--master=http://192.168.4.11:8080"
# 指定apiserver地址，给controller-manager和scheduler使用，日志默认在/var/log/messages，可修改。 4、启动服务
# systemctl enable kube-apiserver.service
# systemctl start kube-apiserver.service
# systemctl enable kube-controller-manager.service
# systemctl start kube-controller-manager.service
# systemctl enable kube-scheduler.service
# systemctl start kube-scheduler.service 5、检查服务是否安装正常
# kubectl get cs
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
controller-manager Healthy ok
etcd-0 Healthy {"health":"true"} 组件作用
api-server： 接受并响应用户的请求
controller： 控制器管理，保证容器始终存活
scheduler： 调度器，选择启动容器的node节点
8、安装配置k8s-node
1、安装
# yum install kubernetes-node -y 2、配置
# grep '^[a-Z]' /etc/kubernetes/config -n
13:KUBE_LOGTOSTDERR="--logtostderr=true"
22:KUBE_MASTER="--master=http://192.168.4.11:8080" # grep '[^a-Z]'/etc/kubernetes/kubelet
5行：KUBELET_ADDRESS="--address=0.0.0.0"
8行：KUBELET_PORT="--port=10250"
11行：KUBELET_HOSTNAME="--hostname-override=192.168.4.12"
14行：KUBELET_API_SERVER="--api-servers=http://192.168.4.11:8080" 3、启动服务
# systemctl enable kubelet.service
# systemctl start kubelet.service
# systemctl enable kube-proxy.service
# systemctl start kube-proxy.service 4、在master节点检查
# kubectl get nodes
NAME STATUS AGE
192.168.4.12 Ready 4d
组件作用
kubelet： 调用docker，管理容器生命周期
kube-proxy： 提供容器的网络访问
8、所有节点安装flannel网络
flannel：不同宿主机之间容器的通信
1、安装
# yum install flannel -y
# yum install docker-1.12.6-71.git3e8e77d.el7.centos.x86_64（master节点要配置镜像仓库）
2、配置
# grep '^[a-Z]' /etc/sysconfig/flanneld -n
4:FLANNEL_ETCD_ENDPOINTS="http://192.168.4.11:2379"
8:FLANNEL_ETCD_PREFIX="/atomic.io/network"
#也可以用sed替换
# sed -i s#127.0.0.1:2379#192.168.4.11:2379#g /etc/sysconfig/flanneld 3、master节点
# etcdctl mk /atomic.io/network/config '{"Network":"172.16.0.0/16"}' #docker网段
如果设置错了，删除重新设置
# etcdctl get /atomic.io/network/config
# etcdctl rm /atomic.io/network/config 4、启动服务
# systemctl enable flanneld.service
# systemctl restart flanneld.service
# systemctl restart docker
# systemctl enable docker
master节点：
# systemctl restart kube-apiserver.service
# systemctl restart kube-controller-manager.service
# systemctl restart kube-scheduler.service
node节点：
# systemctl restart kubelet.service
# systemctl restart kube-proxy.service
5、检查服务
# ifconfig flannel0
docker1.13版本中的一个问题，需要修改iptables，否则容器之间不通
# vim /usr/lib/systemd/system/docker.service
ExecStartPost=/sbin/iptables -P FORWARD ACCEPT
容器网络互通测试
1、所有节点启动容器并获取容器ip地址
# docker run -it busybox /bin/sh 2、网络互通性测试
# ping 172.16.30.2 ping自己
# ping 172.16.30.1 ping网关
# ping 172.16.20.2 ping容器
配置master为镜像仓库
1、所有节点，配置镜像加速，以及私有仓库地址
1.13版本之前
# vim /etc/sysconfig/docker
OPTIONS='--selinux-enabled --log-driver=journald --signature-verification=false --registry-mirror=https://registry.docker-cn.com --insecure-registry=192.168.4.11:5000'
1.13版本之后
# vim /etc/docker/daemon.json
{
"registry-mirror": ["registry.docker-cn.com"],
"insecure-registries":["192.168.4.11:5000"]
}
重启服务
# systemctl restart docker
2、启动私有仓库
# docker run -d -p 5000:5000 --restart=always --name registry -v /opt/registry:/var/lib/registry registry 3、推送镜像测试
master节点：
# docker tag docker.io/busybox:latest 192.168.4.11:5000/busybox:latest
# docker push 192.168.4.11:5000/busybox:latest
node节点：
# docker images
# docker pull 192.168.4.11:5000/busybox:latest
二、功能和基础架构
1、k8s有什么功能
k8s是一个docker集群的管理工具
k8s是容器的编排工具
2、k8s的核心功能
自愈： 重新启动失败的容器，在节点不可用时，替换和重新调度节点上的容器，对用户定义的健康检查不响应的容器会被中止，并且，在容器准备好服务之前不会把容器向客户端广播。 弹性伸缩： 通过监控容器的cpu的使用负载，如果这个容器评价高于80%，增加容器的数量，平均值低于10%，减少容器数量。 服务的自动发现和负载均衡： 不需要修改您的应用程序来使用不熟悉的服务发现机制，kubernetes为容器提供了自己的ip地址和一组容器的单个DNS名称，并可以在他们之间进行负载均衡。 滚动升级和一键回滚: kubernetes 逐渐部署对应用程序或者其配置的更改，同时监视应用程序运行状况，以确保它不会同时终止所有实例。如果出现问题，kubernetes会为你恢复更改，利用日益增长的部署，解决方案的生态系统。 私密配置文件管理： web容器里面，数据库的账户密码（测试库密码）
3、k8s的应用场景
最适合跑微服务项目！
微服务的好处
能承载更高的并发
业务健壮性，高可用
修改代码，重新编译时间短 持续集成，持续发布
jenkins代码自动上线
三、k8s常用的资源
1、pod资源
pod是最小的资源单位
任何一个k8s资源都可以有yml清单文件来定义
k8s yaml的主要组成
apiVersion: v1 api版本
kind: pod 资源类型
metadata: 属性
spec: 详细
pod基本操作
创建
# kubectl create –f ks8_pod.yaml 查询
# kubectl get pod
# kubectl describe pod
# kubectl get pod -o wide 查看资源列表 删除
# kubectl delete pod nginx
# kubectl delete -f ks8_pod.yaml
更新
# Kubectl replace ks8_pod.yaml
一个最简单的pod
编辑k8s_pod.yml文件
apiVersion: v1 #版本
kind: Pod #资源类型
metadata: #元数据（属性）
name: nginx #pod名字
labels: #标签 键值对
app: web
spec: #详细
containers: #容器
- name: nginx #名字
image: 192.168.4.11:5000/nginx:latest #镜像
ports:
- containerPort: 80 #端口
启动pod
# kubectl create -f ks8_pod.yaml
获取pod详细信息kubectl describe(排错常用命令)
# kubectl describe pod nginx
构建成失败，此处有坑
错误是无法从registry.access.redhat.com仓库获取镜像
解决办法：
1、下载redhat-ca.crt证书
2、下载镜像文件，tag改名，上传到私有仓库
node节点
# vim /etc/kubernetes/kubelet
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container image=192.168.4.11:5000/pod-infrastructure:latest"
重启服务
# systemctl restart kubelet.service
pod资源：至少由两个容器组成，pod基础容器和业务容器组成(最多1+4)
pod网络类型是container
Nginx没有IP地址
# docker ps -a
CONTAINER ID IMAGE
b28f849335a7 192.168.4.11:5000/nginx:latest
2bed13c3afda 192.168.4.11:5000/pod-infrastructure:latest # docker inspect b28f849335a7| tail -22
"NetworkSettings": {
"Bridge": "",
"SandboxID": "",
"HairpinMode": false,
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"Ports": null,
"SandboxKey": "",
"SecondaryIPAddresses": null,
"SecondaryIPv6Addresses": null,
"EndpointID": "",
"Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"IPAddress": "",
"IPPrefixLen": 0,
"IPv6Gateway": "",
"MacAddress": "",
"Networks": {}
}
访问的IP实际是pod-infrastructure容器的ip
# docker inspect 01549ff0cf31| tail -22
"IPPrefixLen": 24,
"IPv6Gateway": "",
"MacAddress": "02:42:ac:10:0e:02",
"Networks": {
"bridge": {
"IPAMConfig": null,
"Links": null,
"Aliases": null,
"NetworkID": "91b2a8f0e6bc27e794c236206658ff980174af5af50f5c8960da2920d3936eca",
"EndpointID": "32d012474893339123e7ce707d89528831a50fd05374bb773fe5abab050b1e81",
"Gateway": "172.16.30.1",
"IPAddress": "172.16.30.2",
"IPPrefixLen": 24,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:10:0e:02"
}
}
原理：Nginx只提供web服务，pod-infrastructure的基础容器提供IP，实现k8s负载均衡、服务自愈等高级功能。
一个pod两个容器nginx+redis(端口不冲突即可)
1、编辑pod文件
# cat ks8_pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: test
labels:
app: web
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80 - name: redis
image: redis:latest
imagePullPolicy: IfNotPresent（使用本地镜像，不要pull）
ports:
- containerPort: 6379 2、创建并验证
# kubectl create -f ks8_pod.yaml
# kubectl get pods -o wide
NAME READY STATUS RESTARTS AGE IP NODE
po/test 2/2 Running 0 25s 172.16.30.2 192.168.4.12
访问Nginx和Redis，共用一个ip
# curl -I 172.16.30.2
# telnet 172.16.30.2 6379
node1节点上有3个容器 Nginx+ Redis + pod
# docker ps
CONTAINER ID IMAGE COMMAND
922e73599020 redis:latest "docker-entrypoint..."
28690cdbc403 nginx:latest "nginx -g 'daemon off"
c630ef8c2216 pod-infrastructure:latest "/pod"
k8s每启动一个容器，都需要先启动一个pod容器，启动的容器共用pod容器的ip地址
2、ReplicationController 资源
通过metadata标签，选择器selector管理pod
rc：保证指定数量的pod始终存活，确保pod数量，确保pod健康，弹性伸缩，滚动升级
创建yaml文件
# vim myweb-rc.yml
apiVersion: v1
kind: ReplicationController
metadata:
name: myweb #rc的名字
spec:
replicas: 3 #副本数
selector:
app: myweb #选择器，管理pod
template:
metadata:
labels:
app: myweb #此为pod的标签
spec:
containers:
- name: nginx
image: 192.168.4.11:5000/nginx:latest
ports:
- containerPort: 80
故障自愈（多次删除自动新启动容器）
1、创建
# kubectl create -f myweb-rc.yaml
2、查看
# kubectl get all -o wide
NAME DESIRED CURRENT READY AGE CONTAINER(S) IMAGE(S) SELECTOR
rc/myweb 3 3 3 21s nginx nginx:latest app=myweb NAME READY STATUS RESTARTS AGE IP NODE
po/myweb-9gngt 1/1 Running 0 21s 172.16.30.4 192.168.4.12
po/myweb-blrwr 1/1 Running 0 21s 172.16.30.3 192.168.4.12
po/myweb-wk6gm 1/1 Running 0 21s 172.16.30.2 192.168.4.12 3、删除pod，rc会自动创建
# kubectl delete pod myweb-9gngt
# kubectl delete pod myweb-wk6gm
# kubectl get pods -o wide
NAME READY STATUS RESTARTS AGE IP NODE
po/myweb-blrwr 1/1 Running 0 51s 172.16.30.3 192.168.4.12
po/myweb-8dkee 1/1 Running 0 21s 172.16.30.5 192.168.4.12
po/myweb-7wsek 1/1 Running 0 21s 172.16.30.6 192.168.4.12
弹性伸缩—手动
方式一：kubectl scale rc 【rc-name】 --replicas=1
1、查看rc名字
# kubectl get rc -o wide 2、修改副本数
# kubectl scale rc myweb --replicas=5 3、查看结果
# kubectl get pods -o wide --selector app=myweb
方式二 ：手动编辑
# kuberctl edit rc myweb
设置 replicas
服务发现和负载均衡
1、查看当前rc和pod
# kubectl get all -o wide --show-labels
NAME DESIRED CURRENT READY AGE CONTAINER(S) IMAGE(S) SELECTOR LABELS
rc/myweb 3 3 3 21s nginx nginx:latest app=myweb app=myweb
NAME READY STATUS RESTARTS AGE IP NODE LABELS
po/myweb-blrwr 1/1 Running 0 51s 172.16.30.3 192.168.4.12 app=myweb
po/myweb-8dkee 1/1 Running 0 21s 172.16.30.5 192.168.4.12 app=myweb
po/myweb-7wsek 1/1 Running 0 21s 172.16.30.6 192.168.4.12 app=myweb
po/test 1/1 Running 0 56s 172.16.30.2 192.168.4.12 app=web
2、修改test标签:app=myweb
# kubectl edit pod test
app: myweb
kubectl get pod
NAME READY STATUS RESTARTS AGE
po/myweb-blrwr 1/1 Running 0 8m
po/myweb-8dkee 1/1 Running 0 8m
po/test 1/1 Running 0 1h
3、小结
1）因为rc控制器设置最少保持3个副本
2）rc控制器是根据Labels 标签来区分的
3）test的标签和myweb控制器的标签一样，所以就删除了存活时间最短的容器（rc认为pod存活久的比较稳定，默认删除新的pod）
rc滚动的升级和回滚
1、创建nginx两个版本yaml文件
# cat nginx-1.13-rc.yaml
kind: ReplicationController
apiVersion: v1
metadata:
name: nginx
spec:
replicas: 1
selector:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.13
ports:
- containerPort: 80 # cat nginx-1.15-rc.yaml
kind: ReplicationController
apiVersion: v1
metadata:
name: nginx
spec:
replicas: 1
selector:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.15
ports:
- containerPort: 80 2、滚动升级
# kubectl create -f nginx-1.13-rc.yaml 创建旧版本nginx
# kubectl rolling-update nginx -f nginx-1.15-rc.yaml --update-period=20s
# curl -I 172.16.30.2 检查版本
3、一键回滚
# kubectl rolling-update nginx -f nginx-1.13-rc.yaml --update-period=10s
# curl -I 172.16.30.2 检查版本
3、deployment资源
rc在滚动升级之后,会造成服务访问中断,于是k8s引入了deployment资源
对比rc的好处：
升级服务不中断
不依赖yaml文件
rc标签选择器不支持模糊匹配，rs标签选择器支持模糊匹配
通过文件创建deployment
1、创建yaml文件
# cat nginx-dep.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx-dep
spec:
replicas: 3
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: 192.168.4.11:5000/nginx:1.13
ports:
- containerPort: 80
2、启动
# kubectl create -f nginx-dep.yaml 3、查看
# kubectl get deploy DESIRED : Pod副本数量的期望值，即Deployment里定义的Replica。
CURRENT： 当前实际的Replica数量，当这个值不断增加，达到DESIRED时表明部署完成。
UP-TO-DATE：最新版本的Pod副本数量，用于指示在滚动升级过程中有多少Pod副本已经成功升级。
AVAILABLE: 当前集群中可用的Pod副本数量（当前存活的Pod数量）
自动加载deployment配置
deployment编辑配置之后可以自动加载，不想rc还需要删除再启动。
1、修改副本数
# kubectl edit deployment nginx-dep
replicas: 2 2、查看
# kubectl get all -o wide
通过命令行创建deployment
1、命令创建
# kubectl run nginx-dep2 --image=192.168.4.11:5000/nginx:1.15 --replicas=1 --record 2、查看
# kubectl get all
手动扩容缩容
# kubectl scale deployment nginx-dep2 --replicas=2
# kubectl get all
升级pod镜像版本
1、查看pod镜像版本及名字
# kubectl get rs -o wide 2、升级镜像
# kubectl set image deploy nginx-dep2 nginx-dep2=192.168.4.11:5000/nginx:1.15
nginx-dep2=192.168.4.11:5000/nginx:1.15 的名字
3、查看升级结果
# kubectl get rs -o wide 4、查看升级状态
# kubectl rollout status deployment nginx-dep2 5、查看升级历史
# kubectl rollout history deployment nginx-dep2 6、查看历史版本详情
# kubectl rollout history deployment nginx-dep2 --revision=2
回滚pod镜像版本
1、查看历史版本
# kubectl rollout history deployment nginx-dep2 2、执行回滚指定版本
# kubectl rollout undo deployment nginx-dep2 --to-revision=1 3、检查回滚结果
# kubectl get pods -o wide
# curl -I 172.16.30.2
生产建议--record
--record参数： 记录执行的操作步骤和相关信息，生产建议采用这种方式创建deployment
rc和deployment的升级区别
rc:
# kubectl rolling-update nginx -f nginx-1.15-rc.yaml --update-period=20s 升级
# kubectl rolling-update nginx -f nginx-1.13-rc.yaml --update-period=20s 回滚 deploy：
# kubectl create -f nginx-dep.yaml --record 文件创建
# kubectl set image deploy nginx-dep nginx=192.168.4.11:5000/nginx:1.15 升级或回滚 # kubectl run nginx-dep2 --image=192.168.4.11:5000/nginx:1.15 --replicas=1 --record
# kubectl set image deploy nginx-dep2 nginx-dep2=192.168.4.11:5000/nginx:1.15 # kubectl rollout history deployment nginx-dep2 查看历史版本
# kubectl rollout undo deployment nginx-dep2 --to-revision=1 回滚指定版本
rc修改（edit）配置文件，需要启动新容器才生效
deploy修改配置文件，立即生效
4、service资源
介绍
Pod挂掉后ip地址会改变，外部不能访问容器内的服务，service是提供了一个固定IP，cluster ip（vip）,通过该固定的IP来进行通信
service的作用：帮助外界用户访问k8s内的服务，并且提供负载均衡
service默认使用iptables来实现负载均衡, k8s 1.8新版本中推荐使用lvs(四层负载均衡 传输层tcp,udp)
Service同RC一样，都是通过Label来关联Pod的。在Service的yaml文件中定义了selector中的label为app:my-web，那么这个Service会将Pod-->metadata-->labeks中label为app:my-web的Pod作为分发请求的后端。当Pod发生变化时（增加、减少、重建等），Service会及时更新。这样一来，Service就可以作为Pod的访问入口，起到代理服务器的作用，而对于访问者来说，通过Service进行访问，无需直接感知Pod。 需要注意的是，Kubernetes分配给Service的固定IP是一个虚拟IP，并不是一个真实的IP，在外部是无法寻址的。真实的系统实现上，Kubernetes是通过Kube-proxy组件来实现的虚拟IP路由及转发。所以在之前集群部署的环节上，我们在每个Node上均部署了Proxy这个组件，从而实现了Kubernetes层级的虚拟转发网络。
kubernetes中的三种IP
Node IP： Node节点IP地址
Cluster IP： Service的IP地址
Pod IP： Pod的IP地址
Service负载均衡
1、创建
# kubectl create -f myweb-svc.yaml
# cat myweb-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: nginx
spec:
type: NodePort #转发方式
ports:
- port: 80 #clusterIP（vip）端口
nodePort: 30001 #node端口
targetPort: 80 #pod 端口
selector:
run: nginx-dep2 #标签选择器（选择rc的pod资源） 2、查看service状态
# kubectl describe svc nginx
Name: nginx
Namespace: default
Labels: <none>
Selector: run=nginx-deployment2 #搜索标签
Type: NodePort #转发方式
IP: 10.254.18.231 #虚拟IP
Port: <unset> 80/TCP
NodePort: <unset> 30001/TCP #node暴露端口
Endpoints: 172.16.30.2:80,172.16.30.3:80,172.16.30.5:80 + 2 more... #pod
Session Affinity: None 3、访问测试
是由kuber-proxy服务提供的
# curl 192.168.4.11:30000
# curl 192.168.4.12:30000
修改Service的nodePort范围
默认分配30000-32767
1、修改默认端口
# vim /etc/kubernetes/apiserver
KUBE_API_ARGS="--service-node-port-range=10000-50000" 2、启动服务
# systemctl restart kube-apiserver.service
命令行创建service资源
# kubectl expose rc nginx --type=NodePort --port=80
# kubectl expose 资源类型 资源名称 端口类型 暴漏端口
其他
1、非交互式修改副本数量
# kubectl scale rc nginx --replicas=2
调度 名称 副本数
2、进入容器
# kubectl exec -it nginx-ld22v /bin/bash
3、网站curl 不通 排错思路：
内核转发参数，iptables规则
重启服务flanneld，docker ， kubelet ，kube-proxy
四、项目实践
1、简单web应用tomcat+mysql
准备镜像
1、下载
# docker pull kubeguide/tomcat-app:v2
# docker pull mysql:5.7 2、改名并上传
# docker tag docker.io/kubeguide/tomcat-app:v1 192.168.4.11:5000/tomcat-app:v1
# docker tag docker.io/mysql:5.7 192.168.4.11:5000/mysql:5.7
# docker push 192.168.4.11:5000/tomcat-app:v1
# docker push 192.168.4.11:5000/mysql:5.7
部署mysql 服务
1、创建yaml文件
# vim mysql-dep.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: mysql #Deployment的名称，全局唯一
spec:
replicas: 1 #Pod副本的数量
selector:
matchLabels: #定义RS的标签
app: mysql #符合目标的Pod拥有此标签
template: #根据此模版创建Pod的副本（实例）
metadata:
labels:
app: mysql #Pod拥有的标签，对应Deployment的selector
spec:
containers: #Pod内，定义容器
- name: mysql #容器名称
image: 192.168.0.136:5000/mysql:5.7
ports:
- containerPort: 3306 #容器应用监听的端口
env: #环境变量
- name: MYSQL_ROOT_PASSWORD #设置root初始密码
value: "123456" # vim mysql-rc.yaml
apiVersion: v1
kind: ReplicationController #副本控制器RC
metadata:
name: mysql #RC的名称，全局唯一
spec:
replicas: 1 #Pod副本的数量
selector:
app: mysql #符合目标的Pod拥有此标签
template: #根据此模版创建Pod的副本（实例）
metadata:
labels:
app: mysql #Pod副本拥有的标签，对应RC的selector
spec:
containers: #Pod内，定义容器
- name: mysql #容器名称
image: 192.168.0.136:5000/mysql:5.7
ports:
- containerPort: 3306 #容器应用监听的端口
env: #环境变量
- name: MYSQL_ROOT_PASSWORD #设置root初始密码
value: "123456" 2、创建mysql-deployment
# kubectl create -f mysql-dep.yaml 3、创建mysql serveice文件
# vim mysql-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: mysql
spec:
type: NodePort
ports:
- port: 3306
nodePort: 30001
selector:
app: mysql 4、创建MySQL svc
# kubectl create -f mysql-svc.yaml
部署web服务
1、创建yaml文件
# vim tomcat-app-dep.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: tomcat-app
spec:
replicas: 3
template:
metadata:
labels:
app: tomcat-app
spec:
containers:
- name: tomcat-app
image: 192.168.0.136:5000/tomcat-app:v1
ports:
- containerPort: 8080
env:
- name: MYSQL_SERVICE_HOST
value: 'mysql' #这是一个坑，最好写mysql服务的Cluster IP
- name: MYSQL_SERVICE_PORT
value: '3306' # vim tomcat-app-rc.yaml
apiVersion: v1
kind: ReplicationController
metadata:
name: myweb
spec:
replicas: 1
selector:
app: myweb
template:
metadata:
labels:
app: myweb
spec:
containers:
- name: myweb
image: kubeguide/tomcat-app:v2
ports:
- containerPort: 8080
env:
- name: MYSQL_SERVICE_HOST
value: 'mysql' mysql为域名要解析
- name: MYSQL_SERVICE_PORT
value: '3306' 2、创建tomcat-app-deployment
# kubectl create -f tomcat-app-dep.yaml 3、创建tomcat-app service文件
# vim tomcat-app-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: tomcat-app
spec:
type: NodePort
ports:
- port: 8080
name: myweb-svc
nodePort: 30002
selector:
app: tomcat-app 4、创建tomcat-app service
# kubectl create -f tomcat-app-svc.yaml
测试
1、查看所有svc、pod的状态及端口
# kubectl get all -o wide 2、测试pod
# curl 172.16.30.2:8080 -I
# telnet 172.16.30.3 3306 3、测试svc
# curl 10.254.102.27:8080 -I
# telnet 10.254.217.119 3306 4、测试node
# curl 192.168.4.12:30008 -I
http://192.168.4.11:30008
http://192.168.4.11:30008/demo
插入一条数据 5、主要
# cat tomcat-app-dep.yaml
env:
- name: MYSQL_SERVICE_HOST
value: '10.254.217.119'
tomcat-app-dep.yaml 文件mysql是域名要解析，没有dns，只能写cluster IP
MySQL没有持久化，pod的数据是临时的，如果删除pod或者重启deployment，数据会丢失
2、持久化存储
数据持久化方式：
1、Volume
Docker数据持久化方案 2、k8s支持的数据卷类型
1）本地数据卷
EmptyDir：Pod配置了EmpyDir数据卷，只要Pod 存在，数据卷就会存在，Pod被删除，数据卷也会被删除，并且永久丢失，适合实现Pod中容器的文件共享。
HostPath：数据卷将容器宿主机上的文件系统挂载到Pod中。 2）网络共享数据卷
网络数据卷包含以下几种：NFS、iSCISI、GlusterFS、RBD（Ceph Block Device）、Flocker、AWS Elastic Block Store、GCE Persistent Disk 3)PV和PVC
PV(Persistent Volume)：由管理员添加的的一个存储的描述，是一个全局资源，包含存储的类型，存储的大小和访问模式等。它的生命周期独立，例如当使用它的Pod销毁时对PV没有影响。
PVC(Persistent Volume Claim)：是Namespace里的资源，描述对PV的一个请求。请求信息包含存储大小，访问模式等。 4）信息数据卷
信息数据卷：主要用来给容器传递配置信息，如Secret（处理敏感配置信息，密码、Token等）、Downward API（通过环境变量的方式告诉容器Pod的信息）、Git Repo（将Git仓库下载到Pod中），都是将Pod的信息以文件形式保存，然后以数据卷方式挂载到容器中，容器通过读取文件获取相应的信息
通过NFS实现持久化存储
配置NFS存储服务
1、环境
k8s-master nfs-server
k8s-node nfs-client 2、配置nfs
master：
# yum install -y nfs-utils 安装
# mkdir -p /data/tomcat 创建共享目录
# cat /etc/exports 创建共享配置文件
/data 192.168.4.0/24(rw,no_root_squash,no_all_squash,sync)
# systemctl start nfs 启动服务
node：
# yum install -y nfs-utils 安装客户端
创建PV-持久卷
1、创建pv文件
# cat pv_nfs.yaml
apiVersion: v1
kind: PersistentVolume #资源类型
metadata:
name: mysql-tomcat
labels:
type: mysql-tomcat-nfs
spec:
capacity:
storage: 5Gi
accessModes:
- ReadWriteMany #访问模式，多个客户端读写
persistentVolumeReclaimPolicy: Recycle #回收策略-可以回收
nfs:
path: "/data/tomcat"
server: 192.168.4.11 #k8s-nfs matser
readOnly: false #只读 2、创建pv
# kubectl create -f pv_nfs.yaml 3、查看PV信息
# kubectl describe pv
创建PVC-持久卷
1、创建PVC文件
# cat pvc_nfs.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mysql-tomcat-pvc
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 1Gi 2、创建pvc
# kubectl create -f pv_nfs.yaml
3、查看pvc
# kubectl get pvc
MySQL挂载共享存储
1、重新修改mysql的yaml文件
# cat mysql-dep.yaml
apiVersion: extensions/v1beta1
kind: Deployment #控制器Deployment
metadata:
name: mysql #Deployment的名称，全局唯一
spec:
replicas: 1 #Pod副本的数量
template: #根据此模版创建Pod的副本（实例）
metadata:
labels:
app: mysql #Pod副本拥有的标签，对应Deployment的selector
spec:
containers: #Pod内，定义容器
- name: mysql #容器名称
image: 192.168.0.136:5000/mysql:5.7
ports:
- containerPort: 3306 #容器监听的端口 volumeMounts:
- name: mysql-data-pvc #容器内挂载点名称
mountPath: /var/lib/mysql #容器内挂载目录
env: #注入容器内的环境变量
- name: MYSQL_ROOT_PASSWORD #这里设置root初始密码
value: "123456"
volumes:
- name: mysql-data-pvc #数据卷名称，要和容器内挂载点名称一致
persistentVolumeClaim:
claimName: mysql-tomcat-pvc #pvc名称 2、更新yaml文件
# kubectl apply -f mysql-dep.yaml 3、检查
# ls /data/tomcat/
# df -h
http://192.168.4.12:30008/demo 插入一条数据
进入数据库，查看插入的数据
删除pod，自动新建pod，再次查看数据
# kubectl delete pod mysql-1215028969-3d366
http://192.168.4.12:30008/demo 查看数据是否存在
不创建pv和pvc，使用nfs实现持久化存储
1、创建mysql的Deployment定义文件
# vim mysql-dep.yaml
apiVersion: extensions/v1beta1 #apiserver的版本
kind: Deployment #副本控制器deployment，管理pod和RS
metadata:
name: mysql #deployment的名称，全局唯一
spec:
replicas: 1 #Pod副本期待数量
selector:
matchLabels: #定义RS的标签
app: mysql #符合目标的Pod拥有此标签
strategy: #定义升级的策略
type: RollingUpdate #滚动升级，逐步替换的策略
template: #根据此模板创建Pod的副本（实例）
metadata:
labels:
app: mysql #Pod副本的标签，对应RS的Selector
spec:
containers: #Pod里容器的定义部分
- name: mysql #容器的名称
image: mysql:5.7 #容器对应的docker镜像
volumeMounts: #容器内挂载点的定义部分
- name: mysql-data #容器内挂载点名称
mountPath: /var/lib/mysql #容器内挂载路径，mysql的数据目录
ports:
- containerPort: 3306 #容器暴露的端口号
env: #写入到容器内的环境容量
- name: MYSQL_ROOT_PASSWORD #定义了一个mysql的root密码的变量
value: "123456"
volumes: #本地需要挂载到容器里的数据卷定义部分
- name: mysql-data #数据卷名称，需要与容器内挂载点名称一致
nfs:
server: 192.168.4.11
path: "/data/tomcat"
2、创建deployment、RS、Pod和容器
# kubectl create -f mysql-dep.yaml 3、创建mysql的service定义文件
# vim mysql-svc.yaml
apiVersion: v1
kind: Service #表示Kubernetes Service
metadata:
name: mysql #Service的名称
spec:
ports:
- port: 3306 #Service提供服务的端口号
selector:
app: mysql #Service对应的Pod的标签 4、创建Service
# kubectl create -f mysql-svc.yaml 5、测试
http://192.168.4.12:30008/demo 插入一条数据
进入数据库，查看插入的数据
删除pod，自动新建pod，再次查看数据
# kubectl delete pod mysql-761066058-bgh3r
http://192.168.4.12:30008/demo 查看数据是否存在
emptyDir类型
删除容器后数据会保存，但是删除pod后数据丢失
# cat mysql-rc.yml
apiVersion: v1
kind: ReplicationController
metadata:
name: mysql
namespace: tomcat
spec:
replicas: 1
selector:
app: mysql
template:
metadata:
labels:
app: mysql
spec:
volumes: *
- name: mysql *
emptyDir: {} *
containers:
- name: mysql
image: 192.168.4.11:5000/mysql:5.7
volumeMounts: *
- name: mysql *
mountPath: /var/lib/mysql *
ports:
- containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: '123456'
HostPath类型
删除容器与删除pod，数据都会保存
# cat mysql-rc.yml
apiVersion: v1
kind: ReplicationController
metadata:
name: mysql
namespace: tomcat
spec:
replicas: 1
selector:
app: mysql
template:
metadata:
labels:
app: mysql
spec:
nodeName: 10.0.0.13
volumes:
- name: mysql
hostPath: *
path: /data/mysql *
containers:
- name: mysql
image: 10.0.0.11:5000/mysql:5.7
volumeMounts: *
- name: mysql *
mountPath: /var/lib/mysql *
ports:
- containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: '123456'
五、HPA水平自动伸缩
HPA简介
Horizontal Pod Autoscaling，简称HPA，是Kubernetes中实现POD水平自动伸缩的功能。
自动扩展主要分为两种:
水平扩展(scale out)，针对于实例数目的增减
垂直扩展(scal up)，即单个实例可以使用的资源的增减, 比如增加cpu和增大内存
自动伸缩
1、创建测试yaml文件
# vim k8s_deploy.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx-deployment
spec:
replicas: 3
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
resources: # 资源限制
limits: # 最大资源是多少
cpu: 100m
requests: # 最小需要多少资源
cpu: 100m 2、命令行创建一个svc资源
# kubectl expose deployment nginx-deployment --port=80 --target-port=80 --type=NodePort 3、命令行方式创建弹性伸缩规则
# kubectl autoscale deployment nginx-deployment --max=10 --min=2 --cpu-percent=10
# cpu生产建议设为60。能有一个40的缓冲 4、查看dpa描述
# kubectl describe hpa
Name: nginx-deployment
Namespace: default
Labels: <none>
Annotations: <none>
CreationTimestamp: Tue, 24 Dec 2019 05:06:45 +0800
Reference: Deployment/nginx-deployment
Target CPU utilization: 10%
Current CPU utilization: 0%
Min replicas: 2
Max replicas: 10 5、修改副本数为1
# kubectl edit deployment nginx-deployment
# kubectl get all 查看pod数量 6、开始压测
# ab -n 400000 -c 50 http://192.168.4.11:30008
调用原理
1、创建pod和service
# kubectl run php-apache --image=gcr.io/google_containers/hpa-example --requests=cpu=200m --expose --port=80 2、创建autoscaler
# kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10 3、增加负载
# kubectl run -i --tty load-generator --image=busybox /bin/sh
$ while true; do wget -q -O- http://php-apache.default.svc.cluster.local; done 4、查看负载及pod
# kubectl get hpa
# kubectl get deployment
pod增加到7个
5、删除创建的负载
pod数量自动降回1个
# kubectl get hpa
# kubectl get deployment
小结
1、首先最底层的资源永远都是pod
2、比pod高级一点的资源叫rc副本控制器
3、在pod上面有一个高级的rs
4、那谁来管理rs呢？是deployment
5、HPA自动管理deployment，deployment设置为1，HPA最低设置为3，deployment这就会被自动设计为3个
HPA-yaml文件
# vim nginx-hpa.yaml
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
name: nginx # 名称
namespace: default #k8s命名空间
spec:
maxReplicas: 10 # 最大副本数
minReplicas: 3 # 最小副本数
scaleTargetRef:
apiVersion: apps/v1beta1
kind: Deployment
name: nginx # 监控名为nginx的Deployment
targetCPUUtilizationPercentage: 80 # cpu 阈值
六、其他项目
1、安装部署Dashboard
1、 获取kubernetes-dashboard.yaml文件
去官网，github上下载对应版本的源码包文件。
https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.5.md#downloads-for-v152
# wget https://dl.k8s.io/v1.5.2/kubernetes.tar.gz
# cd kubernetes/cluster/addons/dashboard/
# cp dashboard-controller.yaml /root/dashboard-dep.yaml
# cp dashboard-service.yaml /root/dashboard-svc.yaml
2、修改yaml文件
# vim dashboard-dep.yaml
image: gcr.io/google_containers/kubernetes-dashboard-amd64:v1.5.0
arg:
- --apiserver-host=http://192.168.4.11:8080 3、启动
# kubectl create -f dashboard-dep.yaml
# kubectl create -f dashboard-svc.yaml 4、查看
# kubectl get -n kube-system all
http://192.168.4.11:8080/ui
dashboard-dep.yaml文件内容
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
# Keep the name in sync with image version and
# gce/coreos/kube-manifests/addons/dashboard counterparts
name: kubernetes-dashboard-latest
namespace: kube-system
spec:
replicas: 1
template:
metadata:
labels:
k8s-app: kubernetes-dashboard
version: latest
kubernetes.io/cluster-service: "true"
spec:
nodeName: k8s-node2
containers:
- name: kubernetes-dashboard
image: index.tenxcloud.com/google_containers/kubernetes-dashboard-amd64:v1.4.1
imagePullPolicy: IfNotPresent
resources:
# keep request = limit to keep this container in guaranteed class
limits:
cpu: 100m
memory: 50Mi
requests:
cpu: 100m
memory: 50Mi
ports:
- containerPort: 9090
args:
- --apiserver-host=http://192.168.4.11:8080
livenessProbe:
httpGet:
path: /
port: 9090
initialDelaySeconds: 30
timeoutSeconds: 30
dashboard-svc.yaml文件内容
apiVersion: v1
kind: Service
metadata:
name: kubernetes-dashboard
namespace: kube-system
labels:
k8s-app: kubernetes-dashboard
kubernetes.io/cluster-service: "true"
spec:
selector:
k8s-app: kubernetes-dashboard
ports:
- port: 80
targetPort: 9090
没用nodeport，不做端口映射
Pod控制器
Kubernetes中内建了很多controller（控制器），分为有状态应用和无状态应用
Pod控制器有多种类型：
Deployment：工作在ReplicaSet之上，用于管理无状态应用，目前来说最好的控制器。支持滚动更新和回滚功能，还提供声明式配置。
DaemonSet：确保集群中的每一个节点只运行特定的pod副本，通常用于实现系统级后台任务。比如ELK，要求：服务是无状态的；服务必须是守护进程
Job：只要完成就立即退出，不需要重启或重建。
Cronjob：周期性任务控制，不需要持续后台运行，
StatefulSet：管理有状态应用，如mysql，redis等。
ReplicaSet: 代用户创建指定数量的pod副本数量，确保pod副本数量符合预期状态，并且支持滚动式自动扩容和缩容功能。
DaemonSet：一个node节点只能启动一个，监控pod、日志收集pod
pet sets： 有状态，适合数据库之类的
namespace
1、介绍
Namespace（命名空间）：在很多情况下用于实现多租户的资源隔离。
同一个namespace下面不允许出现两个service叫mysql
生产环境中把不同的应用放到不同的namespace中。 2、namespace管理命令
创建namespace
# kubectl create namespace nginx 查看namespace
# kubectl get namespace 删除namespace
# kubectl delete namespace qiangge
注：特别危险！会删除namespace下所有的k8s资源 3、yaml文件
# vim nginx-rc.yaml
apiVersion: v1
kind: ReplicationController
metadata:
name: myweb
namespace: nginx-nm
spec:
replicas: 2
selector:
app: myweb
template:
metadata:
labels:
app: myweb
spec:
containers:
- name: myweb
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80 # vim nginx-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: myweb
namespace: nginx-nm
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 80
selector:
app: myweb
通过apiservice反向代理访问service
访问k8s中应用,在svc中配置
第一种：NodePort类型
type: NodePort
ports:
- port: 80
targetPort: 80
nodePort: 30008 第二种：ClusterIP类型
type: ClusterIP
ports:
- port: 80
targetPort: 80 http://192.168.4.11:8080/api/v1/proxy/namespaces/命令空间/services/service的名字/
2、部署dns组件
dns服务的作用：将svc的名字解析成VIP地址
1、获取yaml文件
去官网，github上下载对应版本的源码包文件。
https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.5.md#downloads-for-v152
# wget https://dl.k8s.io/v1.5.2/kubernetes.tar.gz
# cd kubernetes/cluster/gce/coreos/kube-manifests/addons/dns/
# cp skydns-rc.yamll /root/skydns-rc.yaml
# cp skydns-svc.yaml /root/skydns-svc.yaml 2、修改yaml文件
image: myhub.fdccloud.com/library/kubedns-amd64:1.9
- --domain=cluster.local.
- --kube-master-url=http://192.168.4.11:8080
image: myhub.fdccloud.com/library/kube-dnsmasq-amd64:1.4
image: myhub.fdccloud.com/library/dnsmasq-metrics-amd64:1.0
image: myhub.fdccloud.com/library/exechealthz-amd64:1.2
- --cmd=nslookup kubernetes.default.svc.cluster.local 127.0.0.1 >/dev/null
- --cmd=nslookup kubernetes.default.svc.cluster.local 127.0.0.1:10053 >/dev/null 3、启动dns
# kubectl create -f skydns-rc.yaml
# kubectl create -f skydns-svc.yaml 4、修改node节点kubelet配置文件并重启服务
# cat /etc/kubernetes/kubelet
KUBELET_ARGS="--cluster_dns=10.254.230.254 --cluster_domain=cluster.local"
# systemctl restart kubelet 5、测试
# cat test_dns_pod.yaml
apiVersion: v1
kind: Pod
metadata:
labels:
name: busybox
role: master
name: busybox2
spec:
containers:
- name: busybox
image: docker.io/busybox:latest
imagePullPolicy: IfNotPresent
command:
- sleep
- "3600" # kubectl exec -it busybox sh
# cat /etc/resolv.conf
测试
# nslookup kubernetes
# nslookup kubernetes.default.cluster.local
# nslookup kubernetes.default.svc.cluster.local
skydns-rc.yaml的内容
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: kube-dns
namespace: kube-system
labels:
k8s-app: kube-dns
kubernetes.io/cluster-service: "true"
spec:
# replicas: not specified here:
# 1. In order to make Addon Manager do not reconcile this replicas parameter.
# 2. Default is 1.
# 3. Will be tuned in real time if DNS horizontal auto-scaling is turned on.
strategy:
rollingUpdate:
maxSurge: 10%
maxUnavailable: 0
selector:
matchLabels:
k8s-app: kube-dns
template:
metadata:
labels:
k8s-app: kube-dns
annotations:
scheduler.alpha.kubernetes.io/critical-pod: ''
scheduler.alpha.kubernetes.io/tolerations: '[{"key":"CriticalAddonsOnly", "operator":"Exists"}]'
spec:
containers:
- name: kubedns
image: myhub.fdccloud.com/library/kubedns-amd64:1.9
resources:
# TODO: Set memory limits when we've profiled the container for large
# clusters, then set request = limit to keep this container in
# guaranteed class. Currently, this container falls into the
# "burstable" category so the kubelet doesn't backoff from restarting it.
limits:
memory: 200Mi
requests:
cpu: 100m
memory: 100Mi
livenessProbe:
httpGet:
path: /healthz-kubedns
port: 8080
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
successThreshold: 1
failureThreshold: 5
readinessProbe:
httpGet:
path: /readiness
port: 8081
scheme: HTTP
# we poll on pod startup for the Kubernetes master service and
# only setup the /readiness HTTP server once that's available.
initialDelaySeconds: 3
timeoutSeconds: 5
args:
# command = "/kube-dns"
- --domain=cluster.local.
- --dns-port=10053
- --config-map=kube-dns
- --kube-master-url=http://192.168.4.11:8080
env:
- name: PROMETHEUS_PORT
value: "10055"
ports:
- containerPort: 10053
name: dns-local
protocol: UDP
- containerPort: 10053
name: dns-tcp-local
protocol: TCP
- containerPort: 10055
name: metrics
protocol: TCP
- name: dnsmasq
image: myhub.fdccloud.com/library/kube-dnsmasq-amd64:1.4
livenessProbe:
httpGet:
path: /healthz-dnsmasq
port: 8080
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
successThreshold: 1
failureThreshold: 5
args:
- --cache-size=1000
- --no-resolv
- --server=127.0.0.1#10053
- --log-facility=-
ports:
- containerPort: 53
name: dns
protocol: UDP
- containerPort: 53
name: dns-tcp
protocol: TCP
- name: dnsmasq-metrics
image: myhub.fdccloud.com/library/dnsmasq-metrics-amd64:1.0
livenessProbe:
httpGet:
path: /metrics
port: 10054
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
successThreshold: 1
failureThreshold: 5
args:
- --v=2
- --logtostderr
ports:
- containerPort: 10054
name: metrics
protocol: TCP
resources:
requests:
memory: 10Mi
- name: healthz
image: myhub.fdccloud.com/library/exechealthz-amd64:1.2
resources:
limits:
memory: 50Mi
requests:
cpu: 10m
# Note that this container shouldn't really need 50Mi of memory. The
# limits are set higher than expected pending investigation on #29688.
# The extra memory was stolen from the kubedns container to keep the
# net memory requested by the pod constant.
memory: 50Mi
args:
- --cmd=nslookup kubernetes.default.svc.cluster.local 127.0.0.1 >/dev/null
- --url=/healthz-dnsmasq
- --cmd=nslookup kubernetes.default.svc.cluster.local 127.0.0.1:10053 >/dev/null
- --url=/healthz-kubedns
- --port=8080
- --quiet
ports:
- containerPort: 8080
protocol: TCP
dnsPolicy: Default # Don't use cluster DNS.
skydns-svc.yaml 的内容
apiVersion: v1
kind: Service
metadata:
name: kube-dns
namespace: kube-system
labels:
k8s-app: kube-dns
kubernetes.io/cluster-service: "true"
kubernetes.io/name: "KubeDNS"
spec:
selector:
k8s-app: kube-dns
clusterIP: 10.254.230.254
ports:
- name: dns
port: 53
protocol: UDP
- name: dns-tcp
port: 53
protocol: TCP
3、部署heapster监控
介绍
Heapster是kubernetes集群监控工具。在kubernetes中，cAdvisor被集成到kubelet中。通过netstat可以查看到kubelet新开了一个4194的端口，这就是cAdvisor监听的端口，现在我们然后可以通过http://<node-ip>:4194的方式访问到cAdvisor。Heapster就是通过每个node上的kubelet，也就是实际的cAdvisor上收集数据并汇总，保存到后端存储中。
Heapster支持多种后端存储，包括influxDB，Elasticsearch，Kafka等，我们使用influxDB作为后端存储来展示heapster的相关配置。需要说明的是，heapster依赖kubernetes dns配置
部署
1、 获取yaml文件
去官网，github上下载对应版本的源码包文件。
https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.5.md#downloads-for-v152
# wget https://dl.k8s.io/v1.5.2/kubernetes.tar.gz
# cd kubernetes/cluster/addons/cluster-monitoring/influxdb/
# mkdir -p /data/yaml
# cp *.yaml /data/yaml 2、修改yaml文件
查看image地址，添加本地查找
# grep 'image' heapster-controller.yaml
- image: gcr.io/google_containers/heapster:v1.2.0
imagePullPolicy: IfNotPresent #本地找镜像
- image: gcr.io/google_containers/heapster:v1.2.0
imagePullPolicy: IfNotPresent
- image: gcr.io/google_containers/addon-resizer:1.6
imagePullPolicy: IfNotPresent
- image: gcr.io/google_containers/addon-resizer:1.6
imagePullPolicy: IfNotPresent
# grep 'image' influxdb-grafana-controller.yaml
- image: gcr.io/google_containers/heapster_influxdb:v0.7
imagePullPolicy: IfNotPresent
- image: gcr.io/google_containers/heapster_grafana:v3.1.1
imagePullPolicy: IfNotPresent
3、下载镜像文件并修改
# docker search heapster:v1.2.0
# docker pull heapster:v1.2.0
# docker tag heapster:v1.2.0 gcr.io/google_containers/heapster:v1.2.0 4、启动
# kubectl create -f /data/yaml 批量创建 5、报错处理
修改heapster-controller.yaml
command:
- /heapster
- --source=kubernetes:http://192.168.4.11:8080?inClusterConfig=false 数据源在从哪里，apiserver拿数据
- --sink=influxdb:http://monitoring-influxdb:8086 数据存储到哪里，influxdb存数据
heapster依赖kubernetes dns
heapster-controller.yaml 文件内容
apiVersion: v1
kind: ReplicationController
metadata:
labels:
k8s-app: heapster
name: heapster
version: v6
name: heapster
namespace: kube-system
spec:
replicas: 1
selector:
k8s-app: heapster
version: v6
template:
metadata:
labels:
k8s-app: heapster
version: v6
spec:
nodeSelector:
kubernetes.io/hostname: k8s-master
containers:
- name: heapster
image: kubernetes/heapster:canary
imagePullPolicy: IfNotPresent
command:
- /heapster
- --source=kubernetes:http://192.168.4.11:8080?inClusterConfig=false
- --sink=influxdb:http://monitoring-influxdb:8086
influxdb-grafana-controller.yaml 文件内容
apiVersion: v1
kind: ReplicationController
metadata:
labels:
name: influxGrafana
name: influxdb-grafana
namespace: kube-system
spec:
replicas: 1
selector:
name: influxGrafana
template:
metadata:
labels:
name: influxGrafana
spec:
containers:
- name: influxdb
image: kubernetes/heapster_influxdb:v0.5
imagePullPolicy: IfNotPresent
volumeMounts:
- mountPath: /data
name: influxdb-storage
- name: grafana
imagePullPolicy: IfNotPresent
image: kubernetes/heapster_grafana:v2.6.0
env:
- name: INFLUXDB_SERVICE_URL
value: http://monitoring-influxdb:8086- name: GF_AUTH_BASIC_ENABLED
value: "false"
- name: GF_AUTH_ANONYMOUS_ENABLED
value: "true"
- name: GF_AUTH_ANONYMOUS_ORG_ROLE
value: Admin
- name: GF_SERVER_ROOT_URL
value: /api/v1/proxy/namespaces/kube-system/services/monitoring-grafana/
volumeMounts:
- mountPath: /var
name: grafana-storage
nodeSelector:
kubernetes.io/hostname: k8s-master
volumes:
- name: influxdb-storage
emptyDir: {}
- name: grafana-storage
emptyDir: {}
原理
heapster读取kubelet中cadvisor（http://192.168.4.12:4194/containers/）的数据，存到influxdb中，再由grafana读取出图，最后由dashboard呈现
监控数据获得，是从cadvisor获得的,现在cadvisor集成到了kubelete中，访问cadvisor,可以修改kubelet配置文件，添加--cadvisor参数 # cat /etc/kubernetes/kubelet
KUBELET_ARGS="--cluster_dns=10.254.230.254 --cluster_domain=cluster.local --cadvisor-port=8080"
重启
systemctl restart kubelet.service
学习k8s（一）的更多相关文章
- 如何掌握 Kubernetes ？系统学习 k8s 的大纲一份
深度剖析 Kubernetes 深度剖析 k8s 如何学习 Kubernetes ?如何入门 Kubernetes? 为了帮帮初学者,2018 年 InfoQ 旗下(就是你知道的那个 InfoQ 哇) ...
- 学习k8s的经验
最近在学k8s,总结一下安装k8s的坑. 1.晚上关于k8s的学习资料很多,多不如精,这个博客很好,https://blog.csdn.net/sinat_35930259/article/categ ...
- 通过Kuberneters Goat学习K8S安全（上）
实验环境:https://katacoda.com/madhuakula/scenarios/kubernetes-goat 0x1.敏感信息泄露利用 第一关是代码泄露利用,打开网站后显示: 告诉我们 ...
- 学习k8s（四）
1.K8S核心组件 1.Master节点: etcd: 分布式键值对数据库,保存集群状态 api-server: 接受并响应用户的请求 controller: 控制器管理,控制容器的副本数,故障检测 ...
- 学习k8s（三）
一.Kubernetes核心概念 1.Kubernetes介绍 Kubernetes(k8s)是自动化容器操作的开源平台,这些操作包括部署,调度和节点集群间扩展.如果你曾经用过Docker容器技术部署 ...
- 学习k8s（二）
kubernetes-国内拉取gcr.io\quay.io镜像方法 方法1: https://hub.docker.com/r/ibmcom/ 例如: gcr.io/google_containers ...
- .NET Core on K8S快速入门课程学习笔记
课程链接:http://video.jessetalk.cn/course/explore 良心课程,大家一起来学习哈! 目录 01-介绍K8s是什么 02-为什么要学习k8s 03-如何学习k8s ...
- mac上k8s学习踩坑
本文学习k8s参考内容:http://docs.kubernetes.org.cn/126.html,学习过程中遇到一些坑,记录如下: -------------------------------- ...
- k8s学习
k8s简介 在学习k8s之前,相信大家和我一样,肯定都学习和使用过docker容器,并且对容器技术有了一个基本的认识.引用张磊老师的总结:其实一个"容器",实际上是一个由Linux ...
随机推荐
- windev的字符集选择设置及元素命名方法建议
windev支持多语言,且支持整站翻译,同时支持最终用户的多语言选择,可以说多语言功能已经非常的全面和强大. windev原生支持英语.法语和葡萄牙语,在使用如中文等非拉丁字母语言时,需要在多个地方进 ...
- kibana操作记录
GET _search { "query": { "match_all": {} } } GET _cat/nodes GET _cat/health GET ...
- Java课程设计---浏览学生（实现根据姓名查询）
1.修改窗口 2.在StudentDao中增加根据姓名查找的方法 public List<Student> getStudent(String name)throws SQLExcepti ...
- 初识html及网络爬虫概念
网络爬虫 HTML超文本标记语言 HTTP协议 简单的网络请求 python模块模拟浏览器发送请求 爬虫小案例 爬虫简介 我们一般情况 都是通过浏览器正常访问服务端获取资源浏览器展示给用户看 爬虫 模 ...
- 前端vue下载文件时blob返回流中怎么获取文件名
我很久之前写了一篇前端vue利用blob对象下载文件,有些人私信我,如果后端返回流失败,给出的json对象该怎么获得?前端获取的流怎么能获取原文件名?其实在那篇文章之后,我就已经针对这两个问题进行了优 ...
- 零基础，三个月内，找到??? java后端开发工作
一.分析你的问题 出于尊重,先分析一下你的原问题吧,从您的问题,我提取到关键信息:"零基础"."三个月内"."找到工作",最后一个关键词&q ...
- 面试官：Redis中列表的内部实现方式是什么？
在面试间里等候时,感觉这可真暖和呀,我那冰冷的出租屋还得盖两层被子才能睡着.正要把外套脱下来,我突然听到了门外的脚步声,随即门被打开,一位眉毛弯弯嘴唇红红的小姐姐走了进来,甜甜的香水味立刻钻进了我的鼻 ...
- WebGL 与 WebGPU比对[6] - 纹理
目录 1. WebGL 中的纹理 1.1. 创建二维纹理与设置采样参数 1.2. 纹理数据写入与拷贝 1.3. 着色器中的纹理 1.4. 纹理对象 vs 渲染缓冲对象 1.5. 立方体六面纹理 1.6 ...
- 题目要求：传入数组 内容为[['lisi','男','27'],['wangwu','男',18],['zhaoliu','男','30']],将此二维数组转化为一维数组，创建自定义函数完成
//自定义函数 function getOne($arr){ $str = ''; //定义空的字符串,用来接收值 foreach ($arr as $key=>$value){ //循环遍历数 ...
- OpenTracing 简介
自从 Google Dapper 的论文发布之后,各大互联网公司和开源社区开发的分布式链路追踪产品百花齐放,同时也给使用者带来了一个问题,各个分布式链路追踪产品的 API 并不兼容,如果用户在各个产品 ...