云计算-k8s-docker

最新推荐文章于 2024-07-25 17:00:55 发布

JulySeven_ju

最新推荐文章于 2024-07-25 17:00:55 发布

阅读量926

点赞数

本文链接：https://blog.csdn.net/qq_50119948/article/details/116591851

版权

目录
一、第一部分：云计算 IV

什么是云计算？ IV
云计算的服务类型 V
为什么要用云计算 V
云计算的基础KVM虚拟化 VI
kvm管理平台 XVII
二、第二部分 docker容器 XIX
什么是容器 XIX
容器和虚拟机的区别 XIX
docker-ce的安装 XX
docker主要内容 XX
docker镜像常用命令 XXI
docker容器的常用命令 XXII
docker端口映射 XXV
docker数据卷 XXV
手动制作docker镜像 XXVI
自动制作docker镜像 XXIX
docker镜像的分层(复用,节省空间) XXXII
dockerfile的优化 XXXII
容器间的互联 XXXIII
单机版的容器编排 XXXIV
私有仓库docker-registry XXXVI
企业级私有仓库harbor(docker-compose) XXXVII
docker基础网络 XLI
跨宿主机容器间的通讯之macvlan XLII
跨宿主机容器间的通讯之overlay XLIII
docker容器的监控 XLIII
三、第三部分：k8s LVI
k8s集群的安装 LVI
什么是k8s,k8s有什么功能? 5
k8s常用的资源 9
k8s的常用资源(二进制) 23
k8s常用服务（二进制） 34
k8s的网络访问（二进制） 48
K8s的附加组件 63
k8s弹性伸缩 70
8.1 使用heapster实现弹性伸缩 70
使用kubeadm初始化k8s集群 73
9.1 环境要求: 74
9.2 安装指定版本docker 74
9.3 安装kubeadm 74
9.4 使用kubeadm初始化k8s集群 75
9.5 给k8s集群加入node节点: 75
9.6 为k8s集群配置网络插件 75
9.7 为k8s集群配置dashboard服务 76
9.8 使用metric-server实现弹性伸缩 77
持久化存储 85
10.1 emptyDir: 85
10.2 HostPath:[不能跨宿主机做数据共享] 85
10.3 Nfs(网络文件共享) 86
10.4 pv和pvc: 86
10.5 分布式存储ceph 88
使用jenkins实现k8s持续更新 95
11.1 安装gitlab并上传代码 96
11.2 安装jenkins,并自动构建docker镜像 97
k8s高可用 101
基于nfs实现动态存储（二进制） 104
Helm k8s包管理工具 107
14.1 helm介绍: [部署应用变得更简单、高效] 107
14.2 helm安装 107
14.3 helm初始化 108
14.4 自定义helm 110
statsfulset资源 116
job资源和cron.job资源 117
kubesphere管理平台 118
阿里云k8s 120
四、第四部分：阿里云 122
云计算回顾 122
阿里云的发展历程： 123
阿里云的控制台 123
ECS资源(弹性计算)-快照-镜像-云硬盘 123

一、第一部分：云计算

什么是云计算？
云计算是一种按量付费的模式！云计算的底层是通过虚拟化技术来实现的！
云计算的服务类型
IAAS 基础设施即服务(infrastructure as an service) 虚拟机 ecs云主机
PAAS 平台即服务(platform as an service ) php，java 容器
SAAS 软件即服务(software as an service ) 企业邮箱服务 cdn服务 rds数据库
为什么要用云计算
小公司：10台 20w+ idc 5w + 100M 10W， 10台云主机，前期投入小，扩展灵活，风险小
大公司：闲置服务器计算资源，虚拟机，出租（超卖）
64G 服务器 64台1G 320台1G 64台大公司自己的业务 264台租出去
国企，银行
公有云: 谁都可以租
私有云: 只有公司内部使用
混合云: 有自己的私有云 + 租的公有云
云计算的基础KVM虚拟化
宿主机：内存4G+ 纯净的系统CentOS-7（关闭selinux，firewalld和NetworkManager）
4.1 什么是虚拟化？
虚拟化，通过模拟计算机的硬件，来实现在同一台计算机上同时运行多个不同的操作系统的技术。
4.2 linux虚拟化软件的差别
linux虚拟化软件： qemu 软件纯模拟全虚拟化软件，特别慢！兼容性好！ xen(半) 性能特别好，需要使用专门修改之后的内核，兼容性差！ redhat 5.5 xen kvm KVM（linux）全虚拟机，它有硬件支持cpu，内置在linux内核模块，而且不需要使用专门的内核 centos6 kvm 性能较好，兼容较好
vmware workstations: 图形界面
virtual box: 图形界面 Oracle
4.3 安装kvm虚拟化管理工具
主机名 ip地址内存虚拟机
kvm01 10.0.0.11 4G(后期调整到2G) cpu开启vt虚拟化
kvm02 10.0.0.12 2G cpu开启vt虚拟化

yum install libvirt virt-install qemu-kvm -y
KVM：Kernel-based Virtual Machine
libvirt 作用：虚拟机的管理软件 libvirt: kvm,xen,qemu,lxc…
virt virt-install virt-clone 作用：虚拟机的安装工具和克隆工具 qemu-kvm qemu-img (qcow2,raw)作用：管理虚拟机的虚拟磁盘
环境要求：
centos 7.4 7.6 7.8（不要使用7.5）
vmware 宿主机 kvm虚拟机
内存4G，cpu开启虚拟化

IP：10.0.0.11
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
安装软件包
yum install libvirt virt-install qemu-kvm -y
4.4 安装一台kvm虚拟机
VNC-Viewer-6.19.325
微软的远程桌面
vnc:远程的桌面管理工具向日葵微软的远程桌面
systemctl start libvirtd.service systemctl status libvirtd.service
10.0.0.11 宿主机
建议虚拟机内存不要低于1024M，否则安装系统特别慢！
virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name centos7 --memory 1024 --vcpus 1 --disk /opt/centos2.raw,format=raw,size=10 --cdrom /opt/CentOS-7-x86_64-DVD-1708.iso --network network=default --graphics vnc,listen=0.0.0.0 --noautoconsole
vnc：10.0.0.11:5900
–virt-type kvm 虚拟化的类型(qemu) --os-type=linux 系统类型 --os-variant rhel7 系统版本 --name centos7 虚拟机的名字（必须唯一） --memory 1024 虚拟机的内存 --vcpus 1 虚拟cpu的核数 --disk /opt/centos2.raw,format=raw,size=10（必须唯一） --cdrom /opt/CentOS-7-x86_64-DVD-1708.iso --network network=default 使用默认NAT的网络 --graphics vnc,listen=0.0.0.0 --noautoconsole （可有可无）

云主机都没有swap分区

4.5 kvm虚拟机的virsh日常管理和配置
列表list（–all）开机start 关机shutdown(虚拟机有系统) 拔电源关机destroy 重启reboot(虚拟机有系统)
导出配置dumpxml 例子：virsh dumpxml centos7 >centos7-off.xml 删除undefine 推荐：先destroy，在undefine 导入配置define 修改配置edit(自带语法检查) 重命名domrename （低版本不支持）
挂起suspend 恢复resume 查询vnc端口号vncdisplay
kvm虚拟机开机启动 kvm运行业务程序开机启动autostart，前提：systemctl enable libvirtd；取消开机启动autostart --disable
console 控制台登录
centos7的kvm虚拟机：
grubby --update-kernel=ALL --args=“console=ttyS0,115200n8”
reboot
作业1：安装一台centos6的kvm虚拟机，实现console登录安装一台centos6的kvm虚拟机,在安装的过程中.内核参数selinux=0

4.6 kvm虚拟机虚拟磁盘管理和快照管理
raw：俗称裸格式，占用空间比较大，不支持快照功能，不方便传输 ,读写性能较好总50G，用1G，传输50G qcow2： qcow（copy on write）占用空间小，支持快照，性能比raw差一点，方便传输总50G，用1G，传输1G
virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name centos7 --memory 1024 --vcpus 1 --disk /opt/centos2.raw,format=raw,size=10 --cdrom /opt/CentOS-7-x86_64-DVD-1708.iso --network network=default --graphics vnc,listen=0.0.0.0 --noautoconsole
virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name centos7 --memory 1024 --vcpus 1 --disk /opt/oldboy.qcow2,format=qcow2,size=10 --cdrom /data/CentOS-7.2-x86_64-DVD-1511.iso --network network=default --graphics vnc,listen=0.0.0.0 --noautoconsole
4.6.1 磁盘工具的常用命令
qemu-img info，create，resize，convert
查看虚拟磁盘信息 qemu-img info test.qcow2
创建一块qcow2格式的虚拟硬盘： qemu-img create -f qcow2 test.qcow2 2G
调整磁盘磁盘容量 qemu-img resize test.qcow2 +20G
raw转qcow2：qemu-img convert -f raw -O qcow2 oldboy.raw oldboy.qcow2 -c 压缩 virsh edit web01：

virsh destroy web01 virsh start web01
4.6.2 快照管理
创建快照virsh snapshot-create-as centos7 --name install_ok 查看快照virsh snapshot-list centos7
还原快照virsh snapshot-revert centos7 --snapshotname 1516574134 删除快照virsh snapshot-delete centos7 --snapshotname 1516636570
raw不支持做快照，qcow2支持快照，并且快照就保存在qcow2的磁盘文件中
4.7 kvm虚拟机克隆
4.7.1 完整克隆
自动挡：
virt-clone --auto-clone -o web01 -n web02 (完整克隆)
手动挡：
qemu-img convert -f qcow2 -O qcow2 -c web01.qcow2 web03.qcow2
virsh dumpxml web01 >web02.xml
vim web02.xml
#修改虚拟机的名字
#删除虚拟机uuid
#删除mac地址mac add
#修改磁盘路径disk
virsh define web02.xml
virsh start web02
4.7.2 链接克隆
a：生成虚拟机磁盘文件
qemu-img create -f qcow2 -b web03.qcow2 web04.qcow2
b：生成虚拟机的配置文件
virsh dumpxml web01 >web03.xml
vim web03.xml
#修改虚拟机的名字
web03
#删除虚拟机uuid
8e505e25-5175-46ab-a9f6-feaa096daaa4
#删除mac地址

#修改磁盘路径

c：导入虚拟机并进行启动测试
virsh define web03.xml virsh start web03
全自动链接克隆脚本：
[root@kvm01 scripts]# cat link_clone.sh
#!/bin/bash
old_vm=$1
new_vm=$2
#a：生成虚拟机磁盘文件
old_disk=virsh dumpxml $old_vm|grep "<source file"|awk -F"'" '{print $2}'
disk_tmp=dirname $old_disk
qemu-img create -f qcow2 -b $old_disk

{disk_tmp}/

{new_vm}.qcow2
#b：生成虚拟机的配置文件
virsh dumpxml

old_vm >/tmp/

{new_vm}.xml
#修改虚拟机的名字
sed -ri "s#()(.*)()#\1

KaTeX parse error: Undefined control sequence: \3 at position 9: {new_vm}\̲3̲#g" /tmp/

{new_vm}.xml
#删除虚拟机uuid
sed -i ‘//d’ /tmp/

KaTeX parse error: Expected 'EOF', got '#' at position 14: {new_vm}.xml #̲删除mac地址 sed -i…

{new_vm}.xml
#修改磁盘路径
sed -ri “s#()#\1

{disk_tmp}/

{new_vm}.qcow2\3#g” /tmp/

KaTeX parse error: Expected 'EOF', got '#' at position 14: {new_vm}.xml #̲c：导入虚拟机并进行启动测试 …

{new_vm}.xml
virsh start ${new_vm}
4.8 kvm虚拟机的桥接网络
默认的虚拟机网络是NAT模式，网段192.168.122.0/24
4.8.1 创建桥接网卡
创建桥接网卡命令 virsh iface-bridge eth0 br0 取消桥接网卡命令 virsh iface-unbridge br0
4.8.2 新虚拟机使用桥接模式
默认NAT模式
virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name web04 --memory 1024 --vcpus 1 --disk /opt/web04.qcow2 --boot hd --network network=default --graphics vnc,listen=0.0.0.0 --noautoconsole
桥接模式
virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name web04 --memory 1024 --vcpus 1 --disk /data/web04.qcow2 --boot hd --network bridge=br0 --graphics vnc,listen=0.0.0.0 --noautoconsole
问题1：
如果虚拟机获取不到ip地址：

4.8.3 将已有虚拟机网络修改为桥接模式
a：关机状态下修改虚拟机配置文件：
例如：virsh edit centos7

b：启动虚拟机，测试虚拟机网络如果上层没有开启dhcp,需要手动配置ip地址,IPADDR,NATMASK.GATEWAY,DNS1=180.76.76.76 4.9 热添加技术热添加硬盘、网卡、内存、cpu 4.9.1 kvm热添加硬盘临时立即生效 virsh attach-disk web01 /data/web01-add.qcow2 vdb --subdriver qcow2 永久生效(需要重启) virsh attach-disk web01 /data/web01-add.qcow2 vdb --subdriver qcow2 --config 临时剥离硬盘 virsh detach-disk web01 vdb 永久剥离硬盘 virsh detach-disk web01 vdb --config 扩容：在虚拟机里把扩容盘的挂载目录，卸载掉在宿主机上剥离硬盘virsh detach-disk web01 vdb 在宿主机上调整容量qemu-img resize 在宿主机上再次附加硬盘virsh attach-disk web01 /data/web01-add.qcow2 vdb --subdriver qcow2 在虚拟机里再次挂载扩容盘在虚拟机里用xfs_growfs更新扩容盘超级块信息 4.9.2 kvm虚拟机在线热添加网卡 virsh attach-interface web04 --type bridge --source br0 --model virtio virsh attach-interface web04 --type bridge --source br0 --model virtio --config virsh detach-interface web04 --type bridge --mac 52:54:00:35:d3:71 4.9.3 kvm虚拟机在线热添加内存 virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name web04 --memory 512,maxmemory=2048 --vcpus 1 --disk /data/web04.qcow2 --boot hd --network bridge=br0 --graphics vnc,listen=0.0.0.0 --noautoconsole 临时热添加内存 virsh setmem web04 1024M 永久增大内存 virsh setmem web04 1024M --config 调整虚拟机内存最大值 virsh setmaxmem web04 4G #默认永久 4.9.4 kvm虚拟机在线热添加cpu virt-install --virt-type kvm --os-type=linux --os-variant rhel7 --name web04 --memory 512,maxmemory=2048 --vcpus 1,maxvcpus=10 --disk /data/web04.qcow2 --boot hd --network bridge=br0 --graphics vnc,listen=0.0.0.0 --noautoconsole 热添加cpu核数 virsh setvcpus web04 4 永久添加cpu核数 virsh setvcpus web04 4 --config 调整虚拟机cpu的最大值 virsh setvcpus web01 --maximum 4 --config 4.10 virt-manager和kvm虚拟机热迁移(共享的网络文件系统) 冷迁移kvm虚拟机:配置文件,磁盘文件热迁移kvm虚拟机:配置文件,nfs共享 kvm虚拟机热迁移 1：两边的环境（桥接网卡）主机名 ip 内存网络软件需求虚拟化 kvm01 10.0.0.11 2G 创建br0桥接网卡 kvm和nfs 开启虚拟化 kvm02 10.0.0.12 2G 创建br0桥接网卡 kvm和nfs 开启虚拟化 nfs01 10.0.0.31 1G 无 nfs 无 2：实现共享存储（nfs） yum install nfs-utils rpcbind -y vim /etc/exports /data 10.0.0.0/24(rw,async,no_root_squash,no_all_squash) systemctl start rpcbind nfs #kvm01和kvm02 mount -t nfs 10.0.0.31:/data /data 3：在线热迁移 #临时迁移 virsh migrate --live --verbose web04 qemu+ssh://10.0.0.11/system --unsafe #永久迁移 virsh migrate --live --verbose web03 qemu+ssh://10.0.0.100/system --unsafe --persistent --undefinesource 5. kvm管理平台 kvm宿主机 2000台查看每一个宿主机有多少台虚拟机? 查看每一个宿主机还剩多少资源? 查看每一台宿主机,每一个虚拟机的ip地址? excel 资产管理 cmdb kvm管理平台,数据库工具信息:宿主机,总配置,剩余的总配置虚拟机的信息,配置信息,ip地址,操作系统带计费功能的kvm管理平台,openstack ceilometer计费 ecs IAAS层自动化管理kvm宿主机,云主机定制化操作 5.1 用脚本自动化部署openstack M版部署openstack 克隆一台openstack模板机: all-in-one环境 4G内存,开启虚拟化,挂载centos7.6的光盘

虚拟机开机之后，修改ip地址为10.0.0.11
上传脚本openstack-mitaka-autoinstall.sh到/root目录
上传镜像:cirros-0.3.4-x86_64-disk.img到/root目录
上传配置文件:local_settings到/root目录
上传openstack_rpm.tar.gz到/root下,
tar xf openstack_rpm.tar.gz -C /opt/ mount /dev/cdrom /mnt
sh /root/openstack-mitaka-autoinstall.sh
大概10-30分钟左右访问http://10.0.0.11/dashboard 域:default 用户名:admin 密码:ADMIN_PASS
注意: 在windows系统上修改host解析(10.0.0.11 controller)
添加node节点:
修改ip地址 hostnamectl set-hostname compute1
重新登录让新主机名生效上传openstack_rpm.tar.gz到/root下,
tar xf openstack_rpm.tar.gz -C /opt/ mount /dev/cdrom /mnt
上传脚本openstack_compute_install.sh
sh openstack_compute_install.sh
openstack controller
主控制节点,node节点, kvm宿主机
node节点, kvm宿主机
node节点, kvm宿主机
node节点, kvm宿主机
二、第二部分 docker容器

什么是容器
容器是隔离的环境中运行的一个进程,如果进程结束,容器就会停止,容器的隔离环境,拥有自己的ip地址,系统文件,主机名,进程管理
程序: 代码,软件,命令
进程:正在运行的程序
容器和虚拟机的区别
虚拟机: 硬件cpu支持(vt虚拟化),模拟计算硬件,走正常的开机启动
bios开机自检–根据bios启动项–读取硬盘第一个扇区grub,uefi, centos7, 加载内核,启动系统第一个进程/sbin/init systemd
容器: 不需要硬件cpu的支持,共用宿主机内核,启动容器的第一个进程
容器优势: 启动快,性能高,损耗少,轻量级
100虚拟机 100个服务 10宿主机
100容器 100个服务 6宿主机
docker-ce的安装
主机名内存 ip
docker01 2G 10.0.0.11
docker02 2G 10.0.0.12
#安装docker-ce
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo
sed -i ‘s+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+’ /etc/yum.repos.d/docker-ce.repo
yum install docker-ce -y

systemctl enable docker
systemctl start docker

#验证
[root@docker01 yum.repos.d]# docker version
Client: Docker Engine - Community
Version: 19.03.5
API version: 1.40
Go version: go1.12.12
Git commit: 633a0ea
Built: Wed Nov 13 07:25:41 2019
OS/Arch: linux/amd64
Experimental: false
4. docker主要内容
docker是一个cs架构, docker主要:镜像容器仓库网络存储监控
docker是一个软件的打包技术.
docker run -d -p 80:80 nginx:latest
run 创建并启动一个容器
-d 放后台启动
-p 端口映射
nginx:latest docker镜像名称
5. docker镜像常用命令
 拉取/下载镜像
docker pull 镜像名称 [拉取镜像(下载镜像)，注意版本]
docker push 镜像名称 [推送镜像(上传镜像)]
 构建镜像
docker build -t 镜像名称
 查看已经下载的镜像
docker image ls
 删除本地镜像
docker rmi 镜像名称
 镜像导入/导出
docker import 导入镜像
• -c :应用docker 指令创建镜像；
• -m :提交时的说明文字
docker load -i 加载本地镜像
docker save -o 导出路径镜像id
例子:docker save centos:7 -o docker_centos7.tar.gz
 搜索镜像
docker search 搜索镜像, 优先选官方,stars数量多
例子: docker load -i docker_nginx.tar.gz
 给镜像打标签
docker tag 镜像id 新镜像名称:版本
 查看镜像创建历史
docker history 查看指定镜像的创建历史
• -H :以可读的格式打印镜像大小和日期，默认为true；
• --no-trunc :显示完整的提交记录；
• -q :仅列出提交记录ID。

docker容器的常用命令
 运行容器
docker run 镜像标识|镜像名称
( -v -e --privilege –network=host)
例子:docker run -d -it -p 80:80 nginx:latest
-d表示后台运行 -p表示宿机与容器间的映射端口 --name表示给容器指定的命名
 创建容器
docker create 创建容器 –name
 容器的启动、关闭、重启
docker start 启动容器
docker stop 停止容器
docker restart 重启容器
docker kill 强制停止容器
 查看正在运行的容器
docker ps 查看容器列表
docker ps -a 查看所有容器包括未运行的
docker ps -q 查看容器的标识
docker rm 删除容器
批量删除所有容器 docker rm -f docker ps -a -q
 查看容器日志
docker logs -f 容器id 查看容器的控制台输出
-f表示查看最后几行
进入容器
docker exec 进入正在运行的容器(分配一个新终端)
例子: docker exec -it 容器id/容器名字 /bin/bash(/bin/sh)
docker attach 进入正在运行的容器(使用相同的终端),偷偷离开的快捷键ctrl +p,ctrl +q
容器想要放在后台一直运行的化,那么容器的初始命令,必须夯住(前台运行),否则容器就会退出.
前台运行
nginx -g ‘daemon off;’
/usr/sbin/php-fpm –nodaemonize
 启动、关闭、删除、重命名容器
docker start 容器id　　启动容器
docker stop 容器id　　关闭容器
docker rm 容器id 　　删除容器
docker rename 容器id 重命名容器
 查看容器
docker top 查看容器中运行的进程信息，支持 ps 命令参数
docker container diff 查看容器中发生变化的文件
docker container inspect 查看容器的属性
docker container port 查看容器做了哪些随机端口
docker container stats 查看容器的所耗信息(–no-stream)
docker system df 查看容器的使用情况(整体磁盘的使用情况)
docker system info 查看整个docker系统的信息[容器的运行环境:runc]
 容器的导入导出
docker commit 把容器提交为镜像
docker container export 把容器导出为镜像压缩包
[docker export 3984da8164fb >docker_test.tar.gz(export导出的镜像压缩包只能用inport导入)]
 容器的拷贝、挂起、释放、移除、修改、清理
docker cp 用于容器与宿主机之间的数据拷贝
docker container pause 挂起容器
docker container upause 释放挂起的容器
docker container prune 移除所有停止的容器
docker container update 修改容器的属性，(–memory --memory-swap)
docker container wait 等一个或多个容器停止，打印出退出代码
docker system prune 清理没有使用的数据，包括镜像数据，已经停止的容器
docker system events 获取docker系统实时事件，不包括容器内的。
docker端口映射
docker run
-p 宿主机端口:容器端口
-p 宿主机ip1:宿主机端口:容器端口 (多个容器同时使用80端口)
-p 宿主机ip1::容器端口随机端口映射
-p 宿主机ip1::容器端口/udp 使用udp协议做随机端口映射
-p 80:80 -p 3306:3306
-p 1111-1119:1111-1119 端口范围映射
-P 自动随机端口映射
docker数据卷
docker run
-v 宿主机绝对目录:容器目录
-v 容器目录 #创建一个随机卷,来持久化容器的目录下的数据
-v 卷名:容器目录 #创建一个固定名字的卷,来持久化容器的目录下的数据
–volumes-from 跟某一个容器挂载所有相同的卷
小练习: 只启动一个nginx容器,要求访问80端口,出现nginx默认欢迎首页,访问81端口,出现小鸟飞飞.
手动制作docker镜像
 制作一个基于centos7系统的nginx镜像(单服务)
1:手动做镜像
a:启动一个基础容器,安装服务
echo “192.168.15.253 mirrors.aliyun.com” >>/etc/hosts
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum install nginx -y
rm -fr /usr/share/nginx/html/index.html
echo ‘web01’ >/usr/share/nginx/html/index.html

b:将安装好服务的容器提交为镜像
docker container commit 0f65a315c159 centos7_nginx:v1

c:测试镜像
docker run -d -p 82:80 centos7_nginx:v1 nginx -g ‘daemon off;’
 制作一个支持ssh登录的镜像
docker run -it -p 1022:22 centos:7
echo “192.168.15.253 mirrors.aliyun.com” >>/etc/hosts
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
yum install openssh-server -y
systemctl start sshd
cat /usr/lib/systemd/system/sshd.service
/usr/sbin/sshd -D
ls /etc/ssh/
cat /usr/lib/systemd/system/sshd-keygen.service
/usr/sbin/sshd-keygen
rpm -qa|grep initscripts
yum install initscripts -y
/usr/sbin/sshd-keygen
ls /etc/ssh/
/usr/sbin/sshd
ctrl+p ctrl+q 悄悄离开

docker ps -a -l

ssh root010.0.0.11 -p 1022
需要密码，然后ctrl+c退出
docker attach 6a0ece9b8778(这个是自己的容器ID)
进入容器
echo '123456 ’ |passwd --stdin root(设置密码)
ctrl+p ctrl+q 悄悄离开
ssh roota10.0.0.11 -p 1022
ps -ef
logout
docker attach 6a0ece9b8778
exit
宿主机：
docker ps -a -l
将容器提交为一个镜像
docker commit 6a0ece9b8778 centos7_sshd: v1
测试镜像
docker run -d -p 1023:22 centos7_sshd:v1 /usr/sbin/sshd -D
docker ps -a-l
ssh root010.0.0.11 -p 1023
 制作一个基于centos7系统的nginx+sshd双服务镜像
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

yum install nginx -y

yum install openssh-server -y

yum install initscripts -y

/usr/sbin/sshd-keygen

echo ‘123456’|passwd --stdin root
提交镜像之前写脚本
vim /init.sh
nginx
/usr/sbin/sshd -D
提交镜像

docker commit f784da45ec97 centos_nginx_sshd: v1
（已经提交了但是没写脚本怎么办？
重新弄一个容器写脚本

/usr/sbin/sshd -D

 制作一个基于centos7系统的kod网盘的镜像(多服务)
1:启动一个centos7_nginx:v1,再安装php

echo ‘192.168.12.201 mirrors.aliyun.com’ >>/etc/hosts

yum install php-fpm php-gd php-mbstring -y

vi /etc/php-fpm.d/www.conf

; RPM: apache Choosed to be able to access some dir as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
启动：
php-fpm -D

cd /etc/nginx/conf.d/

vi default.conf
server {
listen 80;
server_name _;
root /html;
index index.php index.html index.htm;
location ~ .php$ {
root /html;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /html$fastcgi_script_name;
include fastcgi_params;
}
}
mkdir /html

cd /html

curl -o kodexplorer4.40.zip http://192.168.15.253/kodexplorer4.40.zip

yum install unzip -y

unzip kodexplorer4.40.zip

chown -R nginx:nginx .

vi /init.sh

#!/bin/bash
nginx
/usr/sbin/php-fpm --nodaemonize

2:把安装好服务的容器,提交为镜像

docker commit 47208e3e3796 kod:v2

3:测试镜像的功能
docker run -d -p 83:80 kod:v2 /bin/bash /init.sh
10. 自动制作docker镜像
镜像：中药
dockerfile：配方
dockerfile常用指令
FROM 基础镜像
RUN 制作镜像过程中需要的执行命令(安装服务)
CMD 容器启动的时候执行的初始命令，容易被替换(启动服务)
ENTRYPOINT 容器启动的时候执行的初始命令，不能被替换，如果同时使用CMD和ENTRYPOINT，cmd命令将作为ENTRYPOINT命令的参数
ADD 把dockerfile当前目录下的文件拷贝到容器中（自动解压tar包）
COPY 把dockerfile当前目录下的文件拷贝到容器中（不解压tar包）
WORKDIR 指定容器的默认工作目录
EXPOSE 镜像要暴露的端口
VOLUME 持久化卷
ENV 环境变量(ssh的密码,数据库的密码)
LABEL 镜像的属性标签
MAINTAINER 管理者标识
根据dockerfile自动构建镜像的思路
a:手动制作docker镜像，记录历史命令
b：根据历史命令编写dockerfile文件
c：docker build构建docker镜像
d：测试镜像的功能
 dockerfile单服务例子1：
FROM centos:6.9
RUN echo ‘192.168.19.200 mirrors.aliyun.com’ >>/etc/hosts
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.
aliyun.com/repo/epel-6.repo
RUN yum install nginx -y
CMD [“nginx”,"-g",“daemon off;”]
 dockerfile多服务例子2：
FROM centos6.9_nginx:v1
RUN yum install php-fpm php-gd php-mbstring -y
ADD www.conf /etc/php-fpm.d/www.conf
ADD default.conf /etc/nginx/conf.d/default.conf
RUN mkdir /html
WORKDIR /html
RUN curl -o kodexplorer4.40.zip http://192.168.19.200/191127/kodexplorer4.40.zip
RUN yum install unzip -y
RUN unzip kodexplorer4.40.zip
RUN chown -R nginx:nginx .
ADD init.sh /init.sh

CMD ["/bin/bash","/init.sh"]

vi /init.sh
#!/bin/bash

service php-fpm start
nginx -g ‘daemon off;’
 dockerfile使用环境变量的例子：
FROM centos:7
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
RUN yum install nginx openssh-server initscripts -y
RUN /usr/sbin/sshd-keygen
ADD init.sh /init.sh
ENTRYPOINT ["/bin/bash","/init.sh"]

vi init.sh
#!/bin/bash
if [ -z $SSH_PWD ];then
SSH_PWD=$1
fi

echo $SSH_PWD|passwd --stdin root
nginx
/usr/sbin/sshd -D
11. docker镜像的分层(复用,节省空间)

dockerfile的优化
优化原则：
构建的镜像尽可能小,构建速度尽可能快
a: 使用体积小的linux镜像alpine作为基础镜像
[linux发行版最大的区别：安装包不一样、配置文件路径不一样、
Centos：yum rpm (red package manager ) 网卡配置路径
Suse：zypper
Ubuntu：apt-get /etc/network/interfaces /etc/int nginx rzsz

Alpine：apk
sed -i ‘s/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g’/etc/apk/ repositories
apk add nginx
Centos：编译器 gcc glibc jdk.rpm jdk.tar.gz
Alpine：编译器 musl libc
选择：alpine Debian/ubunto centos]
b：尽可能的清理无用的缓存文件（尽可能把多个RUN合并）
c：修改dockerfile的时候，尽可能把修改的内容放在最后
d：使用.dockerignore忽略构建docker镜像时，不需要的文件
13. 容器间的互联
容器之间通讯，面临的问题
容器IP地址按顺序分配，不知道要通讯的容器IP是多少
docker run –link docker run --name mysql-server -it
-e MYSQL_DATABASE=“zabbix”
-e MYSQL_USER=“zabbix”
-e MYSQL_PASSWORD=“zabbix_pwd”
-e MYSQL_ROOT_PASSWORD=“root_pwd”
-d mysql:5.7
–character-set-server=utf8 --collation-server=utf8_bin
docker run --name zabbix-java-gateway -t
-d zabbix/zabbix-java-gateway:latest

docker run --name zabbix-server-mysql -t
-e DB_SERVER_HOST=“mysql-server”
-e MYSQL_DATABASE=“zabbix”
-e MYSQL_USER=“zabbix”
-e MYSQL_PASSWORD=“zabbix_pwd”
-e MYSQL_ROOT_PASSWORD=“root_pwd”
-e ZBX_JAVAGATEWAY=“zabbix-java-gateway”
–link mysql-server:mysql
–link zabbix-java-gateway:zabbix-java-gateway
-p 10051:10051
-d zabbix/zabbix-server-mysql:latest

docker run --name zabbix-web-nginx-mysql -t
-e DB_SERVER_HOST=“mysql-server”
-e MYSQL_DATABASE=“zabbix”
-e MYSQL_USER=“zabbix”
-e MYSQL_PASSWORD=“zabbix_pwd”
-e MYSQL_ROOT_PASSWORD=“root_pwd”
–link mysql-server:mysql
–link zabbix-server-mysql:zabbix-server
-p 80:80
-d zabbix/zabbix-web-nginx-mysql:latest
14. 单机版的容器编排
yum install docker-compose -y(需要epel源)
docker-compose：批量管理一组容器
批量启动
批量关闭
批量重启
docker-compose up -d 创建并启动一组容器
docker-compose down 停止并删除一组容器
docker-compose start 批量启动
docker-compose stop 批量停止
docker-compose restart 重启
docker-compose scale 设置服务的容器数
Yaml文件
缩进
运行容器的名字（单方向）
version: ‘3’

services:
mysql-server:
image: mysql:5.7
restart: always
environment:
MYSQL_ROOT_PASSWORD: root_pwd
MYSQL_DATABASE: zabbix
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix_pwd
command: --character-set-server=utf8 --collation-server=utf8_bin

zabbix-java-gateway:
image: zabbix/zabbix-java-gateway:latest
restart: always

zabbix-server:
depends_on:
- mysql-server
image: zabbix/zabbix-server-mysql:latest
restart: always
environment:
DB_SERVER_HOST: mysql-server
MYSQL_DATABASE: zabbix
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix_pwd
MYSQL_ROOT_PASSWORD: root_pwd
ZBX_JAVAGATEWAY: zabbix-java-gateway
ports:
- “10051:10051”

zabbix-web-nginx-mysql:
depends_on:
- zabbix-server
image: zabbix/zabbix-web-nginx-mysql:latest
ports:
- “80:80”
restart: always
environment:
DB_SERVER_HOST: mysql-server
MYSQL_DATABASE: zabbix
MYSQL_USER: zabbix
MYSQL_PASSWORD: zabbix_pwd
MYSQL_ROOT_PASSWORD: root_pwd
docker-compose up -d 启动服务
docker-compose down 停止服务
15. 私有仓库docker-registry
.上传镜像的步骤:
1:打标签
2: docker push. 上传
#启动私有仓库
docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry :latest
#镜像地址
nginx:1.15 官方仓库的官方镜像
nginx/nginx:1.15 官方仓库的用户镜像

daocloud.io/nginx/nginx:1.15 私有仓库的镜像
#上传镜像
docker tag alpine:3.9 10.0.0.11:5000/alpine:3.9
docker image push 10.0.0.11:5000/alpine:3.9
#第一次上传镜像会报错
vim /etc/docker/daemon.json
{
“registry-mirrors”: [“https://registry.docker-cn.com”],
“insecure-registries”: [“10.0.0.11:5000”]
}
systemctl restart docker
docker image push 10.0.0.11:5000/alpine:3.9
#下载镜像
docker image pull 10.0.0.11:5000/alpine:3.9
16. 企业级私有仓库harbor(docker-compose)
#下载安装器
[root@docker02 ~]# cd /opt/
[root@docker02 opt]# wget http://192.168.15.253/harbor-offline-installer-v2.1.0.tgz
#解压
[root@docker02 opt]# tar xf harbor-offline-installer-v2.1.0.tgz
#修改配置文件
[root@docker02 opt]# cd harbor/
[root@docker02 harbor]# curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
[root@docker02 harbor]# yum -y install docker-compose
[root@docker02 harbor]# cp harbor.yml.tmpl harbor.yml
[root@docker02 harbor]# vim harbor.yml
hostname: 10.0.0.12
注释https的配置
harbor_admin_password: 123456
#执行安装脚本
./install.sh
[root@docker01 ~]$vim /etc/docker/daemon.json

{
“registry-mirrors”: [" https://registry.docker-cn.com"],
“insecure-registries”: [" 10.0.0.12"]
}

[root@docker01 ~]$systemctl restart docker

[root@docker01 ~] $d o c k e r t a g a l p i n e : 3.910.0.0.12 / l i b r a r y / a l p i n e : 3.9 [r o o t @ d o c k e r 01]$ docker login 10.0.0.12
[root@docker01 ~]$docker push 10.0.0.12/library/alpine:3.9
安全上传镜像(使用证书)
[root@docker02 opt]# mkdir cert
[root@docker02 opt]# cd cert
[root@docker02 cert]# pwd
/opt/cert
[root@docker02 cert]# wget http://192.168.15.253/blog.oldqiang.com.zip
[root@docker02 cert]# unzip blog.oldqiang.com.zip
[root@docker02 cert]# ls Nginx/
1_blog.oldqiang.com_bundle.crt 2_blog.oldqiang.com.key
[root@docker02 cert]# cd /opt/harbor/
[root@docker02 harbor]# pwd
/opt/harbor
[root@docker02 harbor]# cd /opt/
[root@docker02 opt]# cd cert
[root@docker02 cert]# ls
Apache blog.oldqiang.com.csr blog.oldqiang.com.zip IIS Nginx Tomcat
为harbor配置h#修改harbor.yml
[root@docker02 harbor]# vim harbor.yml
#配置域名
hostname: blog.oldqiang.com
#配置证书
https:
port: 443
certificate: /opt/certs/nginx/1_blog.oldqiang.com_bundle.crt
private_key: /opt/certs/nginx/2_blog.oldqiang.com.key
#重新执行安装脚本
./install.sh
[root@docker01 ~]# vim /etc/docker/daemon.json

[root@docker01 ~]# systemctl restart docker
[root@docker01 ~]# vim /etc/hosts
10.0.0.12 blog.oldqiang.com
[root@docker01 ~]# docker pull blog.oldqiang.com/library/alpine:3.9
docker images|grep Zabbix
docker tag zabbix/zabbix-server-mysql:latest blog.oldqiang.com/zabbix/zabbix-server-mysql:latest
docker login blog.oldqiang.com

docker pushblog.oldqiang.com/zabbix/zabbix-server-mysql:latest
rm -rf/root/.docker/config.json
docker login blog.oldqiang.com

docker pull blog.oldqiang.com/zabbix/zabbix-server-mysql:latest

docker-registry和harbor的区别，为什么优先选择harbor?

docker-registry 管理不方便，相对来说比较省资源
harbor 友好的web界面，功能更完善
17. docker基础网络
四种基础网络类型https证书
bridge 默认类型 NAT模式访问外网需要端口映射

host    host类型，使用宿主机网络，网络性能最高，不能有端口冲突，速度最高

container 容器类型。使用其他容器共用网络，k8s中使用
none 没有网络，上不了外网不给IP地址
创建自定义网络
docker network create -d bridge --subnet 172.18.0.0/16 --gateway 172.18.0.1 oldqiang
-d 指定网络类型
–subnet 子网
–gateway 网关
18. 跨宿主机容器间的通讯之macvlan
macvlan类似与虚拟机的桥接网络
macvlan：容器拥有和宿主机同一网段的IP，不能检测IP地址，需手动管理IP地址分配
#创建网络
docker network create -d macvlan --subnet 10.0.0.0/24 --gateway 10.0.0.2 -o parent=eth0 macvlan_1
#启动容器
docker run -it --network macvlan_1 --ip 10.0.0.105 alpine:3.9
19. 跨宿主机容器间的通讯之overlay
overlay: IP存储在consul服务里面，使用该网络的容器，默认有两张网卡，eth0：容器之间通讯使用，eth1：访问外网，可实现容器之间的双向通讯
docker03上： consul存储ip地址的分配
docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap
docker01、02上：
vim /etc/docker/daemon.json
{
“cluster-store”: “consul://10.0.0.13:8500”,
“cluster-advertise”: “10.0.0.11:2376”
}

systemctl restart docker

2）创建overlay网络
docker network create -d overlay --subnet 172.26.0.0/16 --gateway 172.26.0.1 ol1

3）启动容器测试
docker run -it --network ol1 --name oldboy01 alpine:3.9 /bin/sh
每个容器有两块网卡,eth0实现容器间的通讯,eth1实现容器访问外网
20. docker容器的监控
Linux监控：实现事前预警，
监控工具：
zabbix 容易使用，功能强大监控传统业务，监控主要靠模板，不好监控容器，
nagios 不保存历史数据，
catic 保存历史数据，每五分钟监控一次，
openfalcon 不好用，上手程度不如zabbix
监控软件：
Prometheus 普罗米修斯，
docker使用，监控容器业务，
功能：实现对数据的处理，目前不能替代zabbix,要监控就得有exporter，
(exporter主要作用：采集数据提供HTML页面，页面有采集好的数据，) [启动Prometheus时自动生成prometheus.yml配置文件(target)，]
作用：最终实现数据的集中处理。
Prometheus内置tsdb时间序列数据库，以时间作为索引，方便快速查询，
同时支持外置数据库，
需要在Prometheus中指定alterManager的IP和端口，实现报警(邮件报警、微信报警、钉钉报警，)
[报警规则：rule.yml文件]

官网下载:Prometheus.io/download

 #配置普罗米修斯：prometheus节点：docker03
	[root@oldboyedu ~]# cd /opt/
	[root@oldboyedu opt]# wget

http://192.168.15.253/prometheus-2.23.0.linux-amd64.tar.gz
[root@oldboyedu opt]# tar xf prometheus-2.23.0.linux-amd64.tar.gz
[root@oldboyedu opt]# cd prometheus-2.23.0.linux-amd64/
[root@oldboyedu prometheus-2.23.0.linux-amd64]# vim prometheus.yml

#启动prometheus

[root@oldboyedu prometheus-2.23.0.linux-amd64]# ./prometheus --config.file=“prometheus.yml” &
#客户端节点 docker01\02
#启动node-exporter
docker run -d -p 9100:9100 -v “/:/host:ro,rslave” --name=node_exporter quay.io/prometheus/node-exporter --path.rootfs /host

#启动cadvisor
docker run --volume=/:/rootfs:ro --volume=/var/run:/var/run:rw --volume=/sys:/sys:ro --volume=/var/lib/docker/:/var/lib/docker:ro --publish=8080:8080 --detach=true --name=cadvisor google/cadvisor:latest
-p （publish）
-v （volume）
-d （detach）
浏览器访问：10.0.0.13:9090

prometheus节点

cd prometheus-2.12.0.linux-amd64/
vim prometheus.yml
{scrape_configs:

job_name: ‘prometheus’
static_configs:
- targets: [‘localhost:9090’]
job_name: ‘cadvisor’
static_configs:
- targets: [‘10.0.0.11:8080’,‘10.0.0.12:8080’]
job_name: ‘node_exporter’
static_configs:
- targets: [‘10.0.0.11:9100’,‘10.0.0.12:9100’]} (静态报警)
  { - job_name: ‘cadvisor’
  file_sd_configs:
- files:
  - job/server.json
    refresh_interval: 10s }(动态报警)
    [root@oldboyedu prometheus-2.23.0.linux-amd64]# mkdir job
    [root@oldboyedu prometheus-2.23.0.linux-amd64]# vi job/server.json
    [
    {
    “targets”: [" 10.0.0.11:8080"," 10.0.0.12:8080"]
    }
    ]
    [root@oldboyedu prometheus-2.23.0.linux-amd64]# ps -ef |grep prome
    root 27748 26657 0 10:46 pts/0 00:00:02 ./prometheus --config.file=prometheus.yml
    root 27987 26657 0 11:18 pts/0 00:00:00 grep --color=auto prome
    [root@oldboyedu prometheus-2.23.0.linux-amd64]# kill 26657
    [root@oldboyedu prometheus-2.23.0.linux-amd64]# ./prometheus --config.file=“prometheus.yml” &

#启动prometheus
./prometheus --config.file=“prometheus.yml” &
浏览器访问：10.0.0.13:9090

alterManager报警：
思路：alterManager配置收件人和发件人
普罗米修斯上配置报警规则rule.yml（重启生效）
Grafana（开源的数据可视化工具）
普罗米修斯节点：
#安装grafana
yum localinstall grafana-6.3.3-1.x86_64.rpm -y
systemctl start grafana-server.service
systemctl enable grafana-server.service
#访问grafana http://10.0.0.13:3000，默认账号admin:admin
插件;zabbix的插件
数据源：要写上普罗米修斯的地址
作用：优化web界面
新建数据源导入dashboard模板

保存并退出：

保存后我们发现普罗米修斯数据源添加成功：

Dashboard:出图模板(grafan.doc官网下载)
浏览器访问grafana官网：grafana.com/docs
 

 

 
上传刚刚下载的json文件

实现监控nodeExporter：

实现监控cadvisor:

下载json文件：

在普罗米修斯中的图：

三、第三部分：k8s

k8s集群的安装
1.1 k8s的架构

一个master对应一群node
Kubectl:用户通过这个工具去调用api-server管理集群
Master：
api-server :相当于k8s的网关，所有的请求都得经过api-server转发
scheduler：使用调度算法将请求调度到某一个node节点
controller:控制器，维护k8s资源删除增加等
etcd:存储资源对象服务注册发现
node:
docker:运行容器的环境即容器引擎
kubelet:每个node节点都有一个,在node资源相关指令就由kubelet来执行。扫描etcd获取相关指令，扫描请求。一旦发现请求，就在node执行。
Kube-proxy: 代理服务
Pod: 最小单元，内部是容器。k8s不直接管理容器，是通过管理pod来管理容器
Fluented:日志收集服务
Service：

Scheduler的调度：
请求交给api-server，然后将指令数据存储在etcd,node节点的kubelet扫描etcd，从etcd之中获取相关数据信息，然后再node节点执行相关的指令
ReplicationControler/ReplicaSet: rs 副本控制器管理pod
Deployment：管理rs与pod
StatefulSet:
Daemonset:确保多节点部署同一个pod.

核心服务：API server (解析执行任何的k8s命令)[所有k8s组都受API server控制，调用docker创建容器]
etcd :数据库 (存储k8s中创建的资源)[非关系型数据库]
Schedule：调度器 (创建容器时，选择合适的目前资源较多，负载不是很高的，剩余内存较多的节点)
node节点安装一个服务（kubelet：调用docker来实现对容器的管理，随时可以接受API server的远程控制）
所有容器封装在pod中
API server调用kubelet创建容器–kubelet调用docker
监管的角色（controller manager—控制管理，检测容器数量与状态，确保数量不减少）
k8s与cadvisor谷歌公司开发
Kube-proxy作用:实现负载均衡
Plugin network网络插件
Calico 3层acl
Fiannel（简单、高效、容器达到跨宿主机通讯）
k8s构建：
master:etcd api-server controller-manager scheduler
node : kubelet kube-proxy
kubelet作用：接受api-server指令，调用docker启动容器
除了核心组件，还有一些推荐的Add-ons：(附加组件是可选的)
组件名称说明
kube-dns 负责为整个集群提供DNS服务
Ingress Controller 为服务提供外网入口
Heapster 提供资源监控
Dashboard 提供GUI(web界面)
Federation 提供跨可用区的集群(联邦集群，管理多套环境)
Fluentd-elasticsearch 提供集群日志采集、存储与查询

Kubectl命令：
create
describe
edit
get
exec
scale
set image
Run 默认创建deployment
expose
rolling-update
rolllout
logs
1.2 k8s的架构(二进制安装)

1.3 k8s的安装(二进制安装)
环境准备(修改ip地址，主机名，host解析)
做hosts解析和秘钥推送(四个节点都要做)
vim /etc/hosts
10.0.0.11 k8s-master
10.0.0.12 k8s-node1
10.0.0.13 k8s-node2
10.0.0.14 k8s-node3
ssh-keygen
ssh-copy-id root@10.0.0.11
ssh-copy-id root@10.0.0.12
ssh-copy-id root@10.0.0.13
ssh-copy-id root@10.0.0.14
主机 ip 内存软件
k8s-master 10.0.0.11 1g etcd，api-server，controller-manager，scheduler
k8s-node1 100.0.12 2g etcd，kubelet，kube-proxy，docker，flannel
k8s-node2 10.0.0.13 2g ectd，kubelet，kube-proxy，docker，flannel
k8s-node3 10.0.0.14 1g kubelet，kube-proxy，docker，flannel
1.3.1 颁发证书：
K8s组件都是通过http协议，节点和节点之间通讯需要证书
etcd–etcd—etcd
api-server – etcd
flanneld –> etcd
api-server –> kubelet
api-server -> kube-proxy
6443 https
api-server –> controller-manager
api-server -> scheduler
8080 http 127.0.0.1
准备证书颁发工具[openssl生成ca.crt证书，生成xxx.csr请求文件，生成xxx.key私钥，比较麻烦，现在使用cfssl生成证书比较简单，cfssl-certinfo验证证书的有效期]
在node3节点上
[root@k8s-node3 ~]# mkdir /opt/softs
[root@k8s-node3 ~]# cd /opt/softs
[root@k8s-node3 softs]# rz -E
[root@k8s-node3 softs]# ls
cfssl cfssl-certinfo cfssl-json
[root@k8s-node3 softs]# chmod +x /opt/softs/*
[root@k8s-node3 softs]# ln -s /opt/softs/* /usr/bin/
[root@k8s-node3 softs]# mkdir /opt/certs
[root@k8s-node3 softs]# cd /opt/certs
编辑ca证书配置文件
vi /opt/certs/ca-config.json
i{
“signing”: {
“default”: {
“expiry”: “175200h”
},
“profiles”: {
“server”: {
“expiry”: “175200h”,
“usages”: [
“signing”,
“key encipherment”,
“server auth”
]
},
“client”: {
“expiry”: “175200h”,
“usages”: [
“signing”,
“key encipherment”,
“client auth”
]
},
“peer”: {
“expiry”: “175200h”,
“usages”: [
“signing”,
“key encipherment”,
“server auth”,
“client auth”
]
}
}
}
}
编辑ca证书请求配置文件
vi /opt/certs/ca-csr.json
i{
“CN”: “kubernetes-ca”,
“hosts”: [
],
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
],
“ca”: {
“expiry”: “175200h”
}
}
生成CA证书和私钥
[root@k8s-node3 certs]# cfssl gencert -initca ca-csr.json | cfssl-json -bare ca -
[root@k8s-node3 certs]# ls
ca-config.json ca.csr ca-csr.json ca-key.pem ca.pem
1.3.2 部署etcd集群
主机名 ip 角色
k8s-master 10.0.0.11 etcd lead
k8s-node1 10.0.0.12 etcd follow
k8s-node2 10.0.0.13 etcd follow
颁发etcd节点之间通信的证书
vi /opt/certs/etcd-peer-csr.json
i{
“CN”: “etcd-peer”,
“hosts”: [
“10.0.0.11”,
“10.0.0.12”,
“10.0.0.13”
],
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
]
}

[root@k8s-node3 certs]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=peer etcd-peer-csr.json | cfssl-json -bare etcd-peer
[root@k8s-node3 certs]# ls etcd-peer*
etcd-peer.csr etcd-peer-csr.json etcd-peer-key.pem etcd-peer.pem
安装etcd服务
在k8s-master,k8s-node1,k8s-node2上
yum install etcd -y
#在node3上发送证书到/etc/etcd目录
[root@k8s-node3 certs]# scp -rp *.pem root@10.0.0.11:/etc/etcd/
[root@k8s-node3 certs]# scp -rp *.pem root@10.0.0.12:/etc/etcd/
[root@k8s-node3 certs]# scp -rp .pem root@10.0.0.13:/etc/etcd/
#所有节点
[root@k8s-master ~]# chown -R etcd:etcd /etc/etcd/.pem
#master节点
[root@k8s-master ~]# grep -Ev ‘^$|#’ /etc/etcd/etcd.conf
ETCD_DATA_DIR="/var/lib/etcd/"
ETCD_LISTEN_PEER_URLS=“https://10.0.0.11:2380”
ETCD_LISTEN_CLIENT_URLS=“https://10.0.0.11:2379,http://127.0.0.1:2379”
ETCD_NAME=“node1”
ETCD_INITIAL_ADVERTISE_PEER_URLS=“https://10.0.0.11:2380”
ETCD_ADVERTISE_CLIENT_URLS=“https://10.0.0.11:2379,http://127.0.0.1:2379”
ETCD_INITIAL_CLUSTER=“node1=https://10.0.0.11:2380,node2=https://10.0.0.12:2380,node3=https://10.0.0.13:2380”
ETCD_INITIAL_CLUSTER_TOKEN=“etcd-cluster”
ETCD_INITIAL_CLUSTER_STATE=“new”
ETCD_CERT_FILE="/etc/etcd/etcd-peer.pem"
ETCD_KEY_FILE="/etc/etcd/etcd-peer-key.pem"
ETCD_CLIENT_CERT_AUTH=“true”
ETCD_TRUSTED_CA_FILE="/etc/etcd/ca.pem"
ETCD_AUTO_TLS=“true”
ETCD_PEER_CERT_FILE="/etc/etcd/etcd-peer.pem"
ETCD_PEER_KEY_FILE="/etc/etcd/etcd-peer-key.pem"
ETCD_PEER_CLIENT_CERT_AUTH=“true”
ETCD_PEER_TRUSTED_CA_FILE="/etc/etcd/ca.pem"
ETCD_PEER_AUTO_TLS=“true”

#node1和node2需修改
ETCD_LISTEN_PEER_URLS=“https://10.0.0.11:2380”
ETCD_LISTEN_CLIENT_URLS=“https://10.0.0.11:2379,http://127.0.0.1:2379”
ETCD_NAME=“node1”
ETCD_INITIAL_ADVERTISE_PEER_URLS=“https://10.0.0.11:2380”
ETCD_ADVERTISE_CLIENT_URLS=“https://10.0.0.11:2379,http://127.0.0.1:2379”

#3个etcd节点同时启动
systemctl start etcd
systemctl enable etcd

#验证
[root@k8s-master ~]# etcdctl member list

1.3.3 master节点的安装
 安装api-server服务
上传kubernetes-server-linux-amd64-v1.15.4.tar.gz到node3上，然后解压
[root@k8s-node3 softs]# ls
cfssl cfssl-certinfo cfssl-json kubernetes-server-linux-amd64-v1.15.4.tar.gz
[root@k8s-node3 softs]# tar xf kubernetes-server-linux-amd64-v1.15.4.tar.gz
[root@k8s-node3 softs]# ls
cfssl cfssl-certinfo cfssl-json kubernetes kubernetes-server-linux-amd64-v1.15.4.tar.gz
[root@k8s-node3 softs]# cd /opt/softs/kubernetes/server/bin/
[root@k8s-node3 bin]# rm -rf *.tar *_tag
[root@k8s-node3 bin]# scp -rp kube-apiserver kube-controller-manager kube-scheduler kubectl root@10.0.0.11:/usr/sbin/
签发client证书
[root@k8s-node3 bin]# cd /opt/certs/
[root@k8s-node3 certs]# vi /opt/certs/client-csr.json
i{
“CN”: “k8s-node”,
“hosts”: [
],
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
]
}

[root@k8s-node3 certs]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client client-csr.json | cfssl-json -bare client
[root@k8s-node3 certs]# ls client*
client.csr client-csr.json client-key.pem client.pem
签发kube-apiserver证书
[root@k8s-node3 certs]# vi /opt/certs/apiserver-csr.json
i{
“CN”: “apiserver”,
“hosts”: [
“127.0.0.1”,
“10.254.0.1”,
“kubernetes.default”,
“kubernetes.default.svc”,
“kubernetes.default.svc.cluster”,
“kubernetes.default.svc.cluster.local”,
“10.0.0.11”,
“10.0.0.12”,
“10.0.0.13”
],
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
]
}

#注意10.254.0.1为clusterIP网段的第一个ip，做为pod访问api-server的内部ip，oldqiang在这一块被坑了很久

[root@k8s-node3 certs]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=server apiserver-csr.json | cfssl-json -bare apiserver
[root@k8s-node3 certs]# ls apiserver*
apiserver.csr apiserver-csr.json apiserver-key.pem apiserver.pem
配置api-server服务
master节点
#拷贝证书
[root@k8s-master ~]# mkdir /etc/kubernetes
[root@k8s-master ~]# cd /etc/kubernetes
[root@k8s-master kubernetes]# scp -rp root@10.0.0.14:/opt/certs/capem .
[root@k8s-master kubernetes]# scp -rp root@10.0.0.14:/opt/certs/apiserverpem .
[root@k8s-master kubernetes]# scp -rp root@10.0.0.14:/opt/certs/client*pem .
[root@k8s-master kubernetes]# ls
apiserver-key.pem apiserver.pem ca-key.pem ca.pem client-key.pem client.pem
#api-server审计日志规则
[root@k8s-master kubernetes]# vi audit.yaml
iapiVersion: audit.k8s.io/v1beta1 # This is required.
kind: Policy

Don’t generate audit events for all requests in RequestReceived stage.

omitStages:

“RequestReceived”
rules:

Log pod changes at RequestResponse level

level: RequestResponse
resources:
- group: “”
  Resource “pods” doesn’t match requests to any subresource of pods,
  
  which is consistent with the RBAC policy.
  resources: [“pods”]

Log “pods/log”, “pods/status” at Metadata level

level: Metadata
resources:
- group: “”
  resources: [“pods/log”, “pods/status”]

Don’t log requests to a configmap called “controller-leader”

level: None
resources:
- group: “”
  resources: [“configmaps”]
  resourceNames: [“controller-leader”]

Don’t log watch requests by the “system:kube-proxy” on endpoints or services

level: None
users: [“system:kube-proxy”]
verbs: [“watch”]
resources:
- group: “” # core API group
  resources: [“endpoints”, “services”]

Don’t log authenticated requests to certain non-resource URL paths.

level: None
userGroups: [“system:authenticated”]
nonResourceURLs:
- “/api*” # Wildcard matching.
- “/version”

Log the request body of configmap changes in kube-system.

level: Request
resources:
- group: “” # core API group
  resources: [“configmaps”]
This rule only applies to resources in the “kube-system” namespace.

The empty string “” can be used to select non-namespaced resources.
namespaces: [“kube-system”]

Log configmap and secret changes in all other namespaces at the Metadata level.

level: Metadata
resources:
- group: “” # core API group
  resources: [“secrets”, “configmaps”]

Log all other resources in core and extensions at the Request level.

level: Request
resources:
- group: “” # core API group
- group: “extensions” # Version of group should NOT be included.

A catch-all rule to log all other requests at the Metadata level.

level: Metadata

Long-running requests like watches that fall under this rule will not

generate an audit event in RequestReceived.

omitStages:
- “RequestReceived”
vi /usr/lib/systemd/system/kube-apiserver.service
i[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
After=etcd.service
[Service]
ExecStart=/usr/sbin/kube-apiserver
–audit-log-path /var/log/kubernetes/audit-log
–audit-policy-file /etc/kubernetes/audit.yaml
–authorization-mode RBAC
–client-ca-file /etc/kubernetes/ca.pem
–requestheader-client-ca-file /etc/kubernetes/ca.pem
–enable-admission-plugins NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,MutatingAdmissionWebhook,ValidatingAdmissionWebhook,ResourceQuota
–etcd-cafile /etc/kubernetes/ca.pem
–etcd-certfile /etc/kubernetes/client.pem
–etcd-keyfile /etc/kubernetes/client-key.pem
–etcd-servers https://10.0.0.11:2379,https://10.0.0.12:2379,https://10.0.0.13:2379
–service-account-key-file /etc/kubernetes/ca-key.pem
–service-cluster-ip-range 10.254.0.0/16
–service-node-port-range 30000-59999
–kubelet-client-certificate /etc/kubernetes/client.pem
–kubelet-client-key /etc/kubernetes/client-key.pem
–log-dir /var/log/kubernetes/
–logtostderr=false
–tls-cert-file /etc/kubernetes/apiserver.pem
–tls-private-key-file /etc/kubernetes/apiserver-key.pem
–v 2 #(日志级别)
Restart=on-failure
[Install]
WantedBy=multi-user.target #(安装到多个用户级别)

[root@k8s-master kubernetes]# mkdir /var/log/kubernetes
[root@k8s-master kubernetes]# systemctl daemon-reload
[root@k8s-master kubernetes]# systemctl start kube-apiserver.service
[root@k8s-master kubernetes]# systemctl enable kube-apiserver.service

#检验
[root@k8s-master kubernetes]# kubectl get cs

 安装controller-manager服务
[root@k8s-master kubernetes]# vi /usr/lib/systemd/system/kube-controller-manager.service
i[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
After=kube-apiserver.service
[Service]
ExecStart=/usr/sbin/kube-controller-manager
–cluster-cidr 172.18.0.0/16 \ #(pod节点的网段)
–log-dir /var/log/kubernetes/
–master http://127.0.0.1:8080
–service-account-private-key-file /etc/kubernetes/ca-key.pem
–service-cluster-ip-range 10.254.0.0/16 \ #(vip 的网段)
–root-ca-file /etc/kubernetes/ca.pem
–logtostderr=false
–v 2
Restart=on-failure
[Install]
WantedBy=multi-user.target

[root@k8s-master kubernetes]# systemctl daemon-reload
[root@k8s-master kubernetes]# systemctl start kube-controller-manager.service
[root@k8s-master kubernetes]# systemctl enable kube-controller-manager.service
 安装scheduler服务
[root@k8s-master kubernetes]# vi /usr/lib/systemd/system/kube-scheduler.service
i[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
After=kube-apiserver.service
[Service]
ExecStart=/usr/sbin/kube-scheduler
–log-dir /var/log/kubernetes/
–master http://127.0.0.1:8080
–logtostderr=false
–v 2
Restart=on-failure
[Install]
WantedBy=multi-user.target

[root@k8s-master kubernetes]# systemctl daemon-reload
[root@k8s-master kubernetes]# systemctl start kube-scheduler.service
[root@k8s-master kubernetes]# systemctl enable kube-scheduler.service
验证master节点
[root@k8s-master kubernetes]# kubectl get cs

1.3.4 node节点的安装
 安装kubelet服务
在node3节点上签发证书
[root@k8s-node3 bin]# cd /opt/certs/
[root@k8s-node3 certs]# vi kubelet-csr.json
i{
“CN”: “kubelet-node”,
“hosts”: [
“127.0.0.1”,
“10.0.0.11”,
“10.0.0.12”,
“10.0.0.13”,
“10.0.0.14”,
“10.0.0.15”
],
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
]
}

[root@k8s-node3 certs]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=server kubelet-csr.json | cfssl-json -bare kubelet
[root@k8s-node3 certs]# ls kubelet*
kubelet.csr kubelet-csr.json kubelet-key.pem kubelet.pem

#生成kubelet启动所需的kube-config文件
[root@k8s-node3 certs]# ln -s /opt/softs/kubernetes/server/bin/kubectl /usr/sbin/
#设置集群参数
[root@k8s-node3 certs]# kubectl config set-cluster myk8s
–certificate-authority=/opt/certs/ca.pem
–embed-certs=true
–server=https://10.0.0.11:6443
–kubeconfig=kubelet.kubeconfig
#设置客户端认证参数
[root@k8s-node3 certs]# kubectl config set-credentials k8s-node --client-certificate=/opt/certs/client.pem --client-key=/opt/certs/client-key.pem --embed-certs=true --kubeconfig=kubelet.kubeconfig
#生成上下文参数
[root@k8s-node3 certs]# kubectl config set-context myk8s-context
–cluster=myk8s
–user=k8s-node
–kubeconfig=kubelet.kubeconfig
#切换默认上下文
[root@k8s-node3 certs]# kubectl config use-context myk8s-context --kubeconfig=kubelet.kubeconfig
#查看生成的kube-config文件
[root@k8s-node3 certs]# ls kubelet.kubeconfig
kubelet.kubeconfig
master节点上
[root@k8s-master ~]# vi k8s-node.yaml
iapiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding #(集群角色绑定)
metadata:
name: k8s-node
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:node
subjects:

apiGroup: rbac.authorization.k8s.io
kind: User
name: k8s-node
[root@k8s-master ~]# kubectl create -f k8s-node.yaml
node1节点：
#安装docker-ce
[root@k8s-node1 ~]# wget http://192.168.15.253/docker1903_rpm.tar.gz
[root@k8s-node1 ~]# tar xf docker1903_rpm.tar.gz
[root@k8s-node1 ~]# cd docker1903_rpm/
[root@k8s-node1 docker1903_rpm]# yum -y localinstall *.rpm
[root@k8s-node1 docker1903_rpm]# systemctl start docker.service
[root@k8s-node1 docker1903_rpm]# systemctl enable docker.service
vim /etc/docker/daemon.json
i{
“registry-mirrors”: [“https://registry.docker-cn.com”],
“exec-opts”: [“native.cgroupdriver=systemd”]
}
systemctl restart docker.service
systemctl enable docker.service

[root@k8s-node1 ~]# mkdir /etc/kubernetes
[root@k8s-node1 ~]# cd /etc/kubernetes
[root@k8s-node1 kubernetes]# scp -rp root@10.0.0.14:/opt/certs/kubelet.kubeconfig .
[root@k8s-node1 kubernetes]# scp -rp root@10.0.0.14:/opt/certs/capem .
[root@k8s-node1 kubernetes]# scp -rp root@10.0.0.14:/opt/certs/kubeletpem .
[root@k8s-node1 kubernetes]# scp -rp root@10.0.0.14:/opt/softs/kubernetes/server/bin/kubelet /usr/bin/
[root@k8s-node1 kubernetes]# mkdir /var/log/kubernetes
[root@k8s-node1 kubernetes]# vi /usr/lib/systemd/system/kubelet.service
i[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
[Service]
ExecStart=/usr/bin/kubelet
–anonymous-auth=false
–cgroup-driver systemd
–cluster-dns 10.254.230.254
–cluster-domain cluster.local
–runtime-cgroups=/systemd/system.slice
–kubelet-cgroups=/systemd/system.slice
–fail-swap-on=false
–client-ca-file /etc/kubernetes/ca.pem
–tls-cert-file /etc/kubernetes/kubelet.pem
–tls-private-key-file /etc/kubernetes/kubelet-key.pem
–hostname-override 10.0.0.12
–image-gc-high-threshold 20
–image-gc-low-threshold 10
–kubeconfig /etc/kubernetes/kubelet.kubeconfig
–log-dir /var/log/kubernetes/
–pod-infra-container-image t29617342/pause-amd64:3.0
–logtostderr=false
–v=2
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
注释: --fail-swap-on=false \ #(默认值是true,kubelate在启动的时候默认不支持swap,有swap的时候默认是有缓存的，)
–image-gc-high-threshold 20
–image-gc-low-threshold 10 \ #做镜像回收
–pod-infra-container-image t29617342/pause-amd64:3.0 \ #基础pod镜像容器地址

[root@k8s-node1 kubernetes]# systemctl daemon-reload
[root@k8s-node1 kubernetes]# systemctl start kubelet.service
[root@k8s-node1 kubernetes]# systemctl enable kubelet.service
node2节点：
以上步骤同node1节点只需改配置文件
[root@k8s-node2 kubernetes]# vi /usr/lib/systemd/system/kubelet.service
i[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
[Service]
ExecStart=/usr/bin/kubelet
–anonymous-auth=false
–cgroup-driver systemd
–cluster-dns 10.254.230.254
–cluster-domain cluster.local
–runtime-cgroups=/systemd/system.slice
–kubelet-cgroups=/systemd/system.slice
–fail-swap-on=false
–client-ca-file /etc/kubernetes/ca.pem
–tls-cert-file /etc/kubernetes/kubelet.pem
–tls-private-key-file /etc/kubernetes/kubelet-key.pem
–hostname-override 10.0.0.13
–image-gc-high-threshold 20
–image-gc-low-threshold 10
–kubeconfig /etc/kubernetes/kubelet.kubeconfig
–log-dir /var/log/kubernetes/
–pod-infra-container-image t29617342/pause-amd64:3.0
–logtostderr=false
–v=2
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
[root@k8s-node1 kubernetes]# systemctl daemon-reload
[root@k8s-node1 kubernetes]# systemctl start kubelet.service
[root@k8s-node1 kubernetes]# systemctl enable kubelet.service
master节点验证
[root@k8s-master ~]# kubectl get nodes

安装kube-proxy服务
在node3节点上签发证书
[root@k8s-node3 ~]# cd /opt/certs/
[root@k8s-node3 certs]# vi /opt/certs/kube-proxy-csr.json
i{
“CN”: “system:kube-proxy”,
“key”: {
“algo”: “rsa”,
“size”: 2048
},
“names”: [
{
“C”: “CN”,
“ST”: “beijing”,
“L”: “beijing”,
“O”: “od”,
“OU”: “ops”
}
]
}

[root@k8s-node3 certs]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client kube-proxy-csr.json | cfssl-json -bare kube-proxy-client
[root@k8s-node3 certs]# ls kube-proxy-c*
kube-proxy-client.csr kube-proxy-client-key.pem kube-proxy-client.pem kube-proxy-csr.json

#生成kube-proxy启动所需要kube-config
[root@k8s-node3 certs]# kubectl config set-cluster myk8s
–certificate-authority=/opt/certs/ca.pem
–embed-certs=true
–server=https://10.0.0.11:6443
–kubeconfig=kube-proxy.kubeconfig
[root@k8s-node3 certs]# kubectl config set-credentials kube-proxy
–client-certificate=/opt/certs/kube-proxy-client.pem
–client-key=/opt/certs/kube-proxy-client-key.pem
–embed-certs=true
–kubeconfig=kube-proxy.kubeconfig
[root@k8s-node3 certs]# kubectl config set-context myk8s-context
–cluster=myk8s
–user=kube-proxy
–kubeconfig=kube-proxy.kubeconfig
[root@k8s-node3 certs]# kubectl config use-context myk8s-context --kubeconfig=kube-proxy.kubeconfig
[root@k8s-node3 certs]# ls kube-proxy.kubeconfig
kube-proxy.kubeconfig
[root@k8s-node3 certs]# scp -rp kube-proxy.kubeconfig root@10.0.0.12:/etc/kubernetes/
[root@k8s-node3 certs]# scp -rp kube-proxy.kubeconfig root@10.0.0.13:/etc/kubernetes/
[root@k8s-node3 certs]# cd /opt/softs/kubernetes/server/bin/
[root@k8s-node3 bin]# scp -rp kube-proxy root@10.0.0.12:/usr/bin/
[root@k8s-node3 bin]# scp -rp kube-proxy root@10.0.0.13:/usr/bin/
在node1节点上配置kube-proxy
[root@k8s-node1 ~]# vi /usr/lib/systemd/system/kube-proxy.service
i[Unit]
Description=Kubernetes Proxy
After=network.target
[Service]
ExecStart=/usr/bin/kube-proxy
–kubeconfig /etc/kubernetes/kube-proxy.kubeconfig
–cluster-cidr 172.18.0.0/16
–hostname-override 10.0.0.12
–logtostderr=false
–v=2
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target

[root@k8s-node1 ~]# systemctl daemon-reload
[root@k8s-node1 ~]# systemctl start kube-proxy.service
[root@k8s-node1 ~]# systemctl enable kube-proxy.service
Node2 节点上配置：
和node1一样，node2的/usr/lib/systemd/system/kube-proxy.service配置文件修改
–hostname-override 10.0.0.13
验证;

1.3.5 配置flannel网络
所有节点安装flannel(11、12、13)
yum install flannel -y
mkdir /opt/certs/
在node3上分发证书
[root@k8s-node3 ~]# cd /opt/certs/
[root@k8s-node3 certs]# scp -rp ca.pem clientpem root@10.0.0.11:/opt/certs/
[root@k8s-node3 certs]# scp -rp ca.pem clientpem root@10.0.0.12:/opt/certs/
[root@k8s-node3 certs]# scp -rp ca.pem client*pem root@10.0.0.13:/opt/certs/
在master节点上
etcd创建flannel的key
#通过这个key定义pod的ip地址范围
etcdctl mk /atomic.io/network/config ‘{ “Network”: “172.18.0.0/16”,“Backend”: {“Type”: “vxlan”} }’
#注意可能会失败提示
Error: x509: certificate signed by unknown authority
#多重试几次就好了
配置启动flannel
vi /etc/sysconfig/flanneld
第4行：FLANNEL_ETCD_ENDPOINTS=“https://10.0.0.11:2379,https://10.0.0.12:2379,https://10.0.0.13:2379”
第8行不变：FLANNEL_ETCD_PREFIX="/atomic.io/network"
第11行：FLANNEL_OPTIONS="-etcd-cafile=/opt/certs/ca.pem -etcd-certfile=/opt/certs/client.pem -etcd-keyfile=/opt/certs/client-key.pem"

systemctl start flanneld.service
systemctl enable flanneld.service
[root@k8s-master ~]# scp -rp /etc/sysconfig/flanneld root@10.0.0.12:/etc/sysconfig/flanneld
[root@k8s-master ~]# scp -rp /etc/sysconfig/flannel root@10.0.0.13:/etc/sysconfig/flanneld
#验证
[root@k8s-master ~]# ifconfig flannel.1
flannel.1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1450
inet 172.18.43.0 netmask 255.255.255.255 broadcast 0.0.0.0
inet6 fe80::30d9:50ff:fe47:599e prefixlen 64 scopeid 0x20
ether 32:d9:50:47:59:9e txqueuelen 0 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 8 overruns 0 carrier 0 collisions 0
在node1和node2上
[root@k8s-node1 ~]# vim /usr/lib/systemd/system/docker.service
将ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
修改为ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS -H fd:// --containerd=/run/containerd/containerd.sock
增加一行ExecStartPost=/usr/sbin/iptables -P FORWARD ACCEPT
[root@k8s-node1 ~]# systemctl daemon-reload
[root@k8s-node1 ~]# systemctl restart docker
验证：启动一个容器，测试网络通不通
Node1节点、node2节点启动一个容器
[root@k8s-node1 ~]# wget http://192.168.15.253/docker_images/docker_alpine3.9.tar.gz
[root@k8s-node1 ~]# docker load -i docker_alpine3.9.tar.gz
[root@k8s-node1 ~]# docker run -it alpine:3.9
/ # ifconfig
eth0 Link encap:Ethernet HWaddr 02:42:AC:12:4D:02
inet addr:172.18.77.2 Bcast:172.18.77.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1450 Metric:1
RX packets:11 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:962 (962.0 B) TX bytes:0 (0.0 B)

lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
/ #
在master节点上测试网络：
[root@k8s-master ~]# ping 172.18.77.2
PING 172.18.77.2 (172.18.77.2) 56(84) bytes of data.
64 bytes from 172.18.77.2: icmp_seq=1 ttl=63 time=1.73 ms
^C
— 172.18.77.2 ping statistics —
1 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.367/1.049/1.732/0.683 ms
[root@k8s-master ~]# ping 172.18.72.2
PING 172.18.72.2 (172.18.72.2) 56(84) bytes of data.
64 bytes from 172.18.72.2: icmp_seq=1 ttl=63 time=2.57 ms
^C
— 172.18.72.2 ping statistics —
1 packets transmitted, 2 received, 0% packet loss, time 1002ms
rtt min/avg/max/mdev = 0.387/1.480/2.573/1.093 ms
#验证，docker0网络为172.18网段就ok了
[root@k8s-node1 ~]# ifconfig docker0
docker0: flags=4099<UP,BROADCAST,MULTICAST> mtu 1500
inet 172.18.41.1 netmask 255.255.255.0 broadcast 172.18.41.255
ether 02:42:07:3e:8a:09 txqueuelen 0 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
验证k8s集群的安装
[root@k8s-master ~]# kubectl run nginx --image=nginx:1.13 --replicas=2
#多等待一段时间，再查看pod状态
[root@k8s-master ~]# kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-6459cd46fd-8lln4 1/1 Running 0 3m27s 172.18.41.2 10.0.0.12
nginx-6459cd46fd-xxt24 1/1 Running 0 3m27s 172.18.96.2 10.0.0.13

[root@k8s-master ~]# kubectl expose deployment nginx --port=80 --target-port=80 --type=NodePort
[root@k8s-master ~]# kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.254.0.1 443/TCP 6h46m
nginx NodePort 10.254.160.83 80:41760/TCP 3s

#打开浏览器访问http://10.0.0.12:41760,能访问就ok了

1.4 修改IP地址、主机名和host解析
10.0.0.11 k8s-master
10.0.0.12 k8s-node-1
10.0.0.13 k8s-node-2
所有节点需要做hosts解析
1.5 master节点安装etcd
yum install etcd -y

vim /etc/etcd/etcd.conf
6行：ETCD_LISTEN_CLIENT_URLS=“http://0.0.0.0:2379”
21行：ETCD_ADVERTISE_CLIENT_URLS=“http://10.0.0.11:2379”

systemctl start etcd.service
systemctl enable etcd.service

etcdctl set testdir/testkey0 0
etcdctl get testdir/testkey0

etcdctl -C http://10.0.0.11:2379 cluster-health
etcd原生支持做集群，
etcd通过http协议启动
1.6 master节点安装kubernetes
yum install kubernetes-master.x86_64 -y

vim /etc/kubernetes/apiserver
8行: KUBE_API_ADDRESS="–insecure-bind-address=0.0.0.0"
11行：KUBE_API_PORT="–port=8080"
14行: KUBELET_PORT="–kubelet-port=10250"
17行：KUBE_ETCD_SERVERS="–etcd-servers=http://10.0.0.11:2379"
23行：KUBE_ADMISSION_CONTROL="–admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"

vim /etc/kubernetes/config
22行：KUBE_MASTER="–master=http://10.0.0.11:8080"

systemctl enable kube-apiserver.service
systemctl restart kube-apiserver.service
systemctl enable kube-controller-manager.service
systemctl restart kube-controller-manager.service
systemctl enable kube-scheduler.service
systemctl restart kube-scheduler.service
检查服务是否安装正常
[root@k8s-master ~]# kubectl get componentstatus
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
controller-manager Healthy ok
etcd-0 Healthy {“health”:“true”}
[k8s日志级别]

1.7 node节点安装kubernetes
yum install kubernetes-node.x86_64 -y

vim /etc/kubernetes/config
22行：KUBE_MASTER="–master=http://10.0.0.11:8080"

vim /etc/kubernetes/kubelet[注意：node节点的IP]
5行：KUBELET_ADDRESS="–address=0.0.0.0"
8行：KUBELET_PORT="–port=10250"
11行：KUBELET_HOSTNAME="–hostname-override=10.0.0.12"
14行：KUBELET_API_SERVER="–api-servers=http://10.0.0.11:8080"

systemctl enable kubelet.service
systemctl restart kubelet.service
systemctl enable kube-proxy.service
systemctl restart kube-proxy.service
在master节点检查
[root@k8s-master ~]# kubectl get nodes
NAME STATUS AGE
10.0.0.12 Ready 6m
10.0.0.13 Ready 3s
1.8 所有节点配置flannel网络
Flannel网络的特点：所有容器组合在一起，形成一个超大的局域网
Flannel三种模式：
Udp 模式：性能较差，配置最简单
Vxlan模式：性能比较好，
Host-gw：性能最好云主机
#所有节点：
yum install flannel -y
sed -i ‘s#http://127.0.0.1:2379#http://10.0.0.11:2379#g’ /etc/sysconfig/flanneld
##master节点：
etcdctl mk /atomic.io/network/config ‘{ “Network”: “172.18.0.0/16”,“Backend”: {“Type”: “vxlan”} }’
[注意：复制的时候有没有特殊符号，有特殊符号的话，启动会报错]
为何不用172.17网段？
至少16位子网掩码，
systemctl enable flanneld.service
systemctl restart flanneld.service
##node节点：
systemctl enable flanneld.service
systemctl restart flanneld.service
systemctl restart docker (没有重启docker的话，docker和flannel不在同一网段)
systemctl restart kubelet.service
systemctl restart kube-proxy.service

Systemd的配置
Nginx
ExecStartPre=nginx -t
ExecStart=nginx 启动之前
ExecStartPost 启动之后
vim /usr/lib/systemd/system/docker.service
#在[Service]区域下增加一行
ExecStartPost=/usr/sbin/iptables -P FORWARD ACCEPT
systemctl daemon-reload
systemctl restart docker
1.9 配置master为镜像仓库
为什么要有一个私有仓库？
最快的速度启动容器
为了安全性，
#master节点
yum install docker -y
若安装失败：
yum clean all
vi /etc/docker/daemon.json
{
“registry-mirrors”: [“https://registry.docker-cn.com”],
“insecure-registries”: [“10.0.0.11:5000”]
}
systemctl enable docker
systemctl start docker
docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry

#node节点
vi /etc/docker/daemon.json
{
“registry-mirrors”: [“https://registry.docker-cn.com”],
“insecure-registries”: [“10.0.0.11:5000”]
}

systemctl restart docker
2. 什么是k8s,k8s有什么功能?
k8s是一个docker集群的管理工具 ,[官方文档：kubernetes.io]

k8s是容器的编排工具，可以实现批量管理容器
2.1 k8s的核心功能
自愈: 重新启动失败的容器，在节点不可用时，替换和重新调度节点上的容器，对用户定义的健康检查不响应的容器会被中止，并且在容器准备好服务之前不会把其向客户端广播。[自我修复]
弹性伸缩: 通过监控容器的cpu的负载值,如果这个平均高于80%,增加容器的数量,如果这个平均低于10%,减少容器的数量

服务的自动发现和负载均衡: 不需要修改您的应用程序来使用不熟悉的服务发现机制，Kubernetes 为容器提供了自己的 IP 地址和一组容器的单个 DNS 名称，并可以在它们之间进行负载均衡。

滚动升级和一键回滚: Kubernetes 逐渐部署对应用程序或其配置的更改，同时监视应用程序运行状况，以确保它不会同时终止所有实例。如果出现问题，Kubernetes会为您恢复更改，利用日益增长的部署解决方案的生态系统。

私密配置文件管理： web容器里面,数据库的账户密码(测试库密码)
2.2 k8s的历史
2013年 docker开源，容器
2014年 docker容器编排工具，立项，谷歌15年容器运维生产经验borg borg-monitor
2015年7月发布kubernetes 1.0, 加入cncf基金会(谷歌公司牵头成立) 孵化
2016年，kubernetes干掉两个对手，docker swarm，mesos marathon 1.2版
2017年 1.5 -1.9
2018年 k8s 从cncf基金会毕业项目1.10 1.11 1.12
2019年： 1.13, 1.14 ，1.15,1.16 1.17
cncf :cloud native compute foundation 孵化器
kubernetes （k8s）: 希腊语舵手，领航者容器编排领域，
谷歌15年容器使用经验，borg容器管理平台，使用golang重构[代码重构：重新写代码]borg，kubernetes
2.3 k8s的应用场景
k8s最适合跑微服务项目!
微服务：软件开发架构，微小的服务，[多套架构]

每个公司有一个独立的域名，拆了多少个功能就有多少个集群，
消息队列实现数据库的回滚功能，eg:RabbitMQ、kafka、redis、
微服务的好处：1)支持更高的并发
				2)业务更加的健壮
				3)更新迭代更快
mvc架构：(model viewer controller)[一套架构]

数据库：事务

K8s更适合微服务，为什么？
MVC维护一套集群，微服务维护上百套集群
开发环境：微服务，测试环境：微服务，预生产环境：微服务，生产环境：微服务
Docker镜像，快速部署，
K8s弹性伸缩：（容器不够加，多了减）
2.4 k8s的安装方式
yum安装 1.5 最容易安装成功，最适合学习的
源码编译安装—难度最大可以安装最新版(go语言安装的，不推荐)
二进制安装—步骤繁琐可以安装最新版 shell,ansible,saltstack(官方已经编辑好二进制包，只需要配置[但是配置繁琐]，)[生产中最适合使用]
kubeadm 安装最容易, 网络(早期集群所需的镜像，必须访问谷歌的镜像仓库，) 可以安装最新版(容易使用) [生产中最适合使用]
minikube 适合开发人员体验k8s, 网络(仅限于单机)
3. k8s常用的资源
3.1 创建pod资源
创建pod流程:
yaml文件 kubectl create -f .
api-server 写入到etcd
api-server 调用scheduler
api-server调用kubeletpod配置文件
删除pod流程:
kubectl delete pod nginx
api-server修改etcd中改pod的状态
api-server调用kubelet 停止并删除容器
api-server 删除etcd的pod记录
pod是最小资源单位.[pod是用来启动容器]
任何的一个k8s资源都可以由yml清单文件来定义[任何资源都可以用yml文件创建]
k8s yaml的主要组成[yml文件注意缩进]
apiVersion: v1 api版本
kind: pod 资源类型
metadata: 属性
spec: 详细
步骤：(使用低版本的nginx镜像，是方便后面的滚动升级)
Master节点：
⑴ #下载nginx镜像
wget http://192.168.15.253/docker_images/docker_nginx1.13.tar.gz
⑵ #导入nginx镜像
docker load -i docker_nginx1.13.tar.gz
⑶ #给nginx镜像打标签
docker tag docker.io/nginx:1.13 10.0.0.11:5000/nginx:1.13
⑷ 上传镜像
docker push 10.0.0.11:5000/nginx:1.13
⑸ 创建pod资源
#创建目录
mkdir k8s_yaml
cd k8s_yaml
mkdir pod
cd pod
vim k8s_pod.yml
apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: web
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
kubectl create -f k8s_pod.yml
#创建pod类型的资源
kubectl get pod
注意：pod资源名字不能相同
#查看pod类型的资源的状态
kubectl describe pod nginx
51m 51m 1 {default-scheduler } Normal Scheduled Successfully assigned nginx to 10.0.0.13
51m 45m 6 {kubelet 10.0.0.13} Warning FailedSync Error syncing pod, skipping: failed to “StartContainer” for “POD” with ErrImagePull: “image pull failed for registry.access.redhat.com/rhel7/pod-infrastructure:latest, this may be because there are no credentials on this request. details: (open /etc/docker/certs.d/registry.access.redhat.com/redhat-ca.crt: no such file or directory)”

51m 43m 33 {kubelet 10.0.0.13} Warning FailedSync Error syncing pod, skipping: failed to “StartContainer” for “POD” with ImagePullBackOff: “Back-off pulling image “registry.access.redhat.com/rhel7/pod-infrastructure:latest””
报错：

解决方法：解决软链接失效的问题，修改仓库为私有镜像
#node节点:
vim /etc/kubernetes/kubelet
KUBELET_POD_INFRA_CONTAINER="–pod-infra-container-image=10.0.0.11:5000/pod-infrastructure:latest"
systemctl restart kubelet.service
pod资源:至少由两个容器组成,pod基础容器和业务容器组成(最多1+4)
pod逻辑单元
创建一个pod资源，启动了两个容器(一个基础容器pod，一个业务容器nginx+定制化操作)
K8s为什么要给业务容器绑定一个基础容器pod？
普通容器nginx不能实现k8s的高级功能，把基础容器和业务容器捆绑在一块，看作是一个，共同实现k8s的高级功能
Pod资源至少有两个容器组成，一个基础容器pod，一个业务容器
pod配置文件2：
apiVersion: v1
kind: Pod
metadata:
name: test
labels:
app: web
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
- name: alpine
image: 10.0.0.11:5000/alpine:latest
command: [“sleep”,“1000”]
pod配置文件containers写了3个业务容器4个容器
k8s指定容器的初始命令args:
command :
dockerfile指定容器的初始命令CMD
ENTRYPOINT
imagePullPolicy:Always总是更新镜像Never从不更新
工fNotPresent如果本地没有,就去pull
spec:
containers:
image: 10.0.0.11:5000/wordpress :latestimagePullPolicy: Always
name : myweb
ports:

containerPort: 80
nodeName: 10.0.0.13

3.2 ReplicationController资源
rc:保证指定数量的pod始终存活,rc通过标签选择器来关联pod(管理pod数量)
几个副本数，启动几个pod
k8s资源的常见操作:
kubectl create -f xxx.yaml
kubectl get pod|rc
kubectl describe pod nginx
kubectl delete pod nginx 或者kubectl delete -f xxx.yaml kubectl edit pod nginx
创建一个rc
vi k8s_rc.yml
apiVersion: v1
kind: ReplicationController
metadata:
name: nginx
spec:
replicas: 5 #副本5
selector:
app: myweb
template: #模板
metadata:
labels:
app: myweb
spec:
containers:
- name: myweb
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
rc的滚动升级
新建一个nginx-rc1.15.yaml

升级
kubectl rolling-update nginx -f nginx-rc1.15.yaml --update-period=10s
回滚
kubectl rolling-update nginx2 -f nginx-rc.yaml --update-period=1s
3.3 service资源（访问问题）
[创建service资源，自动分配vip，虚拟IP ping不通，虚拟IP，所有的cube-proxy上都有，一个pod死了，提出service资源]
提供负载均衡的资源，实现服务的自动发现和负载均衡，service的负载均衡是虚拟的，有虚拟的IP地址(cluster ip)[随机生成]， service帮助pod暴露端口
创建一个service
apiVersion: v1
kind: Service #简称svc
metadata:
name: myweb
spec:
type: NodePort #默认ClusterIP
ports:
- port: 80 #clusterIP
nodePort: 30000 #node port
targetPort: 80 #pod port
selector:
app: myweb2
#调整rc的副本书
kubectl scale rc nginx --replicas=2
#进入pod容器
kubectl exec -it pod_name /bin/bash
修改nodePort范围
vim /etc/kubernetes/apiserver
KUBE_API_ARGS="–service-node-port-range=3000-50000"
命令行创建service资源(非交互式创建)
kubectl expose rc nginx --type=NodePort --port=80
区别：命令行创建service，vip不能固定，宿主机端口都是随机分配的，
service默认使用iptables来实现负载均衡, k8s 1.8新版本中推荐使用lvs(四层负载均衡传输层tcp,udp)
[iptables: 四表五链

{四表：
filter(实现数据包的过滤，把不安全的数据包拦截，)
nat(数据包地址转换)
raw(追踪,Linux追踪命令：traceroute nginx.org #追踪nginx.org)
mangle(数据包修改，数据包经过一个路由，-1，最后减完数据包丢弃，mangle负责修复这些数据)；
五链：
数据包–prerouting链(判断是否是找后面)(不走input就去forWord转发)—input（过滤）–内核（判断属于哪个进程）–对应进程收到–返回内核–output–postrouting

Input(进来的数据包应用此规则链中的规则)
Preprouting(对数据包作路由选择前应用此链中的规则)
Forword(转发数据包时应用此规则链中的规则)
Postrouting(对数据包作路由选择后应用此链中的规则)
output(外出的数据包应用此规则链中的规则)}]

3.4 deployment资源(rc滚动升级，标签选择器变了，svc关联不上，服务中断)
创建deployment流程
yaml文件kubectl create -f .
api-server写入到etcd
controller-manager创建rs
controller-manager申请创建pod

有rc在滚动升级之后,会造成服务访问中断,于是k8s引入了deployment资源
创建deployment
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx
spec:
replicas: 3
strategy:
rollingUpdate:
maxSurge: 1 #多启动几个容器
maxUnavailable: 1 #最大不可用的pod数量
type: RollingUpdate
minReadySeconds: 30 #升级间隔30秒，超过30秒后，升级好了，
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
deployment升级和回滚
deployment滚动升级服务不中断
deployment不依赖配置文件
修改配置文件立即生效

命令行创建deployment
kubectl run nginx --image=10.0.0.11:5000/nginx:1.13 --replicas=3 –record
命令行升级版本
kubectl set image deployment nginx nginx=10.0.0.11:5000/nginx:1.15
查看deployment所有历史版本
kubectl rollout history deployment nginx
deployment回滚到上一个版本
kubectl rollout undo deployment nginx
deployment回滚到指定版本
kubectl rollout undo deployment nginx --to-revision=2
3.5 tomcat+mysql练习
#node节点：
#下载mysql和Tomcat镜像文件
[root@k8s-node02 ~]# wget http://192.168.15.253/docker_images/docker-mysql-5.7.tar.gz
[root@k8s-node02 ~]# wget http://192.168.15.253/docker_images/tomcat-app-v2.tar.gz
#导入mysql和Tomcat镜像
[root@k8s-node02 ~]# docker load -i docker-mysql-5.7.tar.gz
[root@k8s-node02 ~]# docker load -i tomcat-app-v2.tar.gz
#打标签推送mysql和Tomcat镜像到私有仓库
[root@k8s-node02 ~]# docker tag docker.io/kubeguide/tomcat-app:v2
[root@k8s-node02 ~]# docker tag docker.io/mysql:5.7 10.0.0.11:5000/mysql:5.7
[root@k8s-node02 ~]# docker push 10.0.0.11:5000/tomcat-app:v2
[root@k8s-node02 ~]# docker push 10.0.0.11:5000/mysql:5.7
#master节点：
#查看镜像文件是否推送成功
[root@k8s-master k8s_yaml]# ls /opt/myregistry/docker/registry/v2/repositories/
alpine mysql nginx pod-infrastructure tomcat-app
#上传mysql和Tomcat的yaml文件并解压
[root@k8s-master k8s_yaml]# ls
pod rc svc tomcat_demo.zip
[root@k8s-master k8s_yaml]# unzip tomcat_demo.zip
[root@k8s-master k8s_yaml]# ls
pod rc svc tomcat_demo tomcat_demo.zip
[root@k8s-master k8s_yaml]# cd tomcat_demo/
[root@k8s-master tomcat_demo]# rm -rf pv
[root@k8s-master tomcat_demo]# ls
mysql-rc.yml mysql-svc.yml tomcat-rc.yml tomcat-svc.yml
[root@k8s-master tomcat_demo]# kubectl create -f mysql-rc.yml
[root@k8s-master tomcat_demo]# kubectl create -f mysql-svc.yml
[root@k8s-master tomcat_demo]# kubectl get svc
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes 10.254.0.1 443/TCP 1d
mysql 10.254.215.126 3306/TCP 9s
myweb 10.254.165.253 80:30000/TCP 5h
[root@k8s-master tomcat_demo]# vim tomcat-rc.yml
- name: MYSQL_SERVICE_HOST
value: ‘10.254.215.126’
[root@k8s-master tomcat_demo]# kubectl create -f tomcat-rc.yml
[root@k8s-master tomcat_demo]# kubectl create -f tomcat-svc.yml
[root@k8s-master tomcat_demo]# kubectl get pod
NAME READY STATUS RESTARTS AGE
mysql-m2qws 1/1 Running 0 2m
myweb-x2jl6 1/1 Running 0 1m
nginx 1/1 Running 1 22h
nginx2-j0xw7 1/1 Running 1 18h
nginx2-m5jzg 1/1 Running 0 18h
nginx2-w4gzl 1/1 Running 0 18h
test 2/2 Running 34 21h
在k8s中容器之间相互访问,通过VIP地址!
浏览器访问10.0.0.1:30008/demo

k8s的常用资源(二进制)
4.1 k8s资源的常见操作：
kubectl get
kubectl create
kubectl delete
kubectl edit
kubectl describe
kubectl path “ixxx: {“xxx” :test;xcxc:[3}”
kubectl explain #查看帮助
4.2 pod资源
pod资源至少由两个容器组成,一个基础容器pod+业务容器
动态pod,这个pod的yaml文件从etcd获取的yaml
静态pod,kubelet本地目录读取yaml文件,启动的pod
mkdir /etc/kubernetes/manifest
vim /usr/lib/systemd/system/kubelet.service
#启动参数增加一行
–pod-manifest-path /etc/kubernetes/manifest \

systemctl daemon-reload
systemctl restart kubelet.service

cd /etc/kubernetes/manifest/

vi k8s_pod.yaml
iapiVersion: v1
kind: Pod
metadata:
name: static-pod
spec:
containers:
- name: nginx
image: nginx:1.13
ports:
- containerPort: 80

#验证
[root@k8s-master ~]# kubectl get pod

4.3 污点和容忍度（二进制）
K8s里面为什么需要有污点和容忍度，它的适用范围是什么？
污点taints是定义在节点之上的键值型属性数据，用于让节点拒绝将Pod调度运行于其上，除非该Pod对象具有接纳节点污点的容忍度。而容忍度tolerations是定义在 Pod对象上的键值型属性数据，用于配置其可容忍的节点污点，而且调度器仅能将Pod对象调度至其能够容忍该节点污点的节点之上，如图所示

节点选择器nodeSelector和节点亲和性nodeAffinity两种调度方式都是通过在 Pod对象上添加标签选择器来完成对特定类型节点标签的匹配，它们实现的是由Pod选择节点的机制。而污点和容忍度则是通过向节点添加污点信息来控制Pod对象的调度结果，从而赋予了节点控制何种Pod对象能够调度于其上的主控权。简单来说，节点亲和性使得Pod对象被吸引到一类特定的节点，而污点则相反，它提供了让节点排斥特定Pod对象的能力。
Kubernetes使用PodToleratesNodeTaints预选策略和 TaintTolerationPriority优选函数来完成此种类型的高级调度机制。
污点: 给node节点加污点
污点是node节点的属性，通过打标签实现，[如何加标签？kubectl label nodes 10.0.0.12 node-role.kubernetes.io/node=；删除标签：kubectl label nodes 10.0.0.12 node-role.kubernetes.io/node-]

污点的类型:
NoSchedule：[不要再往该node节点调度，不会影响已有的pod]
PreferNoSchedule：[备用，尽量不要调度]
NoExecute：[清场，驱逐，]
kubectl scale deployment nginx --replicas=n
打污点：kubectl taint node 10.0.0.12 disk=ssd: NoSchedule
取消污点:kubectl taint node 10.0.0.12 disk-

#添加污点的例子
kubectl taint node 10.0.0.14 node-role.kubernetes.io=master:NoExecute
#检查
[root@k8s-master ~]# kubectl describe nodes 10.0.0.14|grep -i taint
Taints: node-role.kubernetes.io=master:NoExecute
容忍度
#添加在pod的spec下
tolerations:

key: “node-role.kubernetes.io” [#与标签相同]
operator: “Exists”
value: “master”
effect: “NoExecute”

4.4 secrets资源
[存储密码(bash64加密)和秘钥、ssh证书，]
方式1:
kubectl create secret docker-registry harbor-secret --namespace=default --docker-username=admin --docker-password=a123456 --docker-server=blog.oldqiang.com

vi k8s_sa_harbor.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
name: docker-image
namespace: default
imagePullSecrets:

name: harbor-secret

vi k8s_pod.yaml
iapiVersion: v1
kind: Pod
metadata:
name: static-pod
spec:
serviceAccount: docker-image
containers:
- name: nginx
image: blog.oldqiang.com/oldboy/nginx:1.13
ports:
- containerPort: 80
方法二(常用)
kubectl create secret docker-registry regcred --docker-server=blog.oldqiang.com --docker-username=admin --docker-password=a123456 --docker-email=296917342@qq.com

#验证
[root@k8s-master ~]# kubectl get secrets
NAME TYPE DATA AGE
default-token-vgc4l kubernetes.io/service-account-token 3 2d19h
regcred kubernetes.io/dockerconfigjson 1 114s

[root@k8s-master ~]# cat k8s_pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: static-pod
spec:
nodeName: 10.0.0.12
imagePullSecrets:
- name: regcred
containers:
- name: nginx
image: blog.oldqiang.com/oldboy/nginx:1.13
ports:
- containerPort: 80
[部署harbor：

wget–tar xf–证书秘钥–vim harbor.yml–域名+证书私钥路径+密码–安.装docker compose–执行./ install.sh–注意执行路径（harbor目录下）–over–登录

局部资源（同namespace）

配置了secret（加密密钥对）、不需要登录仓库就可以下拉镜像]
4.5 configmap资源
存放帮助挂载管理配置文件—此时出现了一个问题（挂载之后，原文件被隐藏）–使用一个资源解决该问题（initcontainer）
vi /opt/81.conf
server {
listen 81;
server_name localhost;
root /html;
index index.html index.htm;
location / {
}
}

kubectl create configmap 81.conf --from-file=/opt/81.conf
#验证
kubectl get cm

vi k8s_deploy.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx
spec:
replicas: 2
template:
metadata:
labels:
app: nginx
spec:
volumes:
- name: nginx-config
configMap:
name: 81.conf
items:
- key: 81.conf
path: 81.conf
containers:
- name: nginx
image: nginx:1.13
volumeMounts:
- name: nginx-config
mountPath: /etc/nginx/conf.d
ports:
- containerPort: 80
name: port1
- containerPort: 81
name: port2
4.6 initcontainter
kubernetes的初始化容器initcontains
initContainers是一种专用的容器，在应用程序容器启动之前运行，可以包括一些应用程序镜像中不存在的实用工具和安装脚本，可以完成应用的必要数据初始化等工作。总的来说就是在正式的容器启动之前做一些准备工作的。
例如一个应用容器挂载的volume目录需要一些必不可少的初始化文件，不加init容器的时候直接挂载volume应用容器的那个目录是空的（因为docker挂载一个volume时，会用volume的内容覆盖容器内挂载目录的内容），这就需要让init容器也跟应用容器挂载同一个volume目录，将初始化文件放进去，然后在启动应用容器就能正常看到那些初始化文件了，我也正是遇到了这样的问题，才来研究和学习init容器的。
1、一个pod可以运行多个容器，同样的一个pod也可能有一个或多个先于应用容器启动的 Init 容器，每个容器启动失败后都会根据你配置的重启策略进行重启，直到运行成功。Init 容器与普通的基本一样，主要区别如下：
• Init 容器总是运行到成功运行完为止。
• 前面的 Init 容器必须已经运行完成，才会开始运行下一个init容器，而应用程序容器时并行运行的。
2、因为 Init 容器具有与应用程序容器分离的单独镜像，所以使用他们可以具有如下优势：
• 它们可以包含并运行实用工具，但是出于安全考虑，是不建议在应用程序容器镜像中包含这些实用工具的。
• 它们可以包含使用工具和定制化代码来安装，但是不能出现在应用程序镜像中。例如，创建镜像没必要 FROM 另一个镜像，只需要在安装过程中使用类似 sed、 awk、 python 或 dig 这样的工具。
• 应用程序镜像可以分离出创建和部署的角色，而没有必要联合它们构建一个单独的镜像。
• Init 容器使用 Linux Namespace，所以相对应用程序容器来说具有不同的文件系统视图。因此，它们能够具有访问 Secret 的权限，而应用程序容器则不能。
• 它们必须在应用程序容器启动之前运行完成，而应用程序容器是并行运行的，所以 Init 容器能够提供了一种简单的阻塞或延迟应用容器的启动的方法，直到满足了一组先决条件。
3、下面是一些如何使用 Init 容器的思路：
• 等待一个 Service 创建完成，通过类似如下 shell 命令：
• for i in {1…100}; do sleep 1; if dig myservice; then exit 0; fi; exit 1
• 将 Pod 注册到远程服务器，通过在命令中调用 API，类似如下：
• curl -X POST http:// $MANAGEMENT_SERVICE_HOST:$ MANAGEMENT_SERVICE_PORT/register -d ‘instance= $KaTeX parse error: Expected 'EOF', got '&' at position 13: (<POD_NAME>)&̲ip=$ (<POD_IP>)’
• 在启动应用容器之前等一段时间，使用类似 sleep 60 的命令。
• 克隆 Git 仓库到数据卷。
• 将配置值放到配置文件中，运行模板工具为主应用容器动态地生成配置文件。例如，在配置文件中存放 POD_IP 值，并使用 Jinja 生成主应用配置文件。
4、 init容器使用示例，
Kubernetes 1.6 版本后使用新语法，把 Init 容器的声明移到 spec 中，只需要添加 initContainers 即可，下面列一个具有 2 个 Init 容器的简单 Pod。第一个等待 myservice 启动，第二个等待 mydb 启动。一旦这两个 Service 都启动完成，Pod 将开始启动。
apiVersion: v1
kind: Pod
metadata:
name: myapp-pod
labels:
app: myapp
spec:
containers:

name: myapp-container
image: busybox
command: [‘sh’, ‘-c’, ‘echo The app is running! && sleep 3600’]
initContainers:
name: init-myservice
image: busybox
command: [‘sh’, ‘-c’, ‘until nslookup myservice; do echo waiting for myservice; sleep 2; done;’]
name: init-mydb
image: busybox
command: [‘sh’, ‘-c’, ‘until nslookup mydb; do echo waiting for mydb; sleep 2; done;’]
下面的 yaml 文件展示了 mydb 和 myservice 两个 Service：
kind: Service
apiVersion: v1
metadata:
name: myservice
spec:
ports:
- protocol: TCP
  port: 80
  targetPort: 9376

kind: Service
apiVersion: v1
metadata:
name: mydb
spec:
ports:
- protocol: TCP
port: 80
targetPort: 9377
这个 Pod 可以使用下面的命令进行启动和调试
$ kubectl create -f myapp.yaml
pod “myapp-pod” created
$ kubectl get -f myapp.yaml
NAME READY STATUS RESTARTS AGE
myapp-pod 0/1 Init:0/2 0 6m
$ kubectl describe -f myapp.yaml
Name: myapp-pod
Namespace: default
[…]
Labels: app=myapp
Status: Pending
[…]
Init Containers:
init-myservice:
[…]
State: Running
[…]
init-mydb:
[…]
State: Waiting
Reason: PodInitializing
Ready: False
[…]
Containers:
myapp-container:
[…]
State: Waiting
Reason: PodInitializing
Ready: False
[…]
Events:
FirstSeen LastSeen Count From SubObjectPath Type Reason Message

16s 16s 1 {default-scheduler } Normal Scheduled Successfully assigned myapp-pod to 172.17.4.201
16s 16s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulling pulling image “busybox”
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulled Successfully pulled image “busybox”
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Created Created container with docker id 5ced34a04634; Security:[seccomp=unconfined]
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Started Started container with docker id 5ced34a04634
$ kubectl logs myapp-pod -c init-myservice # Inspect the first init container
$ kubectl logs myapp-pod -c init-mydb # Inspect the second init container

一旦我们启动了 mydb 和 myservice 这两个 Service，我们能够看到 Init 容器完成，并且 myapp-pod 被创建：
$ kubectl create -f services.yaml
service “myservice” created
service “mydb” created
$ kubectl get -f myapp.yaml
NAME READY STATUS RESTARTS AGE
myapp-pod 1/1 Running 0 9m
在 Pod 上使用 activeDeadlineSeconds，在容器上使用 livenessProbe，这样能够避免 Init 容器一直失败，这就为 Init 容器活跃设置了一个期限。在 Pod 中的每个 app 和 Init 容器的名称必须唯一，与任何其它容器共享同一个名称，会在验证时抛出错误。
在 Pod 启动过程中，Init 容器会按顺序在网络和数据卷初始化之后启动。每个容器必须在下一个容器启动之前成功退出。如果由于运行时或失败退出，导致容器启动失败，它会根据 Pod 的 restartPolicy 指定的策略进行重试，在所有的 Init 容器没有成功之前，Pod 将不会变成 Ready 状态，如果 Pod 重启，所有 Init 容器必须重新执行。
因为 Init 容器可能会被重启、重试或者重新执行，所以 Init 容器的代码应该是幂等的（即任意多次执行所产生的影响与一次执行的影响相同）。特别地，被写到 EmptyDirs 中文件的代码，应该对输出文件可能已经存在做好准备。
5、Pod 能够重启，会导致 Init 容器重新执行，重启主要有如下几个原因：
• 用户更新 PodSpec 导致 Init 容器镜像发生改变。更改 Init 容器的 image 字段，等价于重启该 Pod，应用容器镜像的变更只会重启应用容器。
• Pod 基础设施容器被重启。这不多见，但某些具有 root 权限可访问 Node 的人可能会这样做。
• 当 restartPolicy 设置为 Always，Pod 中所有容器会终止，强制重启，由于垃圾收集导致 Init 容器完成的记录丢失。
5. k8s常用服务（二进制）
5.1 部署dns服务
Dns服务的作用：将SVC的名字解析成clusterIP[k8s中]
RBAC：role base access controller [每启动一个RBAC，pod里就会有个用户]
role [局部角色role 、全剧角色clusterrole,]
(用户sa ServiceAccount
角色绑定：ClusterRoleBinding)
vi coredns.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
name: coredns
namespace: kube-system
labels:
kubernetes.io/cluster-service: “true”
addonmanager.kubernetes.io/mode: Reconcile

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
labels:
kubernetes.io/bootstrapping: rbac-defaults
addonmanager.kubernetes.io/mode: Reconcile
name: system:coredns
rules:

apiGroups:
- “”
  resources:
- endpoints
- services
- pods
- namespaces
  verbs:
- list
- watch
apiGroups:
- “”
  resources:
- nodes
  verbs:
- get

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
annotations:
rbac.authorization.kubernetes.io/autoupdate: “true”
labels:
kubernetes.io/bootstrapping: rbac-defaults
addonmanager.kubernetes.io/mode: EnsureExists
name: system:coredns
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:coredns
subjects:

kind: ServiceAccount
name: coredns
namespace: kube-system

apiVersion: v1
kind: ConfigMap
metadata:
name: coredns
namespace: kube-system
labels:
addonmanager.kubernetes.io/mode: EnsureExists
data:
Corefile: |
.:53 {
errors
health
kubernetes cluster.local in-addr.arpa ip6.arpa {
pods insecure
upstream
fallthrough in-addr.arpa ip6.arpa
ttl 30
}
prometheus :9153
forward . /etc/resolv.conf
cache 30
loop
reload
loadbalance
}
—#普罗米修斯自带了export
apiVersion: apps/v1
kind: Deployment
metadata:
name: coredns
namespace: kube-system
labels:
k8s-app: kube-dns
kubernetes.io/cluster-service: “true”
addonmanager.kubernetes.io/mode: Reconcile
kubernetes.io/name: “CoreDNS”
spec:

replicas: not specified here:

strategy:#滚动升级策略
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1
selector:
matchLabels:
k8s-app: kube-dns
template:#pod模板
metadata:
labels:
k8s-app: kube-dns
annotations:
seccomp.security.alpha.kubernetes.io/pod: ‘docker/default’
spec:
priorityClassName: system-cluster-critical
serviceAccountName: coredns
tolerations:#容忍度
- key: “CriticalAddonsOnly”
operator: “Exists”
nodeSelector:#适配标签
beta.kubernetes.io/os: linux
nodeName: 10.0.0.13
containers:
- name: coredns
image: coredns/coredns:1.3.1
imagePullPolicy: IfNotPresent #镜像策略：如果本地有就不去pull
resources:
limits:
memory: 100Mi
requests:#与调度有关
cpu: 100m
memory: 70Mi
args: [ “-conf”, “/etc/coredns/Corefile” ]#指定启动参数
volumeMounts:
- name: config-volume
mountPath: /etc/coredns
readOnly: true
- name: tmp
mountPath: /tmp
ports:
- containerPort: 53
name: dns
protocol: UDP
- containerPort: 53
name: dns-tcp
protocol: TCP
- containerPort: 9153
name: metrics
protocol: TCP
livenessProbe:#健康检查
httpGet:
path: /health
port: 8080
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
successThreshold: 1
failureThreshold: 5
readinessProbe:
httpGet:
path: /health
port: 8080
scheme: HTTP
securityContext:
allowPrivilegeEscalation: false
capabilities:
add:
- NET_BIND_SERVICE
drop:
- all
readOnlyRootFilesystem: true
dnsPolicy: Default
volumes:
- name: tmp
emptyDir: {}
- name: config-volume
configMap:
name: coredns
items:
- key: Corefile
path: Corefile

apiVersion: v1
kind: Service
metadata:
name: kube-dns
namespace: kube-system
annotations:
prometheus.io/port: “9153”
prometheus.io/scrape: “true”
labels:
k8s-app: kube-dns
kubernetes.io/cluster-service: “true”
addonmanager.kubernetes.io/mode: Reconcile
kubernetes.io/name: “CoreDNS”
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
name: metrics
port: 9153
protocol: TCP

#测试
yum install bind-utils.x86_64 -y
dig @172.18.77.6 kubernetes.default.svc.cluster.local
dig @：指定dns
5.2 部署dashboard服务
认证，exec，增加一些资源类型
[root@k8s-node1 ~]# wget http://192.168.15.253/k8s-tools/docker_k8s_kubernetes-dashboard.tar.gz
[root@k8s-node1 ~]# docker load -i docker_k8s_kubernetes-dashboard.tar.gz
[root@k8s-master k8s_yaml]# cd dashboard/
[root@k8s-master dashboard]# vim dashboard.yaml
[root@k8s-master dashboard]# kubectl create -f dashboard.yaml
[root@k8s-master dashboard]# kubectl get pod -n kube-system

[root@k8s-master dashboard]# kubectl get svc -n kube-system

[root@k8s-master dashboard]# vim dashboard.yaml
[root@k8s-master dashboard]# kubectl get secrets -n kube-system

浏览器访问：https://10.0.0.12:30005

点击令牌登录，令牌号是token 码，

[root@k8s-master dashboard]# rm -rf rbac.yaml
[root@k8s-master dashboard]# kubectl get clusterrole|grep admin
admin 27h
cluster-admin 27h
system:aggregate-to-admin 27h
system:kubelet-api-admin 27h
[root@k8s-master dashboard]# vim dashboard-rbac.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
labels:
k8s-app: kubernetes-dashboard
addonmanager.kubernetes.io/mode: Reconcile
name: kubernets-admin
namespace: kube-system

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: kubernetes-dashboard-admin
namespace: kube-system
labels:
k8s-app: kubernetes-dashboard
addonmanager.kubernetes.io/mode: Reconcile
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects:

kind: ServiceAccount
name: kubernets-admin
namespace: kube-system
[root@k8s-master dashboard]# kubectl create -f dashboard-rbac.yaml
[root@k8s-master dashboard]# kubectl describe secrets -n kube-system kubernets-admin-token-zqlzg
Name: kubernets-admin-token-zqlzg
Namespace: kube-system
Labels:
Annotations: kubernetes.io/service-account.name: kubernets-admin
kubernetes.io/service-account.uid: aa1107b0-86e0-4342-966a-5e41adbe866d

Type: kubernetes.io/service-account-token

Data

ca.crt: 1354 bytes
namespace: 11 bytes
token: eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJrdWJlcm5ldHMtYWRtaW4tdG9rZW4tenFsemciLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoia3ViZXJuZXRzLWFkbWluIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiYWExMTA3YjAtODZlMC00MzQyLTk2NmEtNWU0MWFkYmU4NjZkIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmt1YmVybmV0cy1hZG1pbiJ9.AOTtRsdjvkonJCECN6gNQtJR4xqmgwgu45-xQ2fZZzku-9TDsN2VQrG92dZB5t8AHcSLpVyhTr2k65kDy6BcWHEoGHN-BHNe-fJqoj0KmWAnOOkoRtsVACEtrQwmXjwHcAblClA8Vrjl_HRJkYNBxeUVzoKsWJOSQeK2_ksQnt-qPzOXgl4kIs6UQfgNrx_O92ZMOwxYNHjO9meMplitacynVzgvW3QoU4JfdUABhg3YZwdhEcrfkeEQtEv_Kx2127NxKPErgY_wnt6lVgRvboVhzBrZObMxhT4DQtmmOSmTJz_ElGIHYpEJeouL9vFar12g-IqdL5E5pbYDlPZYQg
火狐浏览器访问:https:10.0.0.12:30005

有些功能火狐浏览器实现不了，用谷歌浏览器（需要做证书）
[root@k8s-master dashboard]# cd key/
[root@k8s-master key]# ls
dashboard.crt dashboard.csr dashboard.key
[root@k8s-master key]# kubectl delete secret kubernetes-dashboard-certs -n kube-system
[root@k8s-master key]# kubectl create secret generic kubernetes-dashboard-certs --from-file=dashboard.key --from-file=dashboard.crt -n kube-system
[root@k8s-master key]# kubectl get pod -n kube-system -o wide

[root@k8s-master key]# kubectl delete pod -n kube-system
[root@k8s-master key]# kubectl get pod -n kube-system -o wide

用谷歌浏览器登录https://10.0.0.12:30005

在这里我们记不住令牌，我们可以做一个文件，每次登陆用kubeconfig登录;
[root@k8s-master key]# kubectl describe secrets -n kube-system kubernets-admin-token-zqlzg

[root@k8s-master key]# DASH_TOCKEN=‘eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJrdWJlcm5ldHMtYWRtaW4tdG9rZW4tenFsemciLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoia3ViZXJuZXRzLWFkbWluIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiYWExMTA3YjAtODZlMC00MzQyLTk2NmEtNWU0MWFkYmU4NjZkIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmt1YmVybmV0cy1hZG1pbiJ9.AOTtRsdjvkonJCECN6gNQtJR4xqmgwgu45-xQ2fZZzku-9TDsN2VQrG92dZB5t8AHcSLpVyhTr2k65kDy6BcWHEoGHN-BHNe-fJqoj0KmWAnOOkoRtsVACEtrQwmXjwHcAblClA8Vrjl_HRJkYNBxeUVzoKsWJOSQeK2_ksQnt-qPzOXgl4kIs6UQfgNrx_O92ZMOwxYNHjO9meMplitacynVzgvW3QoU4JfdUABhg3YZwdhEcrfkeEQtEv_Kx2127NxKPErgY_wnt6lVgRvboVhzBrZObMxhT4DQtmmOSmTJz_ElGIHYpEJeouL9vFar12g-IqdL5E5pbYDlPZYQg’
[root@k8s-master key]# kubectl config set-context admin --cluster=kubernetes --user=admin --kubeconfig=/root/dashbord-admin.conf
[root@k8s-master key]# kubectl config use-context admin --kubeconfig=/root/dashbord-admin.conf
[root@k8s-master key]# kubectl config set-cluster kubernetes --server=10.0.0.11:6443 --kubeconfig=/root/dashbord-admin.conf
[root@k8s-master key]# kubectl config set-credentials admin --token=$DASH_TOCKEN --kubeconfig=/root/dashbord-admin.conf
[root@k8s-master key]# ls
dashboard.crt dashboard.csr dashboard.key
You have new mail in /var/spool/mail/root
[root@k8s-master key]# cd
[root@k8s-master ~]# ll
total 24
-rw-------. 1 root root 1522 Aug 28 11:27 anaconda-ks.cfg
-rw------- 1 root root 1134 Dec 15 16:15 dashbord-admin.conf
-rw-r–r-- 1 root root 259 Dec 14 15:06 k8s-node.yaml
drwxr-xr-x 10 root root 147 Dec 15 11:26 k8s_yaml
-rw-r–r-- 1 root root 9433 Dec 12 16:42 k8s_yaml.tar.gz
[root@k8s-master ~]# sz dashbord-admin.conf

k8s的网络访问（二进制）
6.1 k8s的映射
endpoint和SVC是通过什么关联的？
endpoint和SVC都属于局部资源，必须写在同一个spacename里面，通过名字相同关联。
#准备数据库
Node2节点(10.0.0.13)
yum install mariadb-server -y
systemctl start mariadb
mysql
mysql>grant all on . to root@’%’ identified by ‘123456’;
master节点
#删除mysql的rc和svc
kubectl delete rc mysql
kubectl delete svc mysql

#创建endpoint和svc
[root@k8s-master yingshe]# cat mysql_endpoint.yaml
apiVersion: v1
kind: Endpoints
metadata:
name: mysql
subsets:

addresses:
- ip: 10.0.0.13
  ports:
- name: mysql
  port: 3306
  protocol: TCP

[root@k8s-master yingshe]# cat mysql_svc.yaml
apiVersion: v1
kind: Service
metadata:
name: mysql
spec:
ports:

name: mysql
port: 3306
protocol: TCP
targetPort: 3306
type: ClusterIP

vim /usr/lib/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Proxy
After=network.target
[Service]
ExecStart=/usr/bin/kube-proxy
–kubeconfig /etc/kubernetes/kube-proxy.kubeconfig
–cluster-cidr 172.18.0.0/16
–hostname-override 10.0.0.12
–proxy-mode ipvs
–logtostderr=false
–v=2
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
systemctl daemon-reload
systemctl restart kube-proxy.service
ipvsadm -L -n

6.3 Ingress（访问权）
Service：实现四层负载均衡 lvs [不能配域名]
Ingress：实现七层负载均衡 nginx[可以配域名]
原理：
启动kube-proxy服务，就会有一个vip，（在iptables规则中有）前提是node节点上安装kube-proxy服务，通过vip把用户的请求抛向后面的pod上，实现负载均衡由于这个是四层负载均衡，转发的次数较多，影响了用户的体验，为了提高用户体验，我们引出了ingress，然而Ingress是启动在容器里面的：ingress-controller(ingress控制器)
ingress控制器的实现方式：[pod 容器使用宿主机的网络]
haproxy
nginx
traefik（公司中常用）

部署ingress-controller（使用Traefik）让容器使用宿主机的IP
Master节点;
[root@k8s-master ~]#cd k8s_yaml/
[root@k8s-master k8s_yaml]#vim k8s_test.yaml
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
name: nginx-ds
labels:
addonmanager.kubernetes.io/mode: Reconcile
spec:
template:
metadata:
labels:
app: nginx-ds
spec:
hostNetwork: true
containers:
- name: my-nginx
image: nginx:1.13
ports:
- containerPort: 80
hostPort: 80
[root@k8s-master k8s_yaml]# kubectl create -f k8s_test.yaml
在node节点上查看：
[root@k8s-node1 ~]# netstat -ntplu
浏览器访问10.0.0.12

部署ingress：

ingress-traefik
Traefik 是一款开源的反向代理与负载均衡工具。它最大的优点是能够与常见的微服务系统直接整合，可以实现自动化动态配置。目前支持 Docker、Swarm、Mesos/Marathon、 Mesos、Kubernetes、Consul、Etcd、Zookeeper、BoltDB、Rest API 等等后端模型。

6.3.1 traefik实战
 创建rbac

apiVersion: v1
kind: ServiceAccount
metadata:
name: traefik-ingress-controller
namespace: kube-system

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: traefik-ingress-controller
rules:

apiGroups:
- “”
  resources:
- services
- endpoints
- secrets
  verbs:
- get
- list
- watch
apiGroups:
- extensions
  resources:
- ingresses
  verbs:
- get
- list
- watch

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: traefik-ingress-controller
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: traefik-ingress-controller
subjects:

kind: ServiceAccount
name: traefik-ingress-controller
namespace: kube-system
直接在集群中创建即可：
$ kubectl create -f rbac.yaml
serviceaccount “traefik-ingress-controller” created
clusterrole.rbac.authorization.k8s.io “traefik-ingress-controller” created
clusterrolebinding.rbac.authorization.k8s.io “traefik-ingress-controller” created
 部署traefik服务
Master节点:
[root@k8s-master k8s_yaml]# cd ingress/
[root@k8s-master ingress]# ls
ingress.yaml rabc.yaml traefik.yaml
[root@k8s-master ingress]# kubectl create -f rabc.yaml
[root@k8s-master ingress]# vim traefik.yaml
kind: DaemonSet
apiVersion: extensions/v1beta1
metadata:
name: traefik-ingress-controller
namespace: kube-system
labels:
k8s-app: traefik-ingress-lb
spec:
selector:
matchLabels:
k8s-app: traefik-ingress-lb
template:
metadata:
labels:
k8s-app: traefik-ingress-lb
name: traefik-ingress-lb
spec:
serviceAccountName: traefik-ingress-controller
terminationGracePeriodSeconds: 60
hostNetwork: true
containers:
- image: traefik:v1.7.2
imagePullPolicy: IfNotPresent
name: traefik-ingress-lb
ports:
- name: http
containerPort: 80
hostPort: 80
- name: admin
containerPort: 8080
hostPort: 8080
args:
- --api
- --kubernetes
- --logLevel=INFO

kind: Service
apiVersion: v1
metadata:
name: traefik-ingress-service
namespace: kube-system
spec:
selector:
k8s-app: traefik-ingress-lb
ports:
- protocol: TCP
port: 80
name: web
- protocol: TCP
port: 8080
name: admin
type: NodePort
node1节点:
[root@k8s-node1 ~]# wget http://192.168.15.253/k8s-tools/docker_k8s_traefik.tar.gz
[root@k8s-node1 ~]# docker load -i docker_k8s_traefik.tar.gz
直接创建上面的资源对象即可：(master节点)
[root@k8s-master ingress]# kubectl create -f traefik.yaml
[root@k8s-master ingress]# kubectl get pod -n kube-system

再回到node1节点上查看端口：
[root@k8s-node1 ~]# netstat -ntupl

浏览器访问10.0.0.12:8080

创建ingress规则：
Master节点：
[root@k8s-master ingress]# cd …/tomcat_demo/
[root@k8s-master tomcat_demo]# cp …/ingress/ingress.yaml .
[root@k8s-master tomcat_demo]# vim ingress.yaml
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: tomcat
annotations:
kubernetes.io/ingress.class: traefik
spec:
rules:

host: tomcat.oldqiang.com
http:
paths:
- backend:
  serviceName: myweb
  servicePort: 8080
  [root@k8s-master tomcat_demo]# kubectl create -f ingress.yaml
  [root@k8s-master tomcat_demo]# kubectl get ingresses

[root@k8s-master tomcat_demo]# kubectl scale rc myweb --replicas=2
[root@k8s-master tomcat_demo]# kubectl get pod

做好本地解析；浏览器访问tomcat.oldqiang.com，

traefik 还提供了一个 web ui 工具，就是上面的 8080 端口对应的服务，为了能够访问到该服务，我们这里将服务设置成的 NodePort：

现在在浏览器中输入 10.0.0.12:8080就可以访问到 traefik 的 dashboard 了：

现在还没有实现负载均衡，
[root@k8s-master tomcat_demo]# cd …/ingress/
[root@k8s-master tomcat_demo]# kubectl delete -f ingress.yaml
[root@k8s-master tomcat_demo]# kubectl create -f ingress.yaml
[root@k8s-master tomcat_demo]# kubectl get ingresses

[root@k8s-master tomcat_demo]# kubectl get pod

[root@k8s-master tomcat_demo]# kubectl exec -it myweb-nlqfg /bin/bash
root@myweb-nlqfg:/usr/local/tomcat# cd webapps/
root@myweb-nlqfg:/usr/local/tomcat/webapps# ls
ROOT demo docs examples host-manager manager
root@myweb-nlqfg:/usr/local/tomcat/webapps# cd demo/
root@myweb-nlqfg:/usr/local/tomcat/webapps/demo# ll
bash: ll: command not found
root@myweb-nlqfg:/usr/local/tomcat/webapps/demo# ls
1.html WEB-INF index.jsp input.html insert.jsp
root@myweb-nlqfg:/usr/local/tomcat/webapps/demo# echo ‘oldboy’ >1.html
然后浏览器访问：http://tomcat.oldqiang.com/demo/1.html

再刷新一遍：

实现了负载均衡；
 创建Ingress 对象
创建一个 ingress 对象
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: traefik-nginx
annotations:
kubernetes.io/ingress.class: traefik
spec:
rules:

host: nginx.oldqiang.com
http:
paths:
- backend:
  serviceName: nginx
  servicePort: 80
  创建 ingress 对象：
  kubectl create -f ingress.yaml
  ingress.extensions “traefik-nginx” created
   测试访问
  第一步，在本地的/etc/hosts里面添加上 nginx.oldqiang.com 与 master 节点外网 IP 的映射关系
  10.0.0.11 nginx.oldqiang.com
  第二步，访问http://nginx.oldqiang.com:30293/

查看traefik dashboard，此时多了一条记录

第三步：优化
#增加一行hostPort: 80
ports:

name: http
containerPort: 80
hostPort: 80
添加以后hostPort: 80，然后更新应用：
$ kubectl apply -f traefik.yaml
这个时候我们在浏览器中直接使用http://nginx.oldqiang.com访问

K8s的附加组件
k8s集群中dns服务的作用,就是将svc的名称解析成对应VIP地址
7.1 dns服务
安装dns服务
1:下载dns_docker镜像包(node2节点10.0.0.13)
wget http://192.168.15.253/docker_images/docker_k8s_dns.tar.gz
2:导入docker_k8s_dns.tar.gz镜像包(node2节点10.0.0.13)
3:创建dns服务
vi skydns-rc.yaml
…
spec:
nodeName: 10.0.0.13
containers:

kubectl create -f skydns.yaml
kubectl create -f skydns-svc.yaml
4:检查
kubectl get all --namespace=kube-system
5:修改所有node节点kubelet的配置文件
vim /etc/kubernetes/kubelet
KUBELET_ARGS="–cluster_dns=10.254.230.254 --cluster_domain=cluster.local"

systemctl restart kubelet
6：修改tomcat-rc.yml
env:
- name: MYSQL_SERVICE_HOST
value: ‘mysql’ #修改前值是VIP

kubectl delete -f .
kubectl create -f .
7：验证

[K8s指定容器的初始命令：
args
command:
Dockerfile指定

								ENTRYPOINT]

7.2 namespace命令空间
namespace做资源隔离(对资源进行分组)，一个业务一个namespace

7.3 健康检查和可用性检查
7.3.1 探针的种类
livenessProbe：健康状态检查(存活探针)，周期性检查服务是否存活，检查结果失败，将重新启动一个容器
readinessProbe：可用性检查(就绪探针)，周期性检查服务是否可用，不可用将从service的endpoints中移除
7.3.2 探针的检测方法
• exec：执行一段命令返回值为0, 非0 [Redis info mysql]

• httpGet：检测某个 http 请求的返回状态码 2xx,3xx正常, 4xx,5xx错误 [web服务]
• tcpSocket：测试某个端口是否能够连接
使用场景：
exec: 没有web界面 Redis mysql
httpget: web界面
7.3.3 liveness探针的exec使用
vi nginx_pod_exec.yaml
iapiVersion: v1
kind: Pod
metadata:
name: exec
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
args:
- /bin/sh
- -c
- touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
livenessProbe:
exec:
command:
- cat
- /tmp/healthy
initialDelaySeconds: 5
periodSeconds: 5
timeoutSeconds: 5
successThreshold: 1
failureThreshold: 1
7.3.4 liveness探针的httpGet使用

vi nginx_pod_httpGet.yaml
iapiVersion: v1
kind: Pod
metadata:
name: httpget
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
livenessProbe:
httpGet:
path: /index.html
port: 80
initialDelaySeconds: 3
periodSeconds: 3
7.3.5 liveness探针的tcpSocket使用
vi nginx_pod_tcpSocket.yaml
iapiVersion: v1
kind: Pod
metadata:
name: tcpSocket
spec:
containers:
- name: nginx
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
args:
- /bin/sh
- -c
- tail -f /etc/hosts
livenessProbe:
tcpSocket:
port: 80
initialDelaySeconds: 10
periodSeconds: 3
7.3.6 readiness探针的httpGet使用
vi nginx-rc-httpGet.yaml
iapiVersion: v1
kind: ReplicationController
metadata:
name: readiness
spec:
replicas: 2
selector:
app: readiness
template:
metadata:
labels:
app: readiness
spec:
containers:
- name: readiness
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
readinessProbe:
httpGet:
path: /qiangge.html
port: 80
initialDelaySeconds: 3
periodSeconds: 3
7.4 dashboard服务
1:上传并导入镜像,打标签
2:创建dashborad的deployment和service
3:访问http://10.0.0.11:8080/ui/
全局资源
局部资源(namespace)
Daemon sets 适合做监控 node-exporter 3个 deployment走调度，配置文件里不需要指定副本数，
Pet sets 宠物应用、有状态应用(pod名字是固定的 01 02 03)
Statsfulset: 数据库的应用，redis elasticsearch mysql
其他：畜生应用、无状态应用(pod后的名字是随机的)
Jobs：任务，[一次性任务 complate]
pod：一直运行
Cronjobs:定时任务
Service：四层负载均衡
Ingress：七层负载均衡
Pvc和pv：密码
secret:密码,密钥
config maps:配置文件
daemonset:不需要指定副本数，不需要scheduler调度，应用场景：刚好一个node节点只需要跑一个服务的应用
deployment:需要指定副本数，需要scheduler调度，随机调动，
7.5 通过apiservicer反向代理访问service
第一种：NodePort类型
type: NodePort
ports:
- port: 80
targetPort: 80
nodePort: 30008

第二种：ClusterIP类型
type: ClusterIP
ports:
- port: 80
targetPort: 80

http://10.0.0.11:8080/api/v1/proxy/namespaces/命令空间/services/service的名字/
#例子:
http://10.0.0.11:8080/api/v1/proxy/namespaces/qiangge/services/wordpress
8. k8s弹性伸缩
弹性伸缩前提条件：需要附加插件heapster监控(heapster,influxdb,grafana)
弹性伸缩规则的名字：HPA （kubectl autoscale）
8.1 使用heapster实现弹性伸缩
Heapster架构：
主服务heapster通过连接api-server获取node节点信息，
1:上传并导入镜像,打标签
ls *.tar.gz
for n in ls *.tar.gz;do docker load -i $n ;done
docker tag docker.io/kubernetes/heapster_grafana:v2.6.0 10.0.0.11:5000/heapster_grafana:v2.6.0
docker tag docker.io/kubernetes/heapster_influxdb:v0.5 10.0.0.11:5000/heapster_influxdb:v0.5
docker tag docker.io/kubernetes/heapster:canary 10.0.0.11:5000/heapster:canary
2:上传配置文件,kubectl create -f .
修改配置文件:
#heapster-controller.yaml
spec:
nodeName: 10.0.0.13
containers:
- name: heapster
image: 10.0.0.11:5000/heapster:canary
imagePullPolicy: IfNotPresent
#influxdb-grafana-controller.yaml
spec:
nodeName: 10.0.0.13
containers:
3:打开dashboard验证

1:修改rc的配置文件
containers:

name: myweb
image: 10.0.0.11:5000/nginx:1.13
ports:
- containerPort: 80
  resources:
  limits:
  cpu: 100m
  requests:
  cpu: 100m
  2:创建弹性伸缩规则
  kubectl autoscale deploy nginx-deployment --max=8 --min=1 --cpu-percent=5
  3:测试
  ab -n 1000000 -c 40 http://10.0.0.12:33218/index.html
  扩容截图:

缩容:

使用kubeadm初始化k8s集群
由于二进制安装的k8s: 步骤繁琐,于是就有大佬用ansibe和saltstack来简化二进制安装流程
ansible 一键自动化安装 https://github.com/easzlab/kubeasz
saltstack 一键自动化安装 https://github.com/unixhot/salt-k8s
kubeadm安装k8s: 需要google官方的docker镜像，需要解决网络问题
9.1 环境要求:
机器名 ip地址 cpu和内存要求
kubernetes-master 10.0.0.15 2c2g(关闭swap)
kubernetes-node1 10.0.0.16 2c2g(关闭swap)
9.2 安装指定版本docker
#所有节点
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo
sed -i ‘s+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+’ /etc/yum.repos.d/docker-ce.repo
yum list docker-ce --showduplicates

#安装指定版本的docker
yum install docker-ce-18.09.7 -y
9.3 安装kubeadm
#所有节点
cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

yum install kubelet-1.15.5-0 kubeadm-1.15.5-0 kubectl-1.15.5-0 -y
systemctl enable kubelet && systemctl start kubelet

9.4 使用kubeadm初始化k8s集群
#所有节点
cat < /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sysctl --system

swapoff -a
vim /etc/fstab

#控制节点
kubeadm init --kubernetes-version=v1.15.0 --image-repository registry.aliyuncs.com/google_containers --pod-network-cidr=10.244.0.0/16 --service-cidr=10.254.0.0/16

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(i d - u) :$ (id -g) $HOME/.kube/config
9.5 给k8s集群加入node节点:

#node节点
kubeadm join 10.0.0.11:6443 --token 47hq6d.uvtn5ymfah6egl53
–discovery-token-ca-cert-hash sha256:ff283c3350b5dfa0ac8c093383416c535485ec18d5cdd6b82273e0d198157605
9.6 为k8s集群配置网络插件

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
#修改网段范围为
kubectl create -f kube-flannel.yml
kubectl get all -n kube-system
kubectl get nodes
9.7 为k8s集群配置dashboard服务
kubeadm安装k8s 1.15部署dashboard
wget https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.1/src/deploy/recommended/kubernetes-dashboard.yaml

vi kubernetes-dashboard.yaml
#修改service类型为NodePort类型
kubectl create -f kubernetes-dashboard.yaml

#解决Google浏览器不能打开kubernetes dashboard方法
mkdir key && cd key
#生成证书
openssl genrsa -out dashboard.key 2048
openssl req -new -out dashboard.csr -key dashboard.key -subj ‘/CN=10.0.0.11’
openssl x509 -req -in dashboard.csr -signkey dashboard.key -out dashboard.crt
#删除原有的证书secret
kubectl delete secret kubernetes-dashboard-certs -n kube-system
#创建新的证书secret
kubectl create secret generic kubernetes-dashboard-certs --from-file=dashboard.key --from-file=dashboard.crt -n kube-system
#查看pod
kubectl get pod -n kube-system
#删除pod，启动新pod生效
kubectl delete pod -n kube-sytem kubernetes-dashboard-7c697b776b-zph98

#编辑文件vim k8s-admin.yaml
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: admin
annotations:
rbac.authorization.kubernetes.io/autoupdate: “true”
roleRef:
kind: ClusterRole
name: cluster-admin
apiGroup: rbac.authorization.k8s.io
subjects:

kind: ServiceAccount
name: admin
namespace: kube-system

apiVersion: v1
kind: ServiceAccount
metadata:
name: admin
namespace: kube-system
labels:
kubernetes.io/cluster-service: “true”
addonmanager.kubernetes.io/mode: Reconcile

kubectl create -f k8s-admin.yaml
kubectl get serviceaccount -n kube-system
kubectl describe serviceaccount admin -n kube-system
kubectl describe secret admin-token-29977 -n kube-system

#保存查看到的token密钥，就是登录dashboard需要的令牌

9.8 使用metric-server实现弹性伸缩
安装metric-server
必须要有dns
Master节点：
#上传k8s_yaml.tar.gz
rz
tar xf k8s_yaml.tar.gz
cd k8s_yaml/
node节点：导入docker_k8s_addon_resizer.tar.gz和docker_k8s_metrics_server.tar.gz镜像
rz
docker load -i docker_k8s_addon_resizer.tar.gz
docker load -i docker_k8s_metrics_server.tar.gz
master节点：
cd k8s_yaml/metrics/
#创建
[root@kubernetes-master metrics]#kubectl create -f .
#查看pod状态;
[root@kubernetes-master metrics]#kubectl get pod -n kube-system

[root@kubernetes-master metrics]# kubectl top node

实现弹性伸缩
[root@kubernetes-master metrics]# cd
[root@kubernetes-master ~]# vim k8s_deploy.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx
spec:
replicas: 3
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
minReadySeconds: 30
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.13
ports:
- containerPort: 80
resources:
limits:
cpu: 100m
requests:
cpu: 100m
在node1节点上导入nginx镜像docker_nginx1.13.tar.gz
[root@kubernetes-node1 ~]# rz
[root@kubernetes-node1 ~]# docker load -i docker_nginx1.13.tar.gz
Master节点：
[root@kubernetes-master ~]# kubectl create -f k8s_deploy.yaml
[root@kubernetes-master ~]# kubectl get pod -o wide

创建弹性伸缩规则：
[root@kubernetes-master ~]# kubectl autoscale deployment nginx --max=10 --min=1 --cpu-percent=10
#查看资源
[root@kubernetes-master ~]# kubectl get all

[root@kubernetes-master ~]# cp k8s_yaml/ingress/ingress.yaml nginx_ingress.yaml
[root@kubernetes-master ~]# vim nginx_ingress.yaml
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: nginx
annotations:
kubernetes.io/ingress.class: traefik
spec:
rules:

host: nginx.oldqiang.com
http:
paths:
- backend:
  serviceName: nginx
  servicePort: 80
  [root@kubernetes-master ~]# kubectl expose deployment nginx --port=80 --target-port=80
  [root@kubernetes-master ~]# kubectl get all

[root@kubernetes-master ~]# kubectl create -f nginx_ingress.yaml
[root@kubernetes-master ~]# kubectl get ingresses

做好本地hosts解析，浏览器访问nginx.oldqiang.com

命令行访问;
[root@kubernetes-master ~]# vim /etc/hosts

[root@kubernetes-master ~]# curl -I http://nginx.oldqiang.com/

弹性伸缩:
浏览器访问10.0.0.15:30005页面，选择容器组发现有三个节点，过了一会就剩一个了
[root@kubernetes-master ~]# kubectl get hpa

压力测试：
[root@kubernetes-master ~]# yum -y install httpd-tools&>/dev/null
[root@kubernetes-master ~]# ab -n 5000000 -c 200 http://nginx.oldqiang.com/
再次访问浏览器我们就会看到效果：

最后查看一下每个pod和node占多少资源：
[root@kubernetes-master ~]# kubectl top pod

[root@kubernetes-master ~]# kubectl top node

五分钟以后会自动把pod撤掉
10. 持久化存储
为什么要做持久化存储？
为了保证数据不丢失
数据持久化类型:
10.1 emptyDir:
emptyDir:临时的空目录，[随着pod的生命周期，删除、创建，保存容器里面需要独自保存的数据]
Deployment pod 3个
emptyDir的使用场景：
存放日志
spec:
nodeName: 10.0.0.13
volumes:
- name: mysql
emptyDir: {}
containers:
- name: wp-mysql
image: 10.0.0.11:5000/mysql:5.7
imagePullPolicy: IfNotPresent
ports:
- containerPort: 3306
volumeMounts:
- mountPath: /var/lib/mysql
name: mysql
10.2 HostPath:[不能跨宿主机做数据共享]
查看帮助：kubctl explain pod.spec
spec:
nodeName: 10.0.0.12
volumes:
- name: mysql
hostPath:
path: /data/wp_mysql
containers:
- name: wp-mysql
image: 10.0.0.11:5000/mysql:5.7
imagePullPolicy: IfNotPresent
ports:
- containerPort: 3306
volumeMounts:
- mountPath: /var/lib/mysql
name: mysql
10.3 Nfs(网络文件共享)
volumes:
- name: mysql
nfs:
path: /data/wp_mysql
server: 10.0.0.11
10.4 pv和pvc:
pv: persistent volume 全局资源(在所有namespace里都能看到),k8s集群
一个PV对接一个存储，(不同的存储设置不同的目录)
存储能力(后端能提供的大小)
pvc: persistent volume claim, 局部资源(属于某一个具体的namespace)
PV提供存储能力-PVC选择适合存储
回收：pvc删除、PV清空
删除：PVC删除、PV也删除
PVC：需要存储能力–只有有适合PV的时候才会绑定，一旦绑定则无法分配给别的PV

10.4.1 创建pv和pvc
上传yaml配置文件,创建pv和pvc
10.4.2 创建mysql-rc,pod模板里使用volume
volumes:
- name: mysql
persistentVolumeClaim:
claimName: tomcat-mysql
10.4.3 验证持久化
验证方法1:删除mysql的pod,数据库不丢
kubectl delete pod mysql-gt054
验证方法2:查看nfs服务端,是否有mysql的数据文件

存储：

块存储块设备(格式化挂载后使用) 硬盘 cinder lvm
文件存储无需格式化挂载就可使用, nfs glusterfs eg:nfs
对象存储有专门的数据库，利用哈希校验值校验后端是否存在，eg:百度网盘、QQ
fatsdfs Swift
存储还分为硬件存储(ras san) 和软件存储(nfs lvm 分布式存储；最终数据还是落在硬盘上，只提供存储功能，)
10.5 分布式存储ceph
[分布式存储和单机存储；
分布式存储介绍：增加副本数添加安全性 ,
Ceph: 支持块存储、文件存储；
Ceph架构：
RADOS：（可靠的、自主的分布式存储）
原理：大文件分割N个4M的文件、然后进行分组、每个组有自己的pgid、然后按组存入OSD中、存几份取决于有几个副本、默认三个副本

object ：即把一个大文件切割成N个4M的小文件；
pgs ：将那些小文件进行分组；
OSD：按组进行存储，默认分成三个副本；
[ceph集群之间使用万兆网络]
一个间隔一段时间添加一个
Osd:–data –日志盘使用固态硬盘作为日志盘
osd: --data -journal
ceph-deploy osd create --filestore --fs-type xfs --data /dev/sdc --journal
data/log storage1
部署ceph:使用ceph-deploy部署(实现块存储)[写时复制：用多少分多少])
10.0.0.14 ceph01
10.0.0.15 ceph02
10.0.0.16 ceph03
#配置免密码登录
Ceph01安装
#ceph01初始化ceph配置文件（创建集群） ceph-deploy new --public-network 10.0.0.0/24 ceph01 ceph02 ceph03
#ceph01安装rpm包
yum install ceph ceph-mon ceph-mgr ceph- radosgw.x86_64 ceph-mds.x86_64 ceph-osd.x86_64 -y
#ceph初始化集群：
ceph-deploy mon create-initial
#ceph管理员用户配置admin用户
ceph-deploy admin ceph01 ceph02 ceph03
#安装并启动ceph-manager
ceph-deploy mgr create ceph01 ceph02 ceph03
#创建osd
ceph-deploy osd create ceph01 --data /dev/sdb
ceph-deploy osd create ceph02 --data /dev/sdb
ceph-deploy osd create ceph03 --data /dev/sdb
#创建pool资源池
ceph osd pool create k8s 128 128
#在资源池里创建块设备rbd
rbd create --size 1024 k8s/tomcat_mysql.img
#如何使用rdb(映射块设备到本地)
rbd feature disable k8s/tomcat_mysql.img object-map fast-diff deep-flatten
rbd map k8s/tomcat_mysql.img
mkfs.xfs /dev/rbd0 #映射成功后格式化硬盘
mount /dev/rbd0 /mnt #挂载
#扩容
rbd resize --size 2048 k8s/tomcat_mysql.img
umount /mnt
xfs_growfs /dev/rbd0
rbd info k8s/tomcat_mysql.img
ceph对接k8s
pod资源对接ceph( https://github.com/kubernetes/examples/tree/master/volumes/rbd)
·rbd类型：
#k8s中node节点上都安装rbd(ceph-common)
上传cpeh文件压缩包并解压
[root@k8s-node01 ~]# wget http://192.168.15.253/ceph_common.tar.gz
[root@k8s-node01 ~]# tar xf ceph_common.tar.gz
安装
[root@k8s-node01 ~]# cd ceph_common/
[root@k8s-node01 ceph_common]# yum -y localinstall *.rpm
#给k8s中所有的node节点发送ceph节点的keyring文件和ceph.conf文件
[root@ceph01 ~]# cd /etc/ceph/
[root@ceph01 ceph]# scp ceph.client.admin.keyring root@10.0.0.12:pwd
[root@ceph01 ceph]# scp ceph.client.admin.keyring root@10.0.0.13:pwd
[root@ceph01 ceph]# scp ceph.conf root@10.0.0.12:pwd
[root@ceph01 ceph]# scp ceph.conf root@10.0.0.12:pwd
#取admin用户的秘钥

grep key /etc/ceph/ceph.client.kube.keyring |awk ‘{printf “%s”, $NF}’|base64

[root@k8s-master ceph]# cat ceph-secret.yaml
apiVersion: v1
kind: Secret
metadata:
name: ceph-secret
namespace: tomcat
type: " kubernetes.io/rbd"
data:
key: QVFCczV0RmZIVG8xSEJBQUxUbm5TSWZaRFl1VDZ2aERGeEZnWXc9PQ==
[root@k8s-master ceph]# kubectl create -f ceph-secret.yaml
#创建rbd
rbd create --size 2048 --image-feature layering k8s/test2.img
[root@k8s-master ceph]# cat test_ceph_pod.yml
apiVersion: v1
kind: Pod
metadata:
name: rbd3
namespace: tomcat
spec:
containers:
- image: 10.0.0.11:5000/nginx:1.13
name: rbd-rw
volumeMounts:
- name: rbdpd
mountPath: /data
volumes:
- name: rbdpd
rbd:
monitors:
- ’ 10.0.0.14:6789’
- ’ 10.0.0.15:6789’
- ’ 10.0.0.16:6789’
pool: k8s
image: test2.img
fsType: ext4
user: admin
secretRef:
name: ceph-secret
查看状态:
[root@k8s-master ceph]# kubectl describe -n tomcat pod rbd
验证:
[root@k8s-master ceph]# kubectl get pod -n tomcat
NAME READY STATUS RESTARTS AGE
mysql-snr00 0/1 Error 0 22h
myweb-g5667 1/1 Running 1 1d
rbd 1/1 Running 0 16m
[root@k8s-master ceph]# kubectl exec -n tomcat -it rbd /bin/bash
root@rbd:/# df -h

		·cephfs对接ceph(文件存储；)

实现文件存储：安装 ceph-matedata-server
实现对象存储：安装ceph-radosgw ]

使用jenkins实现k8s持续更新
ip地址服务内存
10.0.0.11 kube-apiserver 8080 1G
10.0.0.12 kube-apiserver 8080 1G
10.0.0.13 jenkins(tomcat + jdk) 8080 2G
代码仓库使用gitee托管

构建完镜像推送到私有仓库
11.1 安装gitlab并上传代码
#a:安装
wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/gitlab-ce-11.9.11-ce.0.el7.x86_64.rpm
yum localinstall gitlab-ce-11.9.11-ce.0.el7.x86_64.rpm -y
#b:配置
vim /etc/gitlab/gitlab.rb
external_url ‘http://10.0.0.13’
prometheus_monitoring[‘enable’] = false
#c:应用并启动服务
gitlab-ctl reconfigure

#使用浏览器访问http://10.0.0.13,修改root用户密码,创建project

#上传代码到git仓库
cd /srv/
rz -E
unzip xiaoniaofeifei.zip
rm -fr xiaoniaofeifei.zip

git config --global user.name “Administrator”
git config --global user.email “admin@example.com”
git init
git remote add origin http://10.0.0.13/root/xiaoniao.git
git add .
git commit -m “Initial commit”
git push -u origin master
11.2 安装jenkins,并自动构建docker镜像
 1:安装jenkins
cd /opt/
wget http://192.168.12.201/191216/apache-tomcat-8.0.27.tar.gz
wget http://192.168.12.201/191216/jdk-8u102-linux-x64.rpm
wget http://192.168.12.201/191216/jenkin-data.tar.gz
wget http://192.168.12.201/191216/jenkins.war
rpm -ivh jdk-8u102-linux-x64.rpm
mkdir /app -p
tar xf apache-tomcat-8.0.27.tar.gz -C /app
rm -fr /app/apache-tomcat-8.0.27/webapps/*
mv jenkins.war /app/apache-tomcat-8.0.27/webapps/ROOT.war
tar xf jenkin-data.tar.gz -C /root
/app/apache-tomcat-8.0.27/bin/startup.sh
netstat -lntup
 2:访问jenkins
访问http://10.0.0.12:8080/,默认账号密码admin:123456
 3:配置jenkins拉取gitlab代码凭据
a:在jenkins上生成秘钥对
ssh-keygen -t rsa
b:复制公钥粘贴gitlab上

c:jenkins上创建全局凭据

 4:拉取代码测试

 5:编写dockerfile并测试
#vim dockerfile
FROM 10.0.0.11:5000/nginx:1.13
add . /usr/share/nginx/html
添加docker build构建时不add的文件
vim .dockerignore dockerfile

docker build -t xiaoniao:v1 . docker run -d -p 88:80 xiaoniao:v1
打开浏览器测试访问xiaoniaofeifei的项目
 6:上传dockerfile和.dockerignore到私有仓库
git add docker .dockerignore
git commit -m “fisrt commit”
git push -u origin master
 7:点击jenkins立即构建,自动构建docker镜像并上传到私有仓库
修改jenkins 工程配置

docker build -t 10.0.0.11:5000/test:v $BUILD_ID . docker push 10.0.0.11:5000/test:v$ BUILD_ID
7.3 jenkins自动部署应用到k8s
kubectl -s 10.0.0.11:8080 get nodes

if [ -f /tmp/xiaoniao.lock ];then
docker build -t 10.0.0.11:5000/xiaoniao:v $BUILD_ID . docker push 10.0.0.11:5000/xiaoniao:v$ BUILD_ID
kubectl -s 10.0.0.11:8080 set image -n xiaoniao deploy xiaoniao xiaoniao=10.0.0.11:5000/xiaoniao:v $KaTeX parse error: Undefined control sequence: \d at position 85: …p -oP '(?<=80:)\̲d̲+'` echo "你…$ port"
echo “更新成功”
else
docker build -t 10.0.0.11:5000/xiaoniao:v $BUILD_ID . docker push 10.0.0.11:5000/xiaoniao:v$ BUILD_ID
kubectl -s 10.0.0.11:8080 create namespace xiaoniao
kubectl -s 10.0.0.11:8080 run xiaoniao -n xiaoniao --image=10.0.0.11:5000/xiaoniao:v $KaTeX parse error: Undefined control sequence: \d at position 205: …p -oP '(?<=80:)\̲d̲+'` echo "你…$ port"
echo “发布成功”
touch /tmp/xiaoniao.lock
chattr +i /tmp/xiaoniao.lock
fi
jenkins一键回滚
kubectl -s 10.0.0.11:8080 rollout undo -n xiaoniao deployment xiaoniao
12. k8s高可用
12.1 安装配置etcd高可用集群
#所有节点安装etcd
yum install etcd -y
3:ETCD_DATA_DIR="/var/lib/etcd/"
5:ETCD_LISTEN_PEER_URLS=“http://0.0.0.0:2380”
6:ETCD_LISTEN_CLIENT_URLS=“http://0.0.0.0:2379”
9:ETCD_NAME=“node1” #节点的名字
20:ETCD_INITIAL_ADVERTISE_PEER_URLS=“http://10.0.0.11:2380” #节点的同步数据的地址
21:ETCD_ADVERTISE_CLIENT_URLS=“http://10.0.0.11:2379” #节点对外提供服务的地址
26:ETCD_INITIAL_CLUSTER=“node1=http://10.0.0.11:2380,node2=http://10.0.0.12:2380,node3=http://10.0.0.13:2380”
27:ETCD_INITIAL_CLUSTER_TOKEN=“etcd-cluster”
28:ETCD_INITIAL_CLUSTER_STATE=“new”

systemctl enable etcd
systemctl restart etcd

[root@k8s-master tomcat_demo]# etcdctl cluster-health
member 9e80988e833ccb43 is healthy: got healthy result from http://10.0.0.11:2379
member a10d8f7920cc71c7 is healthy: got healthy result from http://10.0.0.13:2379
member abdc532bc0516b2d is healthy: got healthy result from http://10.0.0.12:2379
cluster is healthy

#修改flannel
vim /etc/sysconfig/flanneld
FLANNEL_ETCD_ENDPOINTS=“http://10.0.0.11:2379,http://10.0.0.12:2379,http://10.0.0.13:2379”
etcdctl mk /atomic.io/network/config ‘{ “Network”: “172.18.0.0/16”,“Backend”: {“Type”: “vxlan”} }’
systemctl restart flanneld
systemctl restart docker
12.2 安装配置master01的api-server,controller-manager,scheduler(127.0.0.1:8080)
vim /etc/kubernetes/apiserver
KUBE_ETCD_SERVERS="–etcd-servers=http://10.0.0.11:2379,http://10.0.0.12:2379,http://10.0.0.13:2379"

vim /etc/kubernetes/config
KUBE_MASTER="–master=http://127.0.0.1:8080"

systemctl restart kube-apiserver.service
systemctl restart kube-controller-manager.service kube-scheduler.service
12.3 安装配置master02的api-server,controller-manager,scheduler(127.0.0.1:8080)
yum install kubernetes-master.x86_64 -y
scp -rp 10.0.0.11:/etc/kubernetes/apiserver /etc/kubernetes/apiserver
scp -rp 10.0.0.11:/etc/kubernetes/config /etc/kubernetes/config
systemctl stop kubelet.service
systemctl disable kubelet.service
systemctl stop kube-proxy.service
systemctl disable kube-proxy.service

systemctl enable kube-apiserver.service
systemctl restart kube-apiserver.service
systemctl enable kube-controller-manager.service
systemctl restart kube-controller-manager.service
systemctl enable kube-scheduler.service
systemctl restart kube-scheduler.service
12.4 为master01和master02安装配置Keepalived
yum install keepalived.x86_64 -y

#master01配置:
! Configuration File for keepalived

global_defs {
router_id LVS_DEVEL_11
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 100
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
10.0.0.10
}
}

#master02配置
! Configuration File for keepalived

global_defs {
router_id LVS_DEVEL_12
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 80
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
10.0.0.10
}
}

systemctl enable keepalived
systemctl start keepalived
12.5 所有node节点kubelet,kube-proxy指向api-server的vip
vim /etc/kubernetes/kubelet
KUBELET_API_SERVER="–api-servers=http://10.0.0.10:8080"

vim /etc/kubernetes/config
KUBE_MASTER="–master=http://10.0.0.10:8080"

systemctl restart kubelet.service kube-proxy.service

基于nfs实现动态存储（二进制）
当你创建PVC时系统自动创pv
实现动态存储的方式：
Nfs的动态存储方式：
部署nfs
Master节点 node1node2节点安装nfs
yum -y install nfs
master节点：
mdkir /data
[root@k8s-master k8s_yaml]# mkdir storageclass
[root@k8s-master k8s_yaml]# cd storageclass
[root@k8s-master storageclass]#vi nfs-client.yaml
ikind: Deployment
apiVersion: apps/v1
metadata:
name: nfs-client-provisioner
spec:
replicas: 1
strategy:
type: Recreate
selector:
matchLabels:
app: nfs-client-provisioner
template:
metadata:
labels:
app: nfs-client-provisioner
spec:
serviceAccountName: nfs-client-provisioner
containers:
- name: nfs-client-provisioner
image: quay.io/external_storage/nfs-client-provisioner:latest
volumeMounts:
- name: nfs-client-root
mountPath: /persistentvolumes
env:
- name: PROVISIONER_NAME
value: fuseim.pri/ifs
- name: NFS_SERVER
value: 10.0.0.13
- name: NFS_PATH
value: /data
volumes:
- name: nfs-client-root
nfs:
server: 10.0.0.13
path: /data

vi nfs-client-sa.yaml
iapiVersion: v1
kind: ServiceAccount
metadata:
name: nfs-client-provisioner

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: nfs-client-provisioner-runner
rules:

apiGroups: [""]
resources: [“persistentvolumes”]
verbs: [“get”, “list”, “watch”, “create”, “delete”]
apiGroups: [""]
resources: [“persistentvolumeclaims”]
verbs: [“get”, “list”, “watch”, “update”]
apiGroups: [“storage.k8s.io”]
resources: [“storageclasses”]
verbs: [“get”, “list”, “watch”]
apiGroups: [""]
resources: [“events”]
verbs: [“list”, “watch”, “create”, “update”, “patch”]
apiGroups: [""]
resources: [“endpoints”]
verbs: [“create”, “delete”, “get”, “list”, “watch”, “patch”, “update”]

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: run-nfs-client-provisioner
subjects:

kind: ServiceAccount
name: nfs-client-provisioner
namespace: default
roleRef:
kind: ClusterRole
name: nfs-client-provisioner-runner
apiGroup: rbac.authorization.k8s.io

vi nfs-client-class.yaml
iapiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: course-nfs-storage
provisioner: fuseim.pri/ifs

修改pvc的配置文件
metadata:
namespace: tomcat
name: pvc-01
annotations:
volume.beta.kubernetes.io/storage-class: “course-nfs-storage”
14. Helm k8s包管理工具
14.1 helm介绍: [部署应用变得更简单、高效]
secret
configmap
deployment
pvc
service
ingress
14.2 helm安装
master节点：
上传helm文件
[root@kubernetes-master ~]#wget http://192.168.15.253/helm
[root@kubernetes-master ~]# chmod +x helm
[root@kubernetes-master ~]# mv helm /usr/sbin/
[root@kubernetes-master ~]# helm version

这里只有客户端，helm服务端需要配置在k8s的集群中
14.3 helm初始化
helm init #可以指定很多参数
helm init --upgrade -i slpcat/tiller:v2.8.2 --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
[可以部署helm的服务端]
Node节点：
[root@kubernetes-node1 ~]# http://192.168.15.253/k8s-tools/docker_k8s_tiller.tar.gz
[root@kubernetes-node1 ~]# docker load -i docker_k8s_tiller.tar.gz
Master节点：helm init 会自动生成yaml文件，应用于k8s中
[root@kubernetes-master ~]# helm init
[root@kubernetes-master ~]# kubectl get pod -n kube-system |grep tiller

[root@kubernetes-master ~]# helm version

到这里我们的helm服务端就部署OK了
#安装好helm之后，默认tiller没有权限
Master节点：
[root@kubernetes-master ~]# cd helm
vi rbac.yaml
iapiVersion: v1
kind: ServiceAccount
metadata:
name: tiller
namespace: kube-system

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
name: tiller
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects:

kind: ServiceAccount
name: tiller
namespace: kube-system
创建用户
kubectl create -f rbac.yaml
更新配置文件
第一种方式：手动修改配置文件
kubectl edit -n kube-system deployments tiller-deploy
找到serviceAcount,把用户名手动改成tiller
第二种方式：命令行非交互式打补丁
kubectl patch -n kube-system deploy tiller-deploy -p ‘{ “spec”:{ “template”:{ “spec”:{ “serviceAccount”: “tiller” } } } }’
创建完成后查看一下：
kubectl get deployments -n kube-system tiller-deploy -o yaml |grep -i account

#helm命令行自动补全
helm completion bash > .helmrc && echo “source .helmrc” >> .bashrc
source .helmrc
[root@kubernetes-master helm]# helm install --name oldboy --namespace=oldboy stable/phpmyadmin
helm search mysql
helm install –name wordpress stable/mysql
helm inspect values stable/mysql
14.4 自定义helm
[root@kubernetes-master helm]# mkdir helm_chart
[root@kubernetes-master helm]# cd helm_chart
[root@kubernetes-master helm_chart]# helm create hello-helm
官方会自动生成hello-helm目录，这个目录里面会有所有的模板文件
[root@kubernetes-master helm_chart]# ls
hello-helm
[root@kubernetes-master helm_chart]# cd hello-helm/
[root@kubernetes-master hello-helm]# ls
charts Chart.yaml templates values.yaml
[root@kubernetes-master charts]# cd templates/
[root@kubernetes-master templates]# rm -rf *.yaml *.tpl tests
[root@kubernetes-master templates]# ls
NOTES.txt
[root@kubernetes-master templates]# vim NOTES.txt
hello!
[root@kubernetes-master helm_chart]# cd hello-helm/
[root@kubernetes-master hello-helm]# ls
charts Chart.yaml templates values.yaml
[root@kubernetes-master hello-helm]# vim values.yaml

[root@kubernetes-master helm_chart]# helm install --name test hello-helm/
Error: release test failed: namespaces “default” is forbidden: User “system:serviceaccount:kube-system:tiller” cannot get resource “namespaces” in API group “” in the namespace “default”
遇到这个报错，是因为tiller服务器的权限不足
执行以下命令添加权限：
[root@kubernetes-master helm_chart]# kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
[root@kubernetes-master helm_chart]# kubectl patch deploy --namespace kube-system tiller-deploy -p ‘{“spec”:{“template”:{“spec”:{“serviceAccount”:“tiller”}}}}’
然后在安装就OK了
[root@kubernetes-master helm_chart]# helm install --name test hello-helm/

[root@kubernetes-master helm_chart]# helm list

这样就安装成功了
[root@kubernetes-master helm_chart]# cd hello-helm/
[root@kubernetes-master hello-helm]# cd templates/
[root@kubernetes-master templates]# vim pod.yaml

[root@kubernetes-master templates]# cd …
[root@kubernetes-master hello-helm]# ls
charts Chart.yaml templates values.yaml
[root@kubernetes-master hello-helm]# vim values.yaml

[root@kubernetes-master hello-helm]# cd templates/
[root@kubernetes-master templates]# vim pod.yaml
在这里不能以容器的名字作为变量:

再次安装，这次我们不指定名字，会随机生成一个名字
[root@kubernetes-master hello-helm]# helm install …/hello-helm

查看一下，发现这次安装的helm的名字是随机生成的：
[root@kubernetes-master hello-helm]# helm list

我们在values里面写的valum值通过helm部署的时候，会解析成最终的值，[这个过程称为渲染，所谓渲染就是把templates里面的值替换成values的值]然后创建yaml文件，就完成了部署
如果需要只渲染不部署,需要参数：–debug --dry-run
[root@kubernetes-master hello-helm]# helm install …/hello-helm --debug --dry-run
改变模板里面的值：参数：–set
[root@kubernetes-master hello-helm]# helm install …/hello-helm --debug --dry-run --set podname.test=oldguo

升级：
[root@kubernetes-master hello-helm]# helm upgrade test …/hello-helm --set podname.test=oldguo

[root@kubernetes-master hello-helm]# helm list

卸载：delete
[root@kubernetes-master hello-helm]# helm delete modest-dragonfly
[root@kubernetes-master hello-helm]# kubectl get all -n modest-dragonfly
查看没有资源了，卸载成功

statsfulset资源(公司不常用)
有状态的应用有数据的应用 mysql es集群（数据库）
特点：
所有的pod都是有序的(创建一个PVC会自动创建一个PV)
eg: web statsfulset
web-0
web-1
#启动pod，使用默认的动态存储
所有节点安装nfs-utils
yum -y install nfs-utils
master节点：
[root@kubernetes-master ~]# mkdir /data
[root@kubernetes-master ~]# vim /etc/exports
/data 10.0.0.0/24(rw,sync,no_root_squash,no_all_squash)
[root@kubernetes-master ~]# systemctl restart rpcbind
[root@kubernetes-master ~]# systemctl restart nfs
[root@kubernetes-master ~]# systemctl enable nfs
Node节点：
[root@kubernetes-node1 ~]# showmount -e 10.0.0.15
Export list for 10.0.0.15:
/data 10.0.0.0/24
Master节点：
[root@kubernetes-master ~]# cd k8s_yaml/
[root@kubernetes-master k8s_yaml]# ls
dashboard dns heapster helm ingress k8s_test.yaml metrics tomcat_demo volumes
上传storageclass.tar.gz文件
[root@kubernetes-master k8s_yaml]# rz

[root@kubernetes-master k8s_yaml]# tar xf storageclass.tar.gz
[root@kubernetes-master k8s_yaml]# cd storageclass/
[root@kubernetes-master storageclass]# ls
nfs-client.yaml nfs-sc.yaml rbac.yaml test_pvc2.yaml test_pvc.yaml
[root@kubernetes-master storageclass]# rm -rf test_pvc.yaml test_pvc2.yaml
[root@kubernetes-master storageclass]# vim nfs-client.yaml

[root@kubernetes-master storageclass]# vim nfs-sc.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: course-nfs-storage
annotations:
storageclass.kubernetes.io/is-default-class: true
provisioner: fuseim.pri/ifs
[root@kubernetes-master storageclass]# kubectl create -f .

这里报错是因为顺序问题，storageclass.kubernetes.io/is-default-class存储默认不存在
[root@kubernetes-master storageclass]# kubectl get pod
查看pod容器状态，如果nfs容器创建很慢，我们就在node节点上配置docker镜像加速文件
[root@kubernetes-node1 ~]# vim /etc/docker/daemon.json
{“registry-mirrors”:[“https://reg-mirror.qiniu.com/”]}
[root@kubernetes-node1 ~]# systemctl restart docker
等nfs容器running之后我们删除重新创建一下，还是报错，最后删除
[root@kubernetes-master storageclass]# vim nfs-sc.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: course-nfs-storage
provisioner: fuseim.pri/ifs
然后创建：
[root@kubernetes-master storageclass]# kubectl create -f nfs-sc.yaml
创建成功以后我们创建一个PVC试试
上传PVC文件：
[root@kubernetes-master storageclass]# cd …
[root@kubernetes-master k8s_yaml]# cd tomcat_demo/
[root@kubernetes-master tomcat_demo]# rz -E
[root@kubernetes-master tomcat_demo]# vim mysql_pvc.yaml
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: tomcat-mysql
annotations:
volume.beta.kubernetes.io/storage-class: “course-nfs-storage”
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 1Gi
[root@kubernetes-master tomcat_demo]# kubectl create -f mysql_pvc.yaml
创建一个PVC之后会自动创建一个PV
[root@kubernetes-master tomcat_demo]# kubectl get pvc

[root@kubernetes-master tomcat_demo]# kubectl get pv

这里我们可以打标签
[root@kubernetes-master tomcat_demo]# kubectl patch storageclass course-nfs-storage -p ‘{“metadata”:{“annotations”:{“storageclass.kubernetes.io/is-default-class”:“true”}}}’
[root@kubernetes-master tomcat_demo]# vim mysql_pvc2.yaml
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: tomcat-mysql2
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 1Gi
[root@kubernetes-master tomcat_demo]# kubectl create -f mysql_pvc2.yaml
[root@kubernetes-master tomcat_demo]# kubectl get pvc

将提前准备好的sts配置文件上传
[root@kubernetes-master k8s_yaml]# mkdir sts
[root@kubernetes-master k8s_yaml]# cd sts
[root@kubernetes-master sts]# rz

[root@kubernetes-master sts]# ls
sts.tar.gz
[root@kubernetes-master sts]# tar xf sts.tar.gz
[root@kubernetes-master sts]# ls
sts sts.tar.gz
[root@kubernetes-master sts]# mv sts/* .
[root@kubernetes-master sts]# ls
k8s_svc.yaml nginx_sts.yml sts sts.tar.gz
[root@kubernetes-master sts]# rm -rf sts sts.tar.gz
[root@kubernetes-master sts]# ls
k8s_svc.yaml nginx_sts.yml
[root@kubernetes-master sts]# kubectl create -f .
[root@kubernetes-master sts]# kubectl get sts

[root@kubernetes-master sts]# kubectl get pod

同时会自动创建两个PVC：
[root@kubernetes-master sts]# kubectl get pvc

如果没有动态存储，不会自动创建PVC，所以要想做statsfulset，必须要有动态存储
直接使用域名访问
ping web-1.nginx.default.svc.cluster.local
ping mysql.default.svc.cluster.local

kubectl patch storageclass course-nfs-storage -p '{“metadata”: {“annotations”:{" storageclass.kubernetes.io/is-default-class":“true”}}}
[root@kubernetes-master sts]# yum -y install bind-utils
[root@kubernetes-master sts]# kubectl get pod -n kube-system -o wide

[root@kubernetes-master sts]# ping 10.244.0.8
可以ping通
[root@kubernetes-master sts]# dig @10.244.0.8 web-1.nginx.default.svc.cluster.local

可以解析IP
[root@kubernetes-master sts]# kubectl get pod -o wide

servicename: nginx (无头 service 不分配clusterIP)
16. job资源和cron.job资源
job的作用：
运行一次性容器
使用k8s的job清理es索引
master节点：
[root@kubernetes-master ~]# cd k8s_yaml/
[root@kubernetes-master k8s_yaml]# mkdir job
[root@kubernetes-master k8s_yaml]# cd job
[root@kubernetes-master job]# vi k8s_job.yaml
iapiVersion: batch/v1
kind: Job
metadata:
name: nginx
spec:
template:
metadata:
name: myjob
spec:
containers:
- name: nginx
image: nginx:1.13
ports:
- containerPort: 80
command: [“sleep”,“10”]
restartPolicy: Never
[root@kubernetes-master job]# kubectl create -f k8s_job.yaml
[root@kubernetes-master job]# kubectl get job

任务完成以后，pod自动关闭
[root@kubernetes-master job]# kubectl get pod

[root@kubernetes-master job]# vi k8s_cronjob.yaml
iapiVersion: batch/v1beta1
kind: CronJob
metadata:
name: nginx
spec:
schedule: ‘*/1 * * * *’
jobTemplate:
spec:
template:
metadata:
name: myjob
spec:
containers:
- name: nginx
image: nginx:1.13
ports:
- containerPort: 80
command: [“sleep”,“10”]
restartPolicy: Never

[root@kubernetes-master job]# kubectl create -f k8s_cronjob.yaml
[root@kubernetes-master job]# kubectl get cronjob.batch

kubesphere管理平台
17.1 kubesphere是什么？
kubesphere—以应用为中心的容器管理平台，完全开源，KubeSphere 帮助企业在云、虚拟化及物理机等任何环境中快速构建、部署和运维基于 Kubernetes 的容器架构，轻松实现微服务治理、多租户管理、DevOps 与 CI/CD、监控日志告警、应用商店、大数据、以及人工智能等业务场景。

Kubernetes平台，专为DevOps团队量身定制
极简、易用、灵活、高效
17.2 部署kubesphere
 部署方式：
• 部署k8s集群及kubesphere
• 已有kubernetes集群部署kubesphere
已有k8s集群部署kubesphere具有更高的灵活性
 架构：
KubeSphere 采用了前后端分离的架构设计，后端的各个功能组件可通过 REST API 对接外部系统，详见架构说明。本仓库仅包含后端代码，前端代码参考 Console 项目。
 核心功能：
功能介绍
多云与多集群管理提供多云与多集群的中央管理面板，支持集群导入，支持应用在多云与多集群一键分发
Kubernetes 集群搭建与运维支持在线 & 离线安装、升级与扩容 K8s 集群，支持安装 “云原生全家桶”
Kubernetes 资源可视化管理可视化纳管原生 Kubernetes 资源，支持向导式创建与管理 K8s 资源
基于 Jenkins 的 DevOps 系统支持图形化与脚本两种方式构建 CI/CD 流水线，内置 Source to Image（S2I）和 Binary to Image（B2I）等 CD 工具
应用商店与应用生命周期管理提供应用商店，内置 Redis、MySQL 等 15 个常用应用，支持应用的生命周期管理
基于 Istio 的微服务治理 (Service Mesh) 提供可视化无代码侵入的灰度发布、熔断、流量治理与流量拓扑、分布式 Tracing
多租户管理提供基于角色的细粒度多租户统一认证，支持对接企业 LDAP/AD，提供多层级的权限管理
丰富的可观察性功能提供集群/工作负载/Pod/容器等多维度的监控，提供基于多租户的日志查询与日志收集，支持节点与应用层级的告警与通知
基础设施管理支持 Kubernetes 节点管理，支持节点扩容与集群升级，提供基于节点的多项监控指标与告警规则
存储管理支持对接 Ceph、GlusterFS、NFS、Local PV，支持可视化运维管理 PVC、StorageClass，提供 CSI 插件对接云平台存储
网络管理提供租户网络隔离与 K8s Network Policy 管理，支持 Calico、Flannel，提供 Porter LB 用于暴露物理环境 K8s 集群的 LoadBalancer 服务

GPU support 集群支持添加 GPU 与 vGPU，可运行 TensorFlow 等 ML 框架

 部署k8s集群：
hostnamectl set-hostname xx
yum install -y chrony
systemctl enable --now chronyd
timedatectl set-timezone Asia/Shanghai

在云平台上启动三台虚拟机

https://kubesphere.com.cn/en/docs/installing-on-linux/introduction/multioverview/
18. 阿里云k8s
pvc --pv —阿里云存储
svc --loadbalance
阿里云环境安装K8S步骤

安装docker
yum install -y docker
修改 /etc/docker/daemon.json 文件并添加上 registry-mirrors 键值
vim /etc/docker/daemon.json

{
“registry-mirrors”: [“https://registry.docker-cn.com”]
}
3. 启动并测试
sudo systemctl start docker
sudo docker run hello-world
4. 安装 etcd
sudo yum install etcd -y
5. kubectl安装
wget https://dl.k8s.io/v1.10.0/kubernetes-client-linux-amd64.tar.gz
tar -xzvf kubernetes-client-linux-amd64.tar.gz
cd kubernetes/client/bin
sudo chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
6. 安装VirtualBox 安装
　vim /etc/yum.repos.d/virtualbox.repo

#具体内容如下：
[virtualbox]
name=Oracle Linux / RHEL / CentOS-$releasever / $b a s e a r c h - V i r t u a l B o x b a s e u r l = h t t p : / / d o w n l o a d . v i r t u a l b o x . o r g / v i r t u a l b o x / r p m / e l /$ releasever/$basearch
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://www.virtualbox.org/download/oracle_vbox.asc

#执行以下命令，完成VirtualBox 的安装
yum -y install VirtualBox-5.2

安装minikube
curl -Lo minikube http://kubernetes.oss-cn-hangzhou.aliyuncs.com/minikube/releases/v0.30.0/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
安装依赖，配置virtualbox
yum -y install kernel-devel kernel-devel-3.10.0-957.el7.x86_64
sudo /sbin/vboxconfig
主板的bios中的Intel Virtualization Technology设置成了disable的，重启电脑进入bios，将其设置成abled
注意VMware的虚拟机开启VT-X/AMD-v enabled
解决方式：
step 1：关闭虚拟机（注意：是关闭，不是挂起；否则为关机状态下，下图不能勾选！）
step 2 ：