Linux云盘算 |【第五阶段】CLOUD-DAY6

紧张内容：

了解Kubernetes的架构、搭建Kubernetes集群

一、Kubernetes 概述

Kubernetes 这个名字来自希腊语，意思是“舵手”或“领航员”；K8S 是 Kubernetes 的缩写，其中“8”代表字母“ubernete”中的8个字母。Kubernetes 是由谷歌（Google）公司制作的，是谷歌10多年大规模容器管理技能 Borg 的开源版本。于2014年6月由谷歌公司正式发布并公布开源。
功能与特点：

• 容器集群管理体系：Kubernetes 是一个开源的平台，用于管理容器集群
  
• 自动化摆设：Kubernetes 可以实现容器集群的自动化摆设
  
• 自动扩缩容：Kubernetes 支持根据需求自动扩展或缩减容器集群的规模
  
• 维护功能：Kubernetes 提供维护功能，确保容器集群的稳固运行
  

   1. 自动化摆设
  

• 描述：Kubernetes 可以自动摆设应用程序和服务到容器集群中，减少手动操作的复杂性和错误
  
• 优势：提高摆设效率，减少人为错误，确保一致性和可重复性
  

  2. 自动扩缩容
  

• 描述：Kubernetes 可以根据应用程序的负载情况自动扩展或缩减容器集群的规模
  
• 优势：优化资源利用率，降低本钱，确保应用程序在高负载下仍能稳固运行
  

  3. 维护功能
  

• 描述：Kubernetes 提供维护功能，包括自动修复、滚动更新、回滚等，确保容器集群的稳固运行
  
• 优势：减少停机时间，提高体系的可靠性和可用性
  

  
1、Kubernetes (K8S) 集群分析

Kubernetes (K8S) 集群是一个由多个节点组成的体系，用于管理和运行容器化应用程序。Kubernetes 集群的核心组件包括控制平面（Control Plane）和工作节点（Worker Nodes）。

核心角色：

• - Master（管理节点、控制平面）
  
• - Node（盘算节点、工作节点）
  
• - image（镜像仓库）
  

---

1）控制平面（Control Plane）

控制平面是 Kubernetes 集群的大脑，负责管理和控制整个集群的状态，对集群进行全局决议，检测和响应集群事件；紧张由 API Server、Scheduler、Etcd和Controller manager 组件组成。
   ① API Server：
  

• 功能：提供 Kubernetes API，是集群的入口点，负责处理所有 API 哀求
  
• 特点：支持 RESTful API，用于与集群进行交互
  
• 备注：整个体系的对外接口，提供客户端和别的组件调用，后端运行的所有元数据都会存储于etcd中(键值数据库)
  

  ② etcd：
  

• 功能：分布式键值存储，用于存储集群的所有设置数据和状态信息
  
• 特点：高可用性和一致性，确保集群状态的可靠存储
  
• 备注：由kubernetes集群自动管理，用户无需手动干预，etcdctl是etcd的客户端管理程序
  

  ③ Scheduler：
  

• 功能：负责将 Pod（Kubernetes 的最小调理单元）调理到符合的节点上运行
  
• 特点：根据资源需求、节点状态和策略进行智能调理
  
• 备注：负责对集群内部的资源进行调理，负责分配容器运行所在
  

  ④ Controller Manager：
  

• 功能：运行各种控制器进程，负责维护集群的状态，如副本控制器、节点控制器等
  
• 特点：确保集群的现实状态与期望状态一致
  

  ⑤ Cloud Controller Manager：
  

• 功能：与云服务提供商的 API 交互，管理云资源，如负载均衡器、存储卷等
  
• 特点：特定于云情况的控制器，提供云资源的集成管理
  

  Master相干组件接口：

2）工作节点（Worker Nodes）

工作节点是 Kubernetes 集群中现实运行容器化应用程序的节点，负责维护运行Pod，并提供具体应用的运行情况；每个工作节点包含以下核心组件：
   ① Kubelet：
  

• 功能：负责管理节点上的容器，与控制平面通信，确保容器按照 Pod 规范运行
  
• 特点：节点上的代理，负责执行控制平面的指令
  
• 备注：用来启动、监视pod及调用Docker去对容器进行操作，包括增编削等操作
  

  ② Kube-proxy：
  

• 功能：负责维护节点上的网络规则，实现服务发现和负载均衡
  
• 特点：确保 Pod 之间的网络通信和服务的可达性
  
• 备注：为Pod对象提供代理，并实现kubernetes Service的通信与负载均衡机制
  

  ③ 容器运行时（Container Runtime）：
  

• 功能：负责运行容器，如 Docker、containerd、CRI-O 等
  
• 特点：支持多种容器运行时，提供容器生命周期管理
  

  
2、kube-proxy 代理模式分析

kube-proxy 是 Kubernetes 集群中负责网络代理和负载均衡的关键组件。它确保集群内部和外部的网络流量可以或许正确地路由到相应的 Pod。kube-proxy 支持多种代理模式，每种模式都有其特定的实现方式和实用场景。以下是对 kube-proxy 代理模式的具体分析：
1）用户空间代理模式（User Space Proxy Mode）

   版本：Kubernetes v1.0
  实现方式：kube-proxy 在用户空间运行，通过切换差别的用户空间来实现对应用的访问。
  特点：
  

• 简单：实现简单，易于明白和调试。
  
• 性能较低：由于在用户空间和内核空间之间频仍切换，性能较低。
  
• 实用场景：早期版本中使用，实用于小型集群或测试情况。
  

  2）iptables 模式代理（iptables Proxy Mode）

   版本：Kubernetes v1.1
  实现方式：kube-proxy 使用 iptables 规则来实现网络流量的转发和映射。
  特点：
  

• 性能较高：直接在内核空间操作，性能优于用户空间代理模式。
  
• 复杂性：iptables 规则复杂，管理和维护难度较大。
  
• 实用场景：实用于大多数生产情况，特殊是需要高性能和稳固性的场景。
  

  3）IPVS 代理模式（IPVS Proxy Mode）

   版本：Kubernetes v1.8
  实现方式：kube-proxy 使用 IPVS（IP Virtual Server）来实现负载均衡。IPVS 是 Linux 内核的一部门，提供高性能的负载均衡功能。
  特点：
  

• 高性能：IPVS 在内核空间实现负载均衡，性能非常高。
  
• 可扩展性：支持多种负载均衡算法（如轮询、加权轮询、最小连接等）。
  
• 复杂性：需要满足一定的内核和软件包要求。
  
• 实用场景：实用于大规模集群，特殊是需要高性能负载均衡的场景。
  

  启用 IPVS 模式的条件
① 内核支持，内核必须支持以下模块：

• ip_vs：IPVS 核心模块。
  
• ip_vs_rr：轮询调理算法。
  
• ip_vs_wrr：加权轮询调理算法。
  
• ip_vs_sh：源所在哈希调理算法。
  
• nf_conntrack_ipv4：连接跟踪模块。
  

② 软件包支持，必须安装以下软件包：

• ipvsadm：IPVS 管理工具。
  
• ipset：用于管理 IP 聚集的工具。
  

③ 设置文件中开启 IPVS 参数，在 kube-proxy 的设置文件中开启 IPVS 参数，例如：

1. mode: ipvs

复制代码

3、Pod 的具体分析

在 Kubernetes 中，Pod 是调理的基本单元，也是最小的摆设和管理单元。Pod 的设计理念是将一组紧密关联的容器打包在一起，共享相同的网络命名空间和存储卷。以下是对 Pod 的具体分析：
1）Pod 的基本概念
   调理的基本单元：
  Pod 是 Kubernetes 调理的基本单元，Kubernetes 通过调理 Pod 来管理容器的运行；
  
  容器组：
  一个 Pod 可以包含一个或多个容器，这些容器共享相同的网络命名空间和存储卷；
  
  网络命名空间：
  Pod 中的所有容器共享相同的 IP 所在和端标语，容器之间可以通过 localhost 进行通信；
  
  存储卷：
  Pod 中的容器可以共享存储卷，实现数据的共享和持久化；
  2）Pod 的特点

• 独立摆设单元：Pod 是一个独立的摆设单元，支持横向扩展和复制。通过复制 Pod，可以实现应用的高可用性和负载均衡。
  
• 多进程聚合：Pod 可以看作是一个服务的多个进程的聚合单位。例如，一个 Pod 可以包含一个主应用容器和一个辅助容器（如日志网络器）。
  
• 生命周期管理：Pod 的生命周期由 Kubernetes 管理，支持自动重启、扩缩容等。
  
• 资源隔离：Pod 中的容器在同一节点上运行，但资源隔离由容器运行时管理。
  

3）Pod 的管理
在 Kubernetes 中，用户无法单独管理某一个容器。管理容器的时间是以 Pod 为单位，必须先创建 Pod，才气够去创建容器。每个容器都在 Pod 中，没有不在 Pod 的容器。Pod 是容器运行的最小情况。
4）Pod 的创建和使用
   ① 创建 Pod：
  通过定义 YAML 或 JSON 格式的 Pod 设置文件，可以创建 Pod。设置文件中指定 Pod 的名称、容器镜像、端口、存储卷等信息。
  
  ② 管理 Pod：
  Kubernetes 提供了丰富的命令和 API 来管理 Pod，如 kubectl create、kubectl get、kubectl delete 等。
  
  ③ Pod 的扩展：
  通过复制 Pod，可以实现应用的横向扩展。Kubernetes 的副本控制器（ReplicaSet 或 Deployment）负责管理 Pod 的副本数目。
  
二、kubernetes 集群安装摆设

1）安装摆设方式：

• 源码摆设：下载源码或编译好的二进制，手工添加参数启动服务，Kubernetes接纳证书认证方式，需要创建大量证书；
  
• 容器摆设：官方把服务做成“镜像”，下载镜像、启动即可；
  

   官方特意根据容器摆设方式，制作kubeadm工具，为用户提高下载良好体验度（推荐）
  官网所在：Kubernetes
  2）摆设情况要求：

• ① 内核版本：>= 3.10
  
• ② 最低设置：2CPU、2G内存
  
• ③ 节点之中不可以有重复的主机名、MAC所在或product_uuid
  
• ④ 卸载防火墙、禁用Swap交换分区、禁用SELinux；
  

---

安装摆设示例：

情况准备：实验集群规划，需购买5台云主机

主机名	IP所在	最低设置	集群角色
master	192.168.1.21	2CPU,4G内存	管理节点
node-0001	192.168.1.31	2CPU,4G内存	盘算节点
node-0002	192.168.1.32	2CPU,4G内存
node-0003	192.168.1.33	2CPU,4G内存
registry	192.168.1.100	1CPU,1G内存	私有镜像仓库

步骤1：私有镜像仓库初始化（registry操作192.168.1.100）
① 安装仓库软件并启动服务

1. [root@registry ~]# yum makecache
2. [root@registry ~]# yum install -y docker-distribution    //安装私有镜像仓库软件
3. [root@registry ~]# systemctl enable --now docker-distribution  //开启镜像仓库服务

复制代码

② 使用脚本初始化仓库（init-img.sh）
# 拷贝云盘kubernetes/v1.17.6/registry/myos目录的摆设脚本和镜像压缩包到仓库服务器

1. [root@ecs-proxy ~]# scp /root/kubernetes/v1.17.6/registry/myos/* 192.168.1.100:/root/
2. [root@registry ~]# mkdir myos    //创建存放目录
3. [root@registry ~]# cp init-img.sh myos.tar.gz myos/
4. [root@registry ~]# ls myos
5. init-img.sh  myos.tar.gz
6. [root@registry ~]# cd myos
7. [root@registry myos]# chmod 755 init-img.sh   //赋予脚本执行权限
8. [root@registry myos]# ./init-img.sh    //执行脚本（导入4个镜像）
9. [root@registry myos]# curl http://192.168.1.100:5000/v2/myos/tags/list   //查看镜像仓库的myos镜像的标签
10. {"name":"myos","tags":["php-fpm","httpd","nginx","v1804"]}

复制代码

  补充：其中镜像标签是v1804即原来的latest，因latest在k8s中有特殊含义；在k8s集群中，latest标签是不会被缓存，如果想缓存可以使用其他标签；
   
步骤2：设置YUM仓库（proxy跳板机操作）
# 在跳板机上拷贝kubernetes/v1.17.6/k8s-install/到Yum仓库，提供安装工具软件包

1. [root@ecs-proxy ~]# cp -a kubernetes/v1.17.6/k8s-install/ /var/ftp/localrepo/
2. [root@ecs-proxy ~]# cd /var/ftp/localrepo/
3. [root@ecs-proxy localrepo]# createrepo --update .
4. [root@ecs-proxy localrepo]# ls k8s-install/

复制代码

   补充：官网下载软件包所在https://packages.cloud.google.com/
  
步骤3：Master管理节点安装工具摆设（master操作192.168.1.21）
① 安装基础软件包（kubeadm、kubectl、kubelet、docker-ce）

• - Kubeadm：用来初始化集群的命令行工具；
  
• - kubectl：用来与集群通信的命令行工具（K8S集群管理工具）；
  
• - kubelet：在集群中的每个节点上用来启动pod和容器等，用来管理容器和应用的；
  
• - docker-ce：容器的管理工具
  

1. [root@master ~]# yum makecache
2. [root@master ~]# yum install -y kubeadm kubelet kubectl docker-ce

复制代码

② Tab键自动补全设置
   Kubectl、kubeadm工具支持自动补全功能，可节省大量输入，需在Shell设置文件中调用

1. [root@master ~]# kubectl completion bash > /etc/bash_completion.d/kubectl
2. [root@master ~]# kubeadm completion bash > /etc/bash_completion.d/kubeadm
3. [root@master ~]# exit   //配置完成后，重新登录后生效

复制代码

③ 修改内核参数（开启netfilter对bridge装备的监控）

1. [root@master ~]# vim /etc/sysctl.d/k8s.conf    //编写配置文件
2. net.bridge.bridge-nf-call-ip6tables = 1    //开启网桥监控
3. net.bridge.bridge-nf-call-iptables = 1
4. net.ipv4.ip_forward = 1     //路由转发
5. [root@master ~]# modprobe br_netfilter   //载入内核模块
6. [root@master ~]# sysctl --system

复制代码

步骤4：Master管理节点服务镜像摆设（master操作192.168.1.21）
① 编写设置文件/etc/docker/daemon.json，指定私有镜像仓库
   注意：为docker指定私有镜像仓库和Cgroup驱动控制器；因kubelet使用的Cgroup控制器是Systemd，而docker使用的是Cgroupfs，所以必须设置统一（查询命令：docker info）

1. [root@master ~]# mkdir -p /etc/docker
2. [root@master ~]# vim /etc/docker/daemon.json   //指定registry的镜像仓库地址IP端口
3. {
4.     "exec-opts": ["native.cgroupdriver=systemd"],
5.     "registry-mirrors": ["https://hub-mirror.c.163.com"],
6.     "insecure-registries":["192.168.1.100:5000", "registry:5000"]
7. }
8. [root@master ~]# systemctl enable --now docker kubelet   //启动Docker、kubelet服务
9. [root@master ~]# docker info | grep Cgroup
10. Cgroup Driver: systemd      //必须使用systemd驱动

复制代码

② 镜像导入私有仓库
   补充：K8S v1.17.6推荐的摆设方式是使用镜像摆设，master节点各个服务是运行在容器内的；
  # 拷贝云盘kubernetes/v1.17.6/base-images中的7个镜像拷贝到master（apiserver、coredns、controller-manager、kube-proxy、scheduler、etcd、pause）

1. [root@ecs-proxy ~]# scp -r /root/kubernetes/v1.17.6/base-images/ 192.168.1.21:/root
2. [root@master ~]# cd base-images/
3. [root@master base-images]# ls
4. coredns.tar.gz  etcd.tar.gz  kube-apiserver.tar.gz  kube-controller-manager.tar.gz kube-proxy.tar.gz  kube-scheduler.tar.gz  pause.tar.gz

复制代码

③ 导入镜像到本地仓库

1. [root@master base-images]# for i in *.tar.gz
2. > do
3. > docker load -i ${i}
4. > done
5. [root@master base-images]# docker images

复制代码

④ 上传到私有镜像仓库

1. [root@master base-images]# docker images | awk '$2!="TAG"{print $1,$2}'|while read _f _v;do
2. >     docker tag ${_f}:${_v} 192.168.1.100:5000/${_f##*/}:${_v};
3. >     docker push 192.168.1.100:5000/${_f##*/}:${_v};
4. >     docker rmi ${_f}:${_v};
5. > done

复制代码

# 检察验证

1. [root@master base-images]# curl http://192.168.1.100:5000/v2/_catalog   //查看私有镜像仓库的镜像
2. {"repositories":["coredns","etcd","kube-apiserver","kube-controller-manager","kube-proxy","kube-scheduler","myos","pause"]}

复制代码

步骤5：Master管理节点初始化安装（master操作192.168.1.21）
① 安装IPVS代理软件包

1. [root@master ~]# yum install -y ipvsadm ipset

复制代码

② 设置主机名

1. [root@master ~]# vim /etc/hosts
2. 192.168.1.21   master
3. 192.168.1.31   node-0001
4. 192.168.1.32   node-0002
5. 192.168.1.33   node-0003
6. 192.168.1.100  registry

复制代码

③ 使用kubeadm工具初始化应答文件安装master（kubeadm-init.yaml）
# 拷贝云盘的kubernetes/v1.17.6/config/kubeadm-init.yaml应答文件到Master

• - 格式：kubeadm init --config=应答文件.yaml //初始化安装
  

1. [root@ecs-proxy ~]# scp /root/kubernetes/v1.17.6/config/kubeadm-init.yaml 192.168.1.21:/root
2. [root@master ~]# mkdir init ; cd init
3. [root@master init]# cp /root/kubeadm-init.yaml ./
4. [root@master init]# kubeadm init --config=kubeadm-init.yaml | tee master-init.log   //初始化安装
5. [root@master init]# tree /root/init/
6. init/
7. ├── kubeadm-init.yaml
8. └── master-init.log
9. 0 directories, 2 files

复制代码

④ 通过tee的输出提示，根据提示执行命令

1. [root@master init]# mkdir -p $HOME/.kube
2. [root@master init]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
3. [root@master init]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

复制代码

⑨ 验证安装结果（安装完成即集群已组建，需等Node节点加入）

1. [root@master ~]# kubectl version   //查看版本

复制代码

1. [root@master ~]# kubectl get componentstatuses    //查看Master组件的状态

复制代码

---

补充：Kubeadm常用命令

命令	说明
- config	设置管理命令
- help	检察帮助
- init	初始命令
- join	node加入集群的命令
- reset	还原状态命令
- token	token凭证管理命令
- version	检察版本

补充：通过tee命令记载日志（输出到终点且记载到日志）

补充：Node节点需要加入集群，必须有Master节点提供的Token令牌；
获取Token，需要从Master的安装日志里查找安装指令示例：

   - token：相当于证明文件
  - token-ca-cert-hash： 验证文件的真伪
  
补充：Token管理
管理token使用kubeadm token指令：

• - 格式：kubeadm token list    //列出token
  
• - 格式：kubeadm token delete    //删除token
  
• - 格式：kubeadm token create [参数]    //创建token
  

可选参数：
   [ --ttl ]   设置token生命周期，0为无穷；
  [ --print-join-command ]  直接打印安装命令；
  

---

步骤6：在Master上创建天生token（master操作192.168.1.21）

1. [root@master ~]# kubeadm token create --ttl=0 --print-join-command

复制代码

1. [root@master ~]# kubeadm token list

复制代码

• 方法1：获取token证书的hash，--discovery-token-ca-cert-hash sha256:
  
• 方法2：获取token证书的hash，CA证书路径/etc/kubernetes/pki.ca.crt，通过Openssl指令获取；
  

1. [root@master ~]# openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der | openssl dgst -sha256 -hex

复制代码

   token证书：2f5px8.l2tgvrpppe4i3ha2
  token_hash：23ddaaad95ac7377bbc858975ac068529a0bda07d60cd32e5726611c576751b4
  token_hash加密算法：sha256
  
步骤7：Node盘算节点安装并加入集群（proxy跳板机操作）

• ① 卸载防火墙
  
• ② 禁用SELinux和SWAP
  
• ③ 设置YUM仓库，安装kubeadm、kubelet、docker-ce
  
• ④ 安装IPVS模式软件包：ipvsadm、ipset
  
• ⑤ 设置Docker私有镜像仓库和Cgroup驱动（daemon.json）
  
• ⑥ 设置内核参数（/etc/sysctl.d/k8s.conf）
  
• ⑦ 设置/etc/host（Master能访问Node的主机名）
  

# 拷贝云盘上 kubernetes/v1.17.6/node-install 的Ansible安装Playbook脚本到跳板机

1. [root@ecs-proxy ~]# cp -a /root/kubernetes/v1.17.6/node-install/ /root/
2. [root@ecs-proxy ~]# cd node-install/
3. [root@ecs-proxy node-install]# ls
4. ansible.cfg  files  hostlist.yaml  node_install.yaml
5. //注释：Ansible配置文件、主机清单文件、安装Node节点Playbook
6. [root@ecs-proxy node-install]# tree files/
7. files/
8. ├── daemon.json   //指定私有仓库配置文件
9. ├── hosts         //主机名解析文件
10. └── k8s.conf     //内核参数配置文件
11. 0 directories, 3 files

复制代码

① 修改主机名分析文件，删除多余主机，出现以下结果

1. [root@ecs-proxy node-install]# vim files/hosts
2. ::1             localhost localhost.localdomain localhost6 localhost6.localdomain6
3. 127.0.0.1       localhost localhost.localdomain localhost4 localhost4.localdomain4
4. 192.168.1.21    master
5. 192.168.1.31    node-0001
6. 192.168.1.32    node-0002
7. 192.168.1.33    node-0003
8. 192.168.1.100   registry

复制代码

② 修改node_instal.yaml文件，将从Master获取得token证书、验证hash替换；

1. [root@ecs-proxy node-install]# vim node_install.yaml
2. …
3.   vars:
4.     master: '192.168.1.21:6443'         //masterIP:apiserver接口
5.     token: '2f5px8.l2tgvrpppe4i3ha2'    //获取的token
6.     token_hash: 'sha256:23ddaaad95ac7377bbc858975ac068529a0bda07d60cd32e5726611c576751b4'    //token的hash算法和hash值
7. …

复制代码

③ 执行Playbook前，测试主机文件

1. [root@ecs-proxy node-install]# ansible nodes --list-hosts
2.   hosts (3):
3.     192.168.1.31
4.     192.168.1.33
5.     192.168.1.32

复制代码

# 执行Playbook前，测试主机Ping测试

1. [root@ecs-proxy node-install]# ansible-playbook node_install.yaml    //执行Playbook
2. …
3. 192.168.1.31               : ok=12   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
4. 192.168.1.32               : ok=12   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
5. 192.168.1.33               : ok=12   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

复制代码

④ 在Master节点验证安装

1. [root@master ~]# kubectl get nodes    //查看节点信息
2. NAME        STATUS     ROLES    AGE     VERSION
3. master      NotReady   master   4h11m   v1.17.6
4. node-0001   NotReady   <none>   6m55s   v1.17.6
5. node-0002   NotReady   <none>   6m54s   v1.17.6
6. node-0003   NotReady   <none>   6m41s   v1.17.6

复制代码

  补充：Master和Node容器已启动，但服务状态不可用NoteReady未就绪，是因为容器的网络不通，需要更新完网络插件以后，状态将酿成Ready；
    Flannel 实质上是一种“覆盖网络(overlay network)”，也就是将TCP数据包装在另一种网络包里进行路由转发和通信，现在已支持UPD、VXLAN、AWS VPC和GCE路由等数据转发方式；使用Flannel目标：差别主机内的容器实现互联互通；
  

  软件所在：GitHub - flannel-io/flannel: flannel is a network fabric for containers, designed for Kubernetes
  步骤8：网络flannel插件安装设置（实现差别主机之间的容器互联互通）（master操作）
# 拷贝云盘 kubernetes/v1.17.6/flannel 目录下的镜像压缩包和Playbook文件到 master 上

1. [root@ecs-proxy ~]# scp -r /root/kubernetes/v1.17.6/flannel/ 192.168.1.21:/root/
2. [root@ecs-proxy ~]# ssh 192.168.1.21
3. [root@master ~]# cd flannel/
4. [root@master flannel]# ls
5. flannel.tar.gz  kube-flannel.yml

复制代码

① 导入镜像到本地仓库

1. [root@master flannel]# docker load -i flannel.tar.gz
2. [root@master flannel]# docker images

复制代码

② 上传镜像到私有镜像仓库

1. [root@master flannel]# docker tag quay.io/coreos/flannel:v0.12.0-amd64 192.168.1.100:5000/flannel:v0.12.0-amd64
2. [root@master flannel]# docker push 192.168.1.100:5000/flannel:v0.12.0-amd64

复制代码

1. [root@master flannel]# curl http://192.168.1.100:5000/v2/flannel/tags/list
2. {"name":"flannel","tags":["v0.12.0-amd64"]}

复制代码

③ 修改资源文件kube-flannel.yml并flannel安装
   只需在Master安装，别的节点会自动完成适配

1. [root@master flannel]# vim kube-flannel.yml
2. 128       "Network": "10.244.0.0/16",     // flannel创建Pod的网络地址，16位表示限制容器个数
3. 172         image: 192.168.1.100:5000/flannel:v0.12.0-amd64   //定义启动容器所使用的的镜像（指定私有仓库地址）
4. 186         image: 192.168.1.100:5000/flannel:v0.12.0-amd64
5. 227  ---开始到结尾的配置为嵌入式配置，删除无效配置
6. ...
7. [root@master flannel]# kubectl apply -f kube-flannel.yml   //安装，-f指定文件
8. podsecuritypolicy.policy/psp.flannel.unprivileged created
9. clusterrole.rbac.authorization.k8s.io/flannel created
10. clusterrolebinding.rbac.authorization.k8s.io/flannel created
11. serviceaccount/flannel created
12. configmap/kube-flannel-cfg created
13. daemonset.apps/kube-flannel-ds-amd64 created

复制代码

③ 验证结果（等候30秒程序启动）

1. [root@master flannel]# kubectl get nodes
2. NAME        STATUS   ROLES    AGE    VERSION
3. master      Ready    master   5h6m   v1.17.6
4. node-0001   Ready    <none>   62m    v1.17.6
5. node-0002   Ready    <none>   62m    v1.17.6
6. node-0003   Ready    <none>   62m    v1.17.6

复制代码

  补充：如果kube-flannel.yml设置文件修改错误，可以使用kubectl delete -f kube-flannel.yml删除，在重新安装；
  

---

扩展：初始化仓库所使用的init-img.sh脚本
紧张内容：

• ① 安装Dokcer工具、启动Docker服务；
  
• ② 设置指定私有镜像仓库文件；
  
• ③ 导入镜像压缩包，通过Dockerfile制作镜像；
  
• ④ 同步4个镜像到私有镜像仓库；
  

1. [root@registry myos]# cat init-img.sh
2. #!/bin/bash
3. yum install -y docker-ce    //安装Docker管理工具
4. mkdir -p /etc/docker
5. cat >/etc/docker/daemon.json <<'EOF'    //指定私有镜像仓库
6. {
7.     "exec-opts": ["native.cgroupdriver=systemd"],
8.     "registry-mirrors": ["https://hub-mirror.c.163.com"],
9.     "insecure-registries":["192.168.1.100:5000", "registry:5000"]
10. }
11. EOF
12. systemctl enable --now docker.service    //启动Docker服务
13. systemctl restart docker.service
14. docker load -i myos.tar.gz     //导入镜像压缩包（v1804 httpd php-fpm nginx）
15. # init apache images     //Dockerfile ——> Apache
16. cat >Dockerfile<<'EOF'
17. FROM myos:latest
18. ENV  LANG=C
19. WORKDIR /var/www/html/
20. EXPOSE 80
21. CMD ["/usr/sbin/httpd", "-DFOREGROUND"]
22. EOF
23. docker build -t 192.168.1.100:5000/myos:httpd .   //创建镜像
24.  
25. # init php-fpm images     //Dockerfile ——> php-fpm
26. cat >Dockerfile<<'EOF'
27. FROM myos:latest
28. EXPOSE 9000
29. WORKDIR /usr/local/nginx/html
30. CMD ["/usr/sbin/php-fpm", "--nodaemonize"]
31. EOF
32. docker build -t 192.168.1.100:5000/myos:php-fpm .   //创建镜像
33.  
34. # init nginx images     //Dockerfile ——> Nginx
35. cat >Dockerfile<<'EOF'
36. FROM myos:latest
37. EXPOSE 80
38. WORKDIR /usr/local/nginx/html
39. CMD  ["/usr/local/nginx/sbin/nginx", "-g", "daemon off;"]
40. EOF
41. docker build -t 192.168.1.100:5000/myos:nginx .   //创建镜像
42.  
43. # upload images
44. rm -f Dockerfile
45. docker tag myos:latest 192.168.1.100:5000/myos:v1804   //给myos镜像创建标签
46. for i in v1804 httpd php-fpm nginx;do
47.     docker push 192.168.1.100:5000/myos:${i}   //同步到私有镜像仓库
48. done

复制代码

扩展：安装Master节点的kubeadm-init.yaml应答文件

1. [root@master init]# cat /root/kubeadm-init.yaml
2. apiVersion: kubeadm.k8s.io/v1beta2
3. bootstrapTokens:
4. - groups:
5.   - system:bootstrappers:kubeadm:default-node-token
6.   token: abcdef.0123456789abcdef    //token令牌
7.   ttl: 24h0m0s     //token的生命周期
8.   usages:
9.   - signing
10.   - authentication
11. kind: InitConfiguration
12. localAPIEndpoint:
13.   advertiseAddress: 192.168.1.21   //apiserver的IP地址（Master节点地址）
14.   bindPort: 6443
15. nodeRegistration:
16.   criSocket: /var/run/dockershim.sock
17.   name: master
18.   taints:
19.   - effect: NoSchedule
20.     key: node-role.kubernetes.io/master
21. ---
22. apiServer:
23.   timeoutForControlPlane: 4m0s
24. apiVersion: kubeadm.k8s.io/v1beta2
25. certificatesDir: /etc/kubernetes/pki
26. clusterName: kubernetes
27. controllerManager: {}
28. dns:
29.   type: CoreDNS
30. etcd:
31.   local:
32.     dataDir: /var/lib/etcd
33. imageRepository: 192.168.1.100:5000    //镜像仓库地址
34. kind: ClusterConfiguration
35. kubernetesVersion: v1.17.6    //仓库镜像标签TAG（表示当前安装的K8S版本）
36. networking:
37.   dnsDomain: cluster.local    //默认服务域名地址
38.   podSubnet: 10.244.0.0/16    //POD的地址（fannel）
39.   serviceSubnet: 10.254.0.0/16   //K8S服务的地址
40. scheduler: {}
41. ---   //---代表对kubeproxy新的定义
42. apiVersion: kubeproxy.config.k8s.io/v1alpha1    //kubeproxy版本
43. kind: KubeProxyConfiguration     //资源对象
44. mode: ipvs      //开启IPVS模式参数

复制代码

扩展：创建应答设置文件模板

• - 命令：kubeadm config print init-defaults > kubeadm-init.yaml
  

扩展：安装Node节点的node_install.yaml
紧张内容：

• ① 卸载防火墙
  
• ② 禁用SELinux和SWAP
  
• ③ 设置YUM仓库，安装kubeadm、kubelet、docker-ce
  
• ④ 安装IPVS模式软件包：ipvsadm、ipset
  
• ⑤ 设置Docker私有镜像仓库和Cgroup驱动（daemon.json）
  
• ⑥ 设置内核参数（/etc/sysctl.d/k8s.conf）
  
• ⑦ 设置/etc/host（Master能访问Node的主机名）
  

1. [root@ecs-proxy ~]# cat node-install/node_install.yaml
2. ---
3. - name: kubernetes node install
4.   hosts:    //主机清单（nodes分组）
5.   - nodes
6.   vars:     //定义变量
7.     master: '192.168.1.21:6443'    //指定Master主机的Apiserver接口
8.     token: '2f5px8.l2tgvrpppe4i3ha2'
9.     token_hash: 'sha256:23ddaaad95ac7377bbc858975ac068529a0bda07d60cd32e5726611c576751b4'
10.   tasks:    //执行命令
11.   - name: disable swap    //关闭SWAP空间
12.     lineinfile:
13.       path: /etc/fstab
14.       regexp: 'swap'
15.       state: absent
16.     notify: disable swap
17.   - name: Ensure SELinux is set to disabled mode    //关闭SELinux
18.     lineinfile:
19.       path: /etc/selinux/config
20.       regexp: '^SELINUX='
21.       line: SELINUX=disabled
22.     notify: disable selinux
23.   - name: remove the firewalld    //卸载防火墙
24.     yum:
25.       name:
26.       - firewalld
27.       - firewalld-filesystem
28.       state: absent
29.   - name: install k8s node tools    //安装Node节点所需工具
30.     yum:
31.       name:
32.       - kubeadm
33.       - kubelet
34.       - docker-ce
35.       - ipvsadm
36.       - ipset
37.       state: present
38.       update_cache: yes
39.   - name: Create a directory if it does not exist    //创建/etc/docker目录存放daemon.json
40.     file:
41.       path: /etc/docker
42.       state: directory
43.       mode: '0755'
44.   - name: Copy file with /etc/hosts   //拷贝host文件
45.     copy:
46.       src: files/hosts
47.       dest: /etc/hosts
48.       owner: root
49.       group: root
50.       mode: '0644'
51.   - name: Copy file with /etc/docker/daemon.json    //创建daemon.json文件，配置私有镜像仓库和cgroup驱动
52.     copy:
53.       src: files/daemon.json
54.       dest: /etc/docker/daemon.json
55.       owner: root
56.       group: root
57.       mode: '0644'
58.   - name: Copy file with /etc/sysctl.d/k8s.conf    //配置内核参数文件
59.     copy:
60.       src: files/k8s.conf
61.       dest: /etc/sysctl.d/k8s.conf
62.       owner: root
63.       group: root
64.       mode: '0644'
65.     notify: enable sysctl args    //触发handles载入内核模块sysctl –system
66.   - name: enable k8s node service     //启动docker、kubelet服务
67.     service:
68.       name: "{{ item }}"
69.       state: started
70.       enabled: yes
71.     with_items:
72.     - docker
73.     - kubelet
74.   - name: check node state      //检查节点状态
75.     stat:
76.       path: /etc/kubernetes/kubelet.conf    //查看文件是否存在
77.     register: result
78.   - name: node join       //将node节点加入集群
79.     shell: kubeadm join '{{ master }}' --token '{{ token }}' --discovery-token-ca-cert-hash '{{ token_hash }}'
80.     when: result.stat.exists == False     //判断文件不存在则执行Node加入集群
81.   handlers:
82.   - name: disable swap
83.     shell: swapoff -a
84.   - name: disable selinux
85.     shell: setenforce 0
86.   - name: enable sysctl args
87. shell: sysctl –system

复制代码

扩展：网络设置插件kube-flannel.yml资源文件

1. [root@master ~]# cat flannel/kube-flannel.yml
2. ---
3. apiVersion: policy/v1beta1
4. kind: PodSecurityPolicy
5. metadata:
6.   name: psp.flannel.unprivileged
7.   annotations:
8.     seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default
9.     seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default
10.     apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default
11.     apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default
12. spec:
13.   privileged: false
14.   volumes:
15.     - configMap
16.     - secret
17.     - emptyDir
18.     - hostPath
19.   allowedHostPaths:
20.     - pathPrefix: "/etc/cni/net.d"
21.     - pathPrefix: "/etc/kube-flannel"
22.     - pathPrefix: "/run/flannel"
23.   readOnlyRootFilesystem: false
24.   # Users and groups
25.   runAsUser:
26.     rule: RunAsAny
27.   supplementalGroups:
28.     rule: RunAsAny
29.   fsGroup:
30.     rule: RunAsAny
31.   # Privilege Escalation
32.   allowPrivilegeEscalation: false
33.   defaultAllowPrivilegeEscalation: false
34.   # Capabilities
35.   allowedCapabilities: ['NET_ADMIN']
36.   defaultAddCapabilities: []
37.   requiredDropCapabilities: []
38.   # Host namespaces
39.   hostPID: false
40.   hostIPC: false
41.   hostNetwork: true
42.   hostPorts:
43.   - min: 0
44.     max: 65535
45.   # SELinux
46.   seLinux:
47.     # SELinux is unused in CaaSP
48.     rule: 'RunAsAny'
49. ---
50. kind: ClusterRole
51. apiVersion: rbac.authorization.k8s.io/v1beta1
52. metadata:
53.   name: flannel
54. rules:
55.   - apiGroups: ['extensions']
56.     resources: ['podsecuritypolicies']
57.     verbs: ['use']
58.     resourceNames: ['psp.flannel.unprivileged']
59.   - apiGroups:
60.       - ""
61.     resources:
62.       - pods
63.     verbs:
64.       - get
65.   - apiGroups:
66.       - ""
67.     resources:
68.       - nodes
69.     verbs:
70.       - list
71.       - watch
72.   - apiGroups:
73.       - ""
74.     resources:
75.       - nodes/status
76.     verbs:
77.       - patch
78. ---
79. kind: ClusterRoleBinding
80. apiVersion: rbac.authorization.k8s.io/v1beta1
81. metadata:
82.   name: flannel
83. roleRef:
84.   apiGroup: rbac.authorization.k8s.io
85.   kind: ClusterRole
86.   name: flannel
87. subjects:
88. - kind: ServiceAccount
89.   name: flannel
90.   namespace: kube-system
91. ---
92. apiVersion: v1
93. kind: ServiceAccount
94. metadata:
95.   name: flannel
96.   namespace: kube-system
97. ---
98. kind: ConfigMap
99. apiVersion: v1
100. metadata:
101.   name: kube-flannel-cfg
102.   namespace: kube-system
103.   labels:
104.     tier: node
105.     app: flannel
106. data:
107.   cni-conf.json: |
108.     {
109.       "name": "cbr0",
110.       "cniVersion": "0.3.1",
111.       "plugins": [
112.         {
113.           "type": "flannel",
114.           "delegate": {
115.             "hairpinMode": true,
116.             "isDefaultGateway": true
117.           }
118.         },
119.         {
120.           "type": "portmap",
121.           "capabilities": {
122.             "portMappings": true
123.           }
124.         }
125.       ]
126.     }
127.   net-conf.json: |
128.     {
129.       "Network": "10.244.0.0/16",
130.       "Backend": {
131.         "Type": "vxlan"
132.       }
133.     }
134. ---
135. apiVersion: apps/v1
136. kind: DaemonSet
137. metadata:
138.   name: kube-flannel-ds-amd64
139.   namespace: kube-system
140.   labels:
141.     tier: node
142.     app: flannel
143. spec:
144.   selector:
145.     matchLabels:
146.       app: flannel
147.   template:
148.     metadata:
149.       labels:
150.         tier: node
151.         app: flannel
152.     spec:
153.       affinity:
154.         nodeAffinity:
155.           requiredDuringSchedulingIgnoredDuringExecution:
156.             nodeSelectorTerms:
157.               - matchExpressions:
158.                   - key: kubernetes.io/os
159.                     operator: In
160.                     values:
161.                       - linux
162.                   - key: kubernetes.io/arch
163.                     operator: In
164.                     values:
165.                       - amd64
166.       hostNetwork: true
167.       tolerations:
168.       - operator: Exists
169.         effect: NoSchedule
170.       serviceAccountName: flannel
171.       initContainers:
172.       - name: install-cni
173.         image: 192.168.1.100:5000/flannel:v0.12.0-amd64
174.         command:
175.         - cp
176.         args:
177.         - -f
178.         - /etc/kube-flannel/cni-conf.json
179.         - /etc/cni/net.d/10-flannel.conflist
180.         volumeMounts:
181.         - name: cni
182.           mountPath: /etc/cni/net.d
183.         - name: flannel-cfg
184.           mountPath: /etc/kube-flannel/
185.       containers:
186.       - name: kube-flannel
187.         image: 192.168.1.100:5000/flannel:v0.12.0-amd64
188.         command:
189.         - /opt/bin/flanneld
190.         args:
191.         - --ip-masq
192.         - --kube-subnet-mgr
193.         resources:
194.           requests:
195.             cpu: "100m"
196.             memory: "50Mi"
197.           limits:
198.             cpu: "100m"
199.             memory: "50Mi"
200.         securityContext:
201.           privileged: false
202.           capabilities:
203.             add: ["NET_ADMIN"]
204.         env:
205.         - name: POD_NAME
206.           valueFrom:
207.             fieldRef:
208.               fieldPath: metadata.name
209.         - name: POD_NAMESPACE
210.           valueFrom:
211.             fieldRef:
212.               fieldPath: metadata.namespace
213.         volumeMounts:
214.         - name: run
215.           mountPath: /run/flannel
216.         - name: flannel-cfg
217.           mountPath: /etc/kube-flannel/
218.       volumes:
219.         - name: run
220.           hostPath:
221.             path: /run/flannel
222.         - name: cni
223.           hostPath:
224.             path: /etc/cni/net.d
225.         - name: flannel-cfg
226.           configMap:
227.             name: kube-flannel-cfg

复制代码

小结：

本篇章节为【第五阶段】CLOUD-DAY6 的学习条记，这篇条记可以初步了解到 Kubernetes的架构、搭建Kubernetes集群。

---

Tip：毕竟两个人的智慧大于一个人的智慧，如果你不明白本章节的内容或需要相干条记、视频，可私信小安，请不要害羞和回避，可以向他人讨教，花点时间直到你真正的明白。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。