Kubernetes简称k8s（超详细教程）

最新推荐文章于 2025-05-07 13:59:53 发布

starry-sea

最新推荐文章于 2025-05-07 13:59:53 发布

阅读量5.3k

点赞数 7

文章标签： kubernetes docker

本文链接：https://blog.youkuaiyun.com/weixin_47768822/article/details/117019822

版权

本文详细介绍Kubernetes(K8S)的部署流程，包括单节点和多节点部署方式，涉及K8S架构介绍、特性说明及核心概念。涵盖minikube、kubeadm等工具的使用，并提供从零开始构建K8S集群的具体步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一：服务架构分析

K8S架构图

在这里插入图片描述

1：Kubernetes简介

Kubernetes是Google在2014年开源的容器集群管理系统，简称K8S

K8S用于容器化应用程序的部署，扩展和管理

K8S提供了容器的编排，资源调度，弹性伸缩，部署管理，服务发现一系列功能

Kubernetes目标是让部署容器化应用简单高效

官方网站是http://www.kubernetes.io

2：k8s特性

1：自我修复

在节点故障时重新启动失败的容器，替换和重新部署，保证预期的副本数量；杀死健康检查失败的容器，并且在未准备好之前不会处理客户端请求，确保线上服务不中断。

2：弹性伸缩

使用命令、UI或者基于CPU使用情况自动快速扩容和缩容应用程序实例，保证应用业务高峰并发时的高可用性；业务低峰时回收资源，以最小成本运行服务。

3：自动部署和回滚

K8S采用滚动更新策略更新应用，一次更新一个Pod，而不是同时删除所有Pod，如果更新过程中出现问题，将回滚更改，确保升级不受影响业务。

4：服务发现和负载均衡

K8S为多个容器提供一个统一访问入口（内部IP地址和一个DNS名称），并且负载均衡关联的所有容器，使得用户无需考虑容器IP问题。

5：机密和配置管理

管理机密数据和应用程序配置，而不需要把敏感数据暴露在镜像里，提高敏感数据安全性。并可以将一些常用的配置存储在K8S中，方便应用程序使用。

6：存储编排

挂载外部存储系统，无论是来自本地存储，公有云（如AWS），还是网络存储（如NFS、GlusterFS、Ceph）都作为集群资源的一部分使用，极大提高存储使用灵活性。

7：批处理

提供一次性任务，定时任务；满足批量数据处理和分析的场景。

3：K8S组件构成

1：Master组件

kube-apiserver

Kubernetes API，集群的统一入口，各组件协调者，以

RESTful API提供接口服务，所有对象资源的增删改查和监听

操作都交给APIServer处理后再提交给Etcd存储。

kube-controller-manager

处理集群中常规后台任务，一个资源对应一个控制器，而

ControllerManager就是负责管理这些控制器的。

kube-scheduler

根据调度算法为新创建的Pod选择一个Node节点，可以任意

部署,可以部署在同一个节点上,也可以部署在不同的节点上。

etcd

分布式键值存储系统。用于保存集群状态数据，比如Pod、

Service等对象信息。

2：Node组件

kubelet

kubelet是Master在Node节点上的Agent，管理本机运行容器

的生命周期，比如创建容器、Pod挂载数据卷、下载secret、获

取容器和节点状态等工作。kubelet将每个Pod转换成一组容器。

kube-proxy

在Node节点上实现Pod网络代理，维护网络规则和四层负载均

衡工作。

docker或rocket

容器引擎，运行容器

4：K8S核心概念

1：Pod

最小部署单元
一组容器的集合
一个Pod中的容器共享网络命名空间
Pod是短暂的

2：Controllers

ReplicaSet ：确保预期的Pod副本数量
Deployment ：无状态应用部署
StatefulSet ：有状态应用部署
DaemonSet ：确保所有Node运行同一个Pod
Job ：一次性任务
Cronjob ：定时任务

更高级层次对象，部署和管理Pod

3：Service

防止Pod失联
定义一组Pod的访问策略

4：Label

标签，附加到某个资源上，用于关联对象、查询和筛选

5：Namespace

命名空间，将对象逻辑上隔离

二：K8S的部署

1：minikube部署（单节点）

2：kubeadm部署（多节点快速部署）

kubeadm是官方社区推出的一个用于快速部署kubernetes集群的工具。

这个工具能通过两条指令完成一个kubernetes集群的部署：

# 创建一个 Master 节点
$ kubeadm init

# 将一个 Node 节点加入到当前集群中
$ kubeadm join <Master节点的IP和端口 >

1：安装要求

在开始之前，部署Kubernetes集群机器需要满足以下几个条件：

· 一台或多台机器，操作系统 CentOS7.x-86_x64

· 硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多

· 集群中所有机器之间网络互通

· 可以访问外网，需要拉取镜像

· 禁止swap分区

2：学习目标

1. 在所有节点上安装Docker和kubeadm

2. 部署Kubernetes Master

3. 部署容器网络插件

4. 部署 Kubernetes Node，将节点加入Kubernetes集群中

5. 部署Dashboard Web页面，可视化查看Kubernetes资源

3：准备环境

关闭防火墙

$ systemctl stop firewalld

$ systemctl disable firewalld

关闭selinux

$ sed -i 's/enforcing/disabled/' /etc/selinux/config 

$ setenforce 0

关闭swap（影响集群性能）

swapoff -a $ 临时

vim /etc/fstab $ 永久

添加主机名与IP对应关系（记得设置主机名）

$ cat /etc/hosts

192.168.31.61 k8s-master
192.168.31.62 k8s-node1
192.168.31.63 k8s-node2

将桥接的IPv4流量传递到iptables的链

$ cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF


$ sysctl --system

4：所有节点安装Docker/kubeadm/kubelet/kubectl

Kubernetes默认CRI（容器运行时）为Docker，因此先安装Docker。

4.1 安装Docker

$ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo

$ yum -y install docker-ce-18.06.1.ce-3.el7

$ systemctl enable docker && systemctl start docker

#验证docker安装
$ docker --version

$ Docker version 18.06.1-ce, build e68fc7a

4.2 添加阿里云YUM软件源

$ cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

4.3 安装kubeadm，kubelet和kubectl

由于版本更新频繁，这里指定版本号部署

$ yum install -y kubelet-1.15.0 kubeadm-1.15.0 kubectl-1.15.0

$ systemctl enable kubelet

5：部署Kubernetes Master

在192.168.31.61（Master）执行。

$ kubeadm init \
--apiserver-advertise-address=192.168.31.61 \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.15.0 \
--service-cidr=10.1.0.0/16 \
--pod-network-cidr=10.244.0.0/16

由于默认拉取镜像地址k8s.gcr.io国内无法访问，这里指定阿里云镜像仓库地址。

使用kubectl工具：

$ mkdir -p $HOME/.kube

$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

$ sudo chown $(id -u):$(id -g) $HOME/.kube/config

$ kubectl get nodes

6：安装Pod网络插件（CNI



$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml

确保能够访问到quay.io这个registery。

如果下载失败，可以改成这个镜像地址：lizhenliang/flannel:v0.11.0-amd64

7：加入Kubernetes Node

在192.168.31.62/63（Node）执行。

向集群添加新节点，执行在kubeadm init输出的kubeadm join命令：

$ kubeadm join 192.168.31.61:6443 --token esce21.q6hetwm8si29qxwn \
 --discovery-token-ca-cert-hash sha256:00603a05805807501d7181c3d60b478788408cfe6cedefedb1f97569708be9c5

8:测试kubernetes集群

在Kubernetes集群中创建一个pod，验证是否正常运行：

$ kubectl create deployment nginx --image=nginx
$ kubectl expose deployment nginx --port=80 --type=NodePort
$ kubectl get pod,svc

访问地址：http://NodeIP:Port

9：部署 Dashboard

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v1.10.1/src/deploy/recommended/kubernetes-dashboard.yaml

默认镜像国内无法访问，修改镜像地址为： lizhenliang/kubernetes-dashboard-amd64:v1.10.1

默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部：

kind: Service
apiVersion: v1
metadata:
labels:
k8s-app: kubernetes-dashboard
name: kubernetes-dashboard
namespace: kube-system
spec:
type: NodePort
ports:
- port: 443
targetPort: 8443
nodePort: 30001
selector:
k8s-app: kubernetes-dashboard

$ kubectl apply -f kubernetes-dashboard.yaml

访问地址：http://NodeIP:30001

创建service account并绑定默认cluster-admin管理员集群角色：

$ kubectl create serviceaccount dashboard-admin -n kube-system
$ kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
$ kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk ‘/dashboard-admin/{print $1}’)

使用输出的token登录Dashboard。

3：使用二进制安装（较为复杂）

1：环境规划

软件	版本
linux	centos7.5
Kubernetes	Kubernetes
Docker	20.x-ce
Etcd	3.x
Flannel	0.10

角色	IP
k8s-master	192.168.128.10
k8s-node01	192.168.128.11
k8s-node02	192.168.128.12

master节点部署

1：修改主机名

$ vi /etc/hostname

修改内容如下

$ master #只有这一行！！原本的内容删除！

执行命令

$ hostname master

2：关闭selinux

三个节点全关

修改配置文件/etc/selinux/config

将SELINUX=enforcing

修改为SELINUX=disabled

并执行

$ setenforce 0

3：关闭防火墙

三个节点全关

$ systemctl stop firewalld

4：配置时间同步

三个节点执行

$ yum install -y ntpdate

$ ntpdate time.windows.com

5：自签证书

1：安装cfssl工具

$ wget http://www.xiaozhenhx.top:20000/k8s/flannel.sh

$ bash cfssl.sh

2：下载脚本etcd-cert.sh

创建一个工作目录

$ mkdir /root/etcd-cert

$ mkdir /root/k8s-cert

$ cd  /root/etcd-cert

下载执行脚本

$ wget http://www.xiaozhenhx.top:20000/k8s/etcd-cert.sh

修改相关内容

修改第三部分IP地址为三个节点的ip

执行脚本

$ bash etcd-cert.sh

3：创建etcd相关证书

创建证书文件

$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

他会生成三个文件

ca.csr
ca-key.pem
ca.pem

$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

他会生成三个文件

server.csr 
server-key.pem
server.pem

6：部署Etcd数据库

下载软件包

官方链接

https://github.com/etcd-io/etcd/releases/tag/v3.2.12

$ cd /root

$ wget http://www.xiaozhenhx.top:20000/k8s/etcd-v3.3.10-linux-amd64.tar.gz

解压文件

$ tar -zxvf etcd-v3.3.10-linux-amd64.tar.gz

创建etcd工作目录

$ mkdir -p /opt/etcd/{cfg,bin,ssl}

将前面解压的文件移动到/opt/etcd/bin目录下

$ cd /root/etcd-v3.3.10-linux-amd64

$ mv etcd etcdctl /opt/etcd/bin/

解析：

cfg 存放配置文件

bin 存放可执行文件

ssl 存放证书文件

下载etcd.sh

$ cd /root

$ wget http://www.xiaozhenhx.top:20000/k8s/etcd.sh

$  bash etcd.sh etcd01 192.168.128.10 etcd02=https://192.168.128.11:2380,etcd03=https://192.168.128.12:2380

执行完成后查看是否成功

[root@localhost k8s-cert]# cat /opt/etcd/cfg/etcd                      
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.128.10:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.128.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.128.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.128.10:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.128.10:2380,etcd02=https://192.168.128.11:2380,etcd03=https://192.168.128.12:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

[root@localhost k8s-cert]# cat /usr/lib/systemd/system/etcd.service    
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/opt/etcd/cfg/etcd
ExecStart=/opt/etcd/bin/etcd --name=${ETCD_NAME} --data-dir=${ETCD_DATA_DIR} --listen-peer-urls=${ETCD_LISTEN_PEER_URLS} --listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 --advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} --initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} --initial-cluster=${ETCD_INITIAL_CLUSTER} --initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} --initial-cluster-state=new --cert-file=/opt/etcd/ssl/server.pem --key-file=/opt/etcd/ssl/server-key.pem --peer-cert-file=/opt/etcd/ssl/server.pem --peer-key-file=/opt/etcd/ssl/server-key.pem --trusted-ca-file=/opt/etcd/ssl/ca.pem --peer-trusted-ca-file=/opt/etcd/ssl/ca.pem
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
[root@localhost k8s-cert]#

将生成的证书文件移动到/opt/etcd/ssl/

$ cp /root/etcd-cert/{ca,server-key,server}.pem /opt/etcd/ssl/

将配置文件复制到其他服务器上面(etcd最少需要三台机器)

$ scp -r /opt/etcd/ root@192.168.128.11:/opt/
$ scp -r /opt/etcd/ root@192.168.128.12:/opt/
$ scp -r /usr/lib/systemd/system/etcd.service root@192.168.128.11:/usr/lib/systemd/system
$ scp -r /usr/lib/systemd/system/etcd.service root@192.168.128.12:/usr/lib/systemd/system

！！！启动etcd时三台服务器都要etcd步骤完成才能启动完成！！！

启动etcd服务

$ systemctl daemon-reload
$ systemctl enable etcd
$ systemctl restart etcd

启动界面会卡住，原因是启动节点的etcd服务没有启动，三个节点全部启动成功后会结束

查看日志

$ tail /var/log/messages -f

下面的操作是其他节点的etcd服务已经启动完成的操作

验证etcd集群启动是否完成

$ /opt/etcd/bin/etcdctl --ca-file=/opt/etcd/ssl/ca.pem --cert-file=/opt/etcd/ssl/server.pem --key-file=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379" cluster-health

启动成功截图

7：配置Flannel网段

要求：

一个Pod一个ip地址

每个Pod独立IP。Pod内容器共享网络(同一个IP)

所有容器都可以与所有其他容器通信

所有节点都可以与所有容器通信

给Flanne分配子网(写入etcd)

$ /opt/etcd/bin/etcdctl --ca-file=/opt/etcd/ssl/ca.pem --cert-file=/opt/etcd/ssl/server.pem --key-file=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379" set /coreos.com/network/config  '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

验证是否成功

$ /opt/etcd/bin/etcdctl --ca-file=/opt/etcd/ssl/ca.pem --cert-file=/opt/etcd/ssl/server.pem --key-file=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379" get /coreos.com/network/config

显示这个为成功

{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}

8：部署master组件

该步骤需要node节点docker安装完成

kube-apiserver组件

创建软件工作目录

$ mkdir -p /opt/kubernetes/{bin,cfg,ssl}

生成证书

下载脚本

$ cd /root/k8s-cert

$ wget http://www.xiaozhenhx.top:20000/k8s/k8s-cert.sh

修改脚本内容

$ vi k8s-cert.sh

修改server-csr.json段

改为

执行脚本

$ bash k8s-cert.sh

移动生成的证书到固定位置

$ cp ca.pem ca-key.pem server.pem server-key.pem /opt/kubernetes/ssl/

生成token

下面是一整段，请直接完成

BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
cat > token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

将生成的token文件移动到/opt/kubernetes/cfg/

$ mv token.csv /opt/kubernetes/cfg/

下载组件包

$ wget http://www.xiaozhenhx.top:20000/k8s/kubernetes-server-linux-amd64.tar.gz

$ tar -zxvf kubernetes-server-linux-amd64.tar.gz 

$ cd kubernetes/server/bin/

拷贝需要的文件到/opt/kubernetes/bin/

$ cp kube-apiserver kube-controller-manager kube-scheduler /opt/kubernetes/bin/

$ cp kubectl /usr/bin

下载master安装包

$ wget http://www.xiaozhenhx.top:20000/k8s/master.zip

$ yum install -y unzip

$ unzip master.zip

./apiserver.sh 192.168.128.10 https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379

查看部署是否完成

$ netstart -antp |grep 8080

$ netstart -antp |grep 6443

kube-ocntroller-manager

将在master组件包里面解压的controller-manager.sh

$ bash controller-manager.sh 127.0.0.1

kube-scheduler

将在master组件包里面解压的scheduler.sh

赋予权限

$ bash scheduler.sh 127.0.0.1

9：查看集群状态

$ kubectl get cs

10：部署node节点认证

创建kubeconfig文件

下载脚本

$ wget http://www.xiaozhenhx.top:20000/k8s/kubeconfig.sh

编辑内容

$ vi kubeconfig.sh

BOOTSTRAP_TOKEN=后面追加 /opt/kubernetes/cfg/tocken.csv

例：

$ bash kubeconfig.sh 192.168.128.10 /root/k8s-cert

解析：IP地址填写api地址

后面的路径是生成文件的保存位置

完成后将配置文件拷贝到node节点上面

$ cd /root

$ scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.128.11:/opt/kubernetes/cfg/

$ scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.128.12:/opt/kubernetes/cfg/

$ cd /root/kubernetes/server/bin/kube-proxy
#node节点第一个组件报错
$ master的目录下/root/kubernetes/server/bin/

$ scp kubelet kube-proxy root@192.168.128.11:/opt/kubernetes/bin/

$ scp kubelet kube-proxy root@192.168.128.12:/opt/kubernetes/bin/

node01节点部署

1：修改主机名

$ vi /etc/hostname

修改内容如下

$ node01 #只有这一行！！原本的内容删除！！

执行命令

$ hostname node01

2：关闭selinux

修改配置文件/etc/selinux/config

将SELINUX=enforcing

修改为SELINUX=disabled

并执行

$ setenforce 0

3：关闭防火墙

$ systemctl stop firewalld

4：配置时间同步

$ yum install -y ntpdate

$ ntpdate time.windows.com

5：配置etcd服务

执行这一步时，前提是master节点的配置文件拷贝完成

修改/opt/etcd/cfg/etcd

$ vi /opt/etcd/cfg/etcd

修改第二行

ETCD_NAME=“etcd02”

修改所有IP端修改为本机IP地址

注意：ETCD_INITIAL_CLUSTER=行忽略

修改完成截图

启动etcd服务

$ systemctl daemon-reload
$ systemctl enable etcd
$ systemctl restart etcd

6：安装docker

卸载旧版本(旧版本与新版本不兼容)

$ yum remove docker docker-client docker-client-latest  docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

安装相关工具

$ yum install -y yum-utils device-mapper-persistent-data lvm2

下载docker-ce.repo文件

$ yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装docker-ce

$ yum install docker-ce -y

配置仓库加速

$ curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://bc437cce.m.daocloud.io

启动docker并加入开机自启

$ systemctl restart docker

$ systemctl enable docker

7：配置Flannel网络

创建Flanne工作目录

$ mkdir -p /opt/kubernetes/{bin,cfg,ssl}

下载二进制包文件

官方：https://github.com/coreos/flannel/releases

$ cd /root

$ wget http://www.xiaozhenhx.top:20000/k8s/flannel-v0.10.0-linux-amd64.tar.gz

压缩包处理

$ tar -zxvf flannel-v0.10.0-linux-amd64.tar.gz 

$ mv flanneld mk-docker-opts.sh /opt/kubernetes/bin/

下载Flannel脚本

$ wget http://www.xiaozhenhx.top:20000/k8s/flannel.sh

$ bash flannel.sh https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379

查看文件是否生成完成

[root@node01 ~]# cat /opt/kubernetes/cfg/flanneld

FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.128.10:2379,https://192.168.128.11:2379,https://192.168.128.12:2379 -etcd-cafile=/opt/etcd/ssl/ca.pem -etcd-certfile=/opt/etcd/ssl/server.pem -etcd-keyfile=/opt/etcd/ssl/server-key.pem"

[root@node01 ~]# cat /usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service

[Service]
Type=notify
EnvironmentFile=/opt/kubernetes/cfg/flanneld
ExecStart=/opt/kubernetes/bin/flanneld --ip-masq $FLANNEL_OPTIONS
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

[root@node01 ~]# cat /usr/lib/systemd/system/docker.service

[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target

查看进程查看Flannel是否启动

$ ps -ef |grep flannel

重启docker读取配置

$ systemctl restart docker

查看docker进程是否读取成功

$ ps -ef |grep docker

查看ip的docker和Flannel是否在一个网段

$ ip a

拷贝配置文件到node02上面(主要是懒得再配置一遍)

$ scp -r /opt/kubernetes/ root@192.168.128.12:/opt/

$ scp -r /usr/lib/systemd/system/{flanneld,docker}.service root@192.168.128.12:/usr/lib/systemd/system/

8：部署node节点组件

我们在/opt/kubernetes/cfg/token.csv里定义了一个角色

$ kubectl create clusterrolebinding kubelet-bootstrap \
  --clusterrole=system:node-bootstrapper \
  --user=kubelet-bootstrap

下载node安装组件包

$ wget http://www.xiaozhenhx.top:20000/k8s/node.zip

$ unzip node.zip

部署kubectl组件

$ chmod +x  kubelet.sh

$ ./kubelet.sh 192.168.128.11  #后面跟的是本机IP地址

在master节点同意node01节点的证书请求

$ kubectl get csr

$ kubectl sertificate approve 跟上面图片的NAME

查看服务器是否上线

$ kubectl get node

部署proxy组件

$ chmod +x  proxy.sh

$ ./proxy.sh 192.168.128.11  #后面跟的是本机IP地址

查看启动状态

$ ps -ef |grep proxy

将一些配置文件拷贝到node02节点实现快速配置

$ scp -r /opt/kubernetes/ root@192.168.128.12:/opt/
$ scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.128.12:/usr/lib/systemd/system/

node02节点部署

1：修改主机名

$ vi /etc/hostname

修改内容如下

$ node02

执行命令

$ hostname node02

2：关闭selinux

修改配置文件/etc/selinux/config

将SELINUX=enforcing

修改为SELINUX=disabled

并执行

$ setenforce 0

3：关闭防火墙

$ systemctl stop firewalld

4：配置时间同步

$ yum install -y ntpdate
$ ntpdate time.windows.com

5：配置etcd服务

执行这一步时，前提是master节点的配置文件拷贝完成

修改/opt/etcd/cfg/etcd

$ vi /opt/etcd/cfg/etcd

修改第二行

ETCD_NAME=“etcd03”

修改所有IP端修改为本机IP地址

注意：ETCD_INITIAL_CLUSTER=行忽略

修改完成截图

启动etcd服务

$ systemctl daemon-reload
$ systemctl enable etcd
$ systemctl restart etcd

6：安装docker

卸载旧版本(旧版本与新版本不兼容)

$ yum remove docker docker-client docker-client-latest  docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

安装相关工具

$ yum install -y yum-utils device-mapper-persistent-data lvm2

下载docker-ce.repo文件

$ yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装docker-ce

$ yum install docker-ce -y

配置仓库加速

$ curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://bc437cce.m.daocloud.io

启动docker并加入开机自启

$ systemctl restart docker

$ systemctl enable docker

7：配置Flannel网络

由于配置文件已经从node01节点拷贝过来，所有这里直接启动即可

$ systemctl daemon-reload

$ systemctl start flanneld

$ systemctl restart docker

查看进程确认是否启动完成

 $ ps -ef |grep flannel

 $ ps -ef |grep docker

$ ip a

验证node节点是否正常通信

创建一个docker容器

在node01节点ping node02节点创建的容器IP

ping通表示搭建完成

8：部署node节点组件

和node01节点安装组件步骤一样

我们在/opt/kubernetes/cfg/token.csv里定义了一个角色

$ kubectl create clusterrolebinding kubelet-bootstrap \
  --clusterrole=system:node-bootstrapper \
  --user=kubelet-bootstrap

下载node安装组件包

$ wget http://www.xiaozhenhx.top:20000/k8s/node.zip

$ unzip node.zip

部署kubectl组件

$ chmod +x  kubelet.sh

$ ./kubelet.sh 192.168.128.12  #后面跟的是本机IP地址

在master节点同意node01节点的证书请求

$ kubectl get csr

$ kubectl sertificate approve 跟上面图片的NAME

查看服务器是否上线

$ kubectl get node

部署proxy组件

$ chmod +x  proxy.sh

$ ./proxy.sh 192.168.128.12  #后面跟的是本机IP地址

查看启动状态

$ ps -ef |grep proxy

本文档所使用的所有脚本

cfssl.sh

curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /usr/local/bin/cfssl
curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o /usr/local/bin/cfssljson
curl -L https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o /usr/local/bin/cfssl-certinfo
chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson /usr/local/bin/cfssl-certinfo

etcd-cert.sh

cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

cat > ca-csr.json <<EOF
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF


cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "10.206.240.188",
    "10.206.240.189",
    "10.206.240.111"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

etcd.sh

#!/bin/bash
# example: ./etcd.sh etcd01 192.168.1.10 etcd02=https://192.168.1.11:2380,etcd03=https://192.168.1.12:2380

ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3

WORK_DIR=/opt/etcd

cat <<EOF >$WORK_DIR/cfg/etcd
#[Member]
ETCD_NAME="${ETCD_NAME}"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

cat <<EOF >/usr/lib/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--name=\${ETCD_NAME} \
--data-dir=\${ETCD_DATA_DIR} \
--listen-peer-urls=\${ETCD_LISTEN_PEER_URLS} \
--listen-client-urls=\${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \
--advertise-client-urls=\${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=\${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=\${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=\${ETCD_INITIAL_CLUSTER_TOKEN} \
--initial-cluster-state=new \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

Flannel.sh

#!/bin/bash

ETCD_ENDPOINTS=${1:-"http://127.0.0.1:2379"}

cat <<EOF >/opt/kubernetes/cfg/flanneld

FLANNEL_OPTIONS="--etcd-endpoints=${ETCD_ENDPOINTS} \
-etcd-cafile=/opt/etcd/ssl/ca.pem \
-etcd-certfile=/opt/etcd/ssl/server.pem \
-etcd-keyfile=/opt/etcd/ssl/server-key.pem"

EOF

cat <<EOF >/usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service

[Service]
Type=notify
EnvironmentFile=/opt/kubernetes/cfg/flanneld
ExecStart=/opt/kubernetes/bin/flanneld --ip-masq \$FLANNEL_OPTIONS
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

EOF

cat <<EOF >/usr/lib/systemd/system/docker.service

[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd \$DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP \$MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target

EOF

systemctl daemon-reload
systemctl enable flanneld
systemctl restart flanneld
systemctl restart docker

k8s-cert.sh

cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
      	    "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

#-----------------------

cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "10.206.176.19",
      "10.206.240.188",
      "10.206.240.189",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

#-----------------------

cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

#-----------------------

cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

kubeconfig.sh

# 创建 TLS Bootstrapping Token
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
#BOOTSTRAP_TOKEN=0fb61c46f8991b718eb38d27b605b008

cat > token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

#----------------------

APISERVER=$1
SSL_DIR=$2

# 创建kubelet bootstrapping kubeconfig 
export KUBE_APISERVER="https://$APISERVER:6443"

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig

# 设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 设置默认上下文
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------

# 创建kube-proxy kubeconfig文件

kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

controller-manager.sh

#!/bin/bash

MASTER_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-controller-manager


KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect=true \\
--address=127.0.0.1 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-name=kubernetes \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--experimental-cluster-signing-duration=87600h0m0s"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

scheduler.sh

#!/bin/bash

MASTER_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-scheduler

KUBE_SCHEDULER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

kubelet.sh

#!/bin/bash

NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}

cat <<EOF >/opt/kubernetes/cfg/kubelet

KUBELET_OPTS="--logtostderr=true \\
--v=4 \\
--address=${NODE_ADDRESS} \\
--hostname-override=${NODE_ADDRESS} \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--experimental-bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"

EOF

cat <<EOF >/opt/kubernetes/cfg/kubelet.config

kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local.
failSwapOn: false

EOF

cat <<EOF >/usr/lib/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

proxy.sh

#!/bin/bash

NODE_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-proxy

KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.0.0.0/24 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy