笔记 K8S 环境搭建 kubeadm 与二进制方式（初学）

最新推荐文章于 2024-03-10 23:32:35 发布

FOREVERHOPE_WBZ

最新推荐文章于 2024-03-10 23:32:35 发布

阅读量1k

点赞数

文章标签：容器 kubernetes Powered by 金山文档

本文链接：https://blog.csdn.net/FOREVERHOPE_WBZ/article/details/128592108

版权

K8s 概述

K8s 是谷歌在2014年开源的容器化集群管理系统

使用k8s 进行容器化应用部署

使用k8s 利于应用扩展

K8s目标实施让部署容器化应用更加简洁和高效

K8s功能

自动装箱

基于容器对应用运行环境的资源配置要求自动部署应用容器

自我修复(自愈能力)

当容器失败时，会对容器进行重启

当所部署的node节点有问题时，会对容器进行重新部署和重新调度

当容器未通过监控检查时，会关闭此容器直到容器正常运行时，才会对外提供服务

水平扩展

通过简单的命令、用户UI界面或基于CPU等资源使用情况，对应用容器进行规模扩大或规模裁减

服务发现

用户不需要使用额外的服务发现机制，就能够基于kubernetes自身能力实现服务发现和负载均衡

滚动更新

可以根据应用的变化，对应用容器运行的应用，进行一次性或批量式更新

版本回退

可以根据应用部署情况，对应用容器运行的应用，进行历史版本即时回退

密钥和配置管理

在不需要重新构建镜像的情况下，可以部署和更新密钥和应用配置，类似热部署

存储编排

自动实现存储系统挂在及应用，特别对有状态应用实现数据持久化非常重要。存储系统可以来自于本地目录、网络存储(NFS、Gluster、Ceph)等、公共云存储服务。

批处理

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

K8s集群架构组件

Master node（主控节点）和worker node(工作节点)

Master Node组件

API server

集群统一入口，以restful方式，交给etcd存储

Scheduler

节点调度，选择node节点进行应用部署

Controller-manager

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

ETCD

理解为一种存储系统，用于保存集群相关的数据

Work node组件

Kubelet

Master 派到node节点的代表，管理本机容器

Kube-proxy

提供网络代理，负载均衡等操作

4．K8s核心概念

1) pod

K8s中最小部署单元，一组容器的集合。一个Pod中的容器是共享网络；生命周期短暂，服务器重启后，原来的pod就不存在了。

2）Controller

确保预期的pod副本数量

无状态应用部署

有状态应用部署(例如依赖存储，网络IP唯一，有特定条件才可使用)

确保所有的node都运行统一个pod

一次性任务和定时任务

3）Service

定义一组pod的访问规则

总体过程：通过service统一入口进行访问，由controller创建pod进行部署，一个pod是一组容器的集合

5 搭建k8s环境

5.1 搭建k8s环境平台规划

5.1.1 单Master集群

5.1.2 多Master集群

5.2 服务硬件配置要求

5.2.1 测试环境

Master ：2核cpu，4g内存 20G硬盘

Node：4核 8G内存硬盘40G

5.2.2 生产环境

Master：8核 8G内存

Node：16核 16G 内存

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

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

5.2.4 禁止swap分区

如果不禁止，搭建集群会报错，禁用方法如下：

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

5.3 搭建k8s集群部署方式

部署kubernetes集群主要两种方式：

Kubeadm

Kubeadm是一个k8s部署工具，提供kubeadm init和kubeadm join，用于快速部署kubernetes集群。Kubeadm是官方那个社区推出的一个用于快速部署kubernetes集群的工具，这个工具能够通过两条指令完成一个kubernetes集群的部署：

创建一个Master节点 kubeadm init

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

官方地址：https://kubernetes.io/docs/reference/setup-tools/kubeadm/

二进制包

从github下载发行版的二进制包，手动部署每个组建，组成kubernetes集群

Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署kubernetes集群，虽然动手部署麻烦，其间可以学到很多工作原理，也利于后期维护。

5.4 kubeadm部署步骤

5.4.1 关闭防火墙？生产不能关防火墙

5.4.2 关闭selinux

sed -i 's/enforcing/disabled/' /etc/selinux/config #永久关闭，需要重启系统

setenforce 0 # 临时关闭

5.4.3 关闭swap分区

$ swapoff -a # 临时

$ sed -ri 's/.*swap.*/#&/' /etc/fstab # 永久

5.4.4 根据规划设置主机名

$ hostnamectl set-hostname <hostname>

5.4.5 在master添加hosts

$ cat >> /etc/hosts << EOF

192.168.1.120 master

192.168.1.121 node1

192.168.1.122 node2

EOF

5.4.6 每台服务器都设置将桥接的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 #生效

5.4.7 时间同步

$ yum install ntpdate –y

$ ntpdate time.windows.com

5.5 所有节点安装docker/kubeadm/kubelet

Kubernetes默认CRI(容器运行时)为docker，因此需要先安装docker

5.5.1所有节点安装docker

官网：https://docs.docker.com/engine/install/centos/

卸载旧版本docker

yum remove docker \

docker-client \

docker-client-latest \

docker-common \

docker-latest \

docker-latest-logrotate \

docker-logrotate \

docker-engine

设置yum源

$ yum install -y yum-utils

$ yum-config-manager \

--add-repo \

https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

$ yum -y install docker-ce-17.09.0.ce

$ systemctl start docker

$ systemctl enable docker

$ docker –version

设置镜像加速

$ cat > /etc/docker/daemon.json << EOF

{

"registry-mirrors": ["https://azmefg7j.mirror.aliyuncs.com"]

}

EOF

* 重新启动docker

systemctl restart docker

4.5.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

5.5.3 所有节点安装kubeadm，kubelet和kubectl

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

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

$ systemctl enable kubelet

5.6 部署kubernetes Master

4.6.1 在master上执行

$ kubeadm init \

--apiserver-advertise-address=192.168.1.120 \

--image-repository registry.aliyuncs.com/google_containers \

--kubernetes-version v1.18.0 \

--service-cidr=10.96.0.0/12 \

--pod-network-cidr=10.244.0.0/16

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

5.6.2 使用kubectl 工具：

1) 上述 kubeadm init初始化完成后，会有如下提示，在master中执行提示中的命令

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 命令查看节点状态

在master防火墙开通端口：6443

firewall-cmd --permanent --add-port=6443/tcp

firewall-cmd --reload

2) 在各work node中执行master提示中的下面命令

kubeadm join 192.168.1.120:6443 --token m7wt1b.bp7ady60ad6eoeky \

--discovery-token-ca-cert-hash sha256:f55a0ec36535ebefe2251e8709dc79898d9fbeff83e7cb9a7e81b7cb0e1dd361

默认token有效期为24小时，当过期后，该token就不可用了，这时需要重新创建token，操作如下：

$ kubeadm token create -print-join-command

5.7 安装pod网络插件（CNI）

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

由于raw.githubusercontent.com 是国外地址，域名无法解析，打开浏览器访问https://site.ip138.com/ 网站，输入域名解析成ip地址，填写到/etc/hosts文件中，重新执行上述命令就可以了。

例如：

使用命令查看pod运行状况

$ kubectl get pods -n kube-system

如下图所示，代表启动完成。

以上就是基于kubeadm搭建完成。

5.8 测试kubernetes集群

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

$ kubectl create deployment nginx --image=nginx

使用kubectl get pod 查看创建状态，状态为running时创建完成

$ kubectl expose deployment nginx --port=80 --type=NodePort

$ kubectl get pod,svc

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

6．使用二进制方式搭建集群

部署步骤简要说明：

* 创建多台虚拟机，安装linux操作系统

* 操作系统初始化

* 为etcd和apiserver自签证书

* 部署etcd集群

* 部署master组件：kube-apiserver，kube-controller-mamanger，kube-scheduler，etcd

* 部署node组件：kubelet，kube-proxy，docker，etcd

* 部署集群网络

6.1 安装要求和kubeadm一样

6.2 环境准备

6.2.1 软件环境

操作系统: centos7.1

Docker: 19-ce

Kubernetes 1.19

6.2.2 硬件环境

角色	IP	组件
Master	192.168.1.123	Kube-apiserver,kube-controler-manager,kube-scheduler,etcd
Node1	192.168.1.124	Kubelet,kube-proxy,docker,etcd
Node2	192.168.1.125	Kubelet,kube-proxy,docker,etcd

6.3 部署etcd集群

Etcd是一个分布式键值存储系统，kubernetes使用etcd进行数据存储，需要首先准备一个ETCD数据库，为解决etcd单点故障，应采用集群方式部署，这里使用3台组件集群，可容忍1台机器故障，当然，也可以使用5台组建集群，可容忍2台机器故障

节点名称	IP
Etcd-1	192.168.1.123
Etcd-2	192.168.1.124
Etcd-3	192.168.1.125

注意：为了节省机器，这里与k8s节点机器复用。也可以独立于k8s集群之外部署，只要apiserver能连接到就行

6.4 准备cfssl证书生成工具，为etcd和apiserver自签

Cfssl是一个开源的证书管理工具，使用json文件生成证书，相比openssl更方便使用，找任意一台服务器操作，这里使用master节点

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64

wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64

wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64

mv cfssl_linux-amd64 /usr/local/bin/cfssl

mv cfssljson_linux-amd64 /usr/local/bin/cfssljson

mv cfssl-certinfo_linux-amd64 /usr/local/bin/cfssl-certinfo

6.5 生成Etcd证书

(1) 自签证书颁发机构(CA)

创建工作目录

mkdir -p ~/TLS/{etcd,k8s}

cd TLS/etcd

自签CA：

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

生成证书：

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

$ ls *pem

（2）使用自签CA 签发Etcd HTTPS 证书

创建证书申请文件：

{

"CN": "etcd",

"hosts": [

"192.168.1.123",

"192.168.1.124",

"192.168.1.125"

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "BeiJing",

"ST": "BeiJing"

}

]

}

EOF

注：上述文件hosts 字段中IP 为所有etcd 节点的集群内部通信IP，一个都不能少！为了

方便后期扩容可以多写几个预留的IP。

生成证书：

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

$ ls server*pem

6.6 部署Etcd集群

从Github 下载二进制文件

下载地址：https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-

linux-amd64.tar.gz

以下在节点1 上操作，为简化操作，待会将节点1 生成的所有文件拷贝到节点2 和节点3.

（1）创建工作目录并解压二进制包

mkdir /opt/etcd/{bin,cfg,ssl} –p

tar zxvf etcd-v3.4.9-linux-amd64.tar.gz

mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/

（2）创建etcd 配置文件

cat > /opt/etcd/cfg/etcd.conf << EOF

#[Member]

ETCD_NAME="etcd-1"

ETCD_DATA_DIR="/var/lib/etcd/default.etcd"

ETCD_LISTEN_PEER_URLS="https://192.168.1.123:2380"

ETCD_LISTEN_CLIENT_URLS="https://192.168.1.123:2379"

#[Clustering]

ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.1.123:2380"

ETCD_ADVERTISE_CLIENT_URLS="https://192.168.1.123:2379"

ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.1.123:2380,etcd-

2=https://192.168.1.124:2380,etcd-3=https://192.168.1.125:2380"

ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"

ETCD_INITIAL_CLUSTER_STATE="new"

EOF

ETCD_NAME：节点名称，集群中唯一

ETCD_DATA_DIR：数据目录

ETCD_LISTEN_PEER_URLS：集群通信监听地址

ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址

ETCD_INITIAL_ADVERTISE_PEER_URLS：集群通告地址

ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址

ETCD_INITIAL_CLUSTER：集群节点地址

ETCD_INITIAL_CLUSTER_TOKEN：集群Token

ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new 是新集群，existing 表示加入

已有集群

（3）systemd 管理etcd

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

[Unit]

Description=Etcd Server

After=network.target

After=network-online.target

Wants=network-online.target

[Service]

Type=notify

EnvironmentFile=/opt/etcd/cfg/etcd.conf

ExecStart=/opt/etcd/bin/etcd \

--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 \

--logger=zap

Restart=on-failure

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

EOF

（4）拷贝刚才生成的证书

把刚才生成的证书拷贝到配置文件中的路径：

cp ~/TLS/etcd/ca*pem ~/TLS/etcd/server*pem /opt/etcd/ssl/

（5）启动并设置开机启动

systemctl daemon-reload

systemctl start etcd

systemctl enable etcd

（6）将上面节点1 所有生成的文件拷贝到节点2 和节点3

scp -r /opt/etcd/ root@192.168.31.72:/opt/

scp /usr/lib/systemd/system/etcd.service

root@192.168.31.72:/usr/lib/systemd/system/

scp -r /opt/etcd/ root@192.168.31.73:/opt/

scp /usr/lib/systemd/system/etcd.servicei

root@192.168.31.73:/usr/lib/systemd/system/

然后在节点2 和节点3 分别修改etcd.conf 配置文件中的节点名称和当前服务器IP：

vi /opt/etcd/cfg/etcd.conf

#[Member]

ETCD_NAME="etcd-1" # 修改此处，节点2 改为etcd-2，节点3 改为etcd-3

ETCD_DATA_DIR="/var/lib/etcd/default.etcd"

ETCD_LISTEN_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前服务器IP

ETCD_LISTEN_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器IP

#[Clustering]

ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前

服务器IP

ETCD_ADVERTISE_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器

ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.31.71:2380,etcd-

2=https://192.168.31.72:2380,etcd-3=https://192.168.31.73:2380"

ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"

ETCD_INITIAL_CLUSTER_STATE="new"

最后启动etcd 并设置开机启动，同上。

（7）查看集群状态

$ ETCDCTL_API=3

$ /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.1.123:2379,https://192.168.1.124:2379,https://192.168.1.125:2379" endpoint health

控制台输出

https://192.168.1.123:2379 is healthy: successfully committed proposal: took = 20.394306ms

https://192.168.1.124:2379 is healthy: successfully committed proposal: took = 27.749974ms

https://192.168.1.125:2379 is healthy: successfully committed proposal: took = 29.298205ms

如果输出上面信息，就说明集群部署成功。如果有问题第一步先看日志：

/var/log/message 或journalctl -u etcd

7、部署Master Node

7.1 生成kube-apiserver 证书

（1）自签证书颁发机构（CA）

$ 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

（2）生成证书：

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

ls *pem

ca-key.pem ca.pem

（3）使用自签CA 签发kube-apiserver HTTPS 证书

创建证书申请文件：

cd TLS/k8s

cat > server-csr.json<< EOF

{

"CN": "kubernetes",

"hosts": [

"10.0.0.1",

"127.0.0.1",

"192.168.1.123",

"192.168.1.124",

"192.168.1.125",

"192.168.1.126",

"192.168.1.127",

"192.168.1.128",

"192.168.1.129",

"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

ls server*pem

server-key.pem server.pem

7.2 从Github 下载二进制文件

下载地址：

https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-

1.18.md#v1183

注：打开链接你会发现里面有很多包，下载一个server 包就够了，包含了Master 和

Worker Node 二进制文件。

6.3 解压二进制包

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

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

cd kubernetes/server/bin

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

cp kubectl /usr/bin/

6.4 部署kube-apiserver

1. 创建配置文件

cat > /opt/kubernetes/cfg/kube-apiserver.conf << EOF

KUBE_APISERVER_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--etcd-servers=https://192.168.1.123:2379,https://192.168.1.124:2379,https://192.168.1.125:2379 \\

--bind-address=192.168.1.123 \\

--secure-port=6443 \\

--advertise-address=192.168.1.123 \\

--allow-privileged=true \\

--service-cluster-ip-range=10.0.0.0/24 \\

--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\

--authorization-mode=RBAC,Node \\

--enable-bootstrap-token-auth=true \\

--token-auth-file=/opt/kubernetes/cfg/token.csv \\

--service-node-port-range=30000-32767 \\

--kubelet-client-certificate=/opt/kubernetes/ssl/server.pem \\

--kubelet-client-key=/opt/kubernetes/ssl/server-key.pem \\

--tls-cert-file=/opt/kubernetes/ssl/server.pem \\

--tls-private-key-file=/opt/kubernetes/ssl/server-key.pem \\

--client-ca-file=/opt/kubernetes/ssl/ca.pem \\

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

--etcd-cafile=/opt/etcd/ssl/ca.pem \\

--etcd-certfile=/opt/etcd/ssl/server.pem \\

--etcd-keyfile=/opt/etcd/ssl/server-key.pem \\

--audit-log-maxage=30 \\

--audit-log-maxbackup=3 \\

--audit-log-maxsize=100 \\

--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"

EOF

注：上面两个\ \ 第一个是转义符，第二个是换行符，使用转义符是为了使用EOF 保留换

行符。

–logtostderr：启用日志

—v：日志等级

–log-dir：日志目录

–etcd-servers：etcd 集群地址

–bind-address：监听地址

–secure-port：https 安全端口

–advertise-address：集群通告地址

–allow-privileged：启用授权

–service-cluster-ip-range：Service 虚拟IP 地址段

–enable-admission-plugins：准入控制模块

–authorization-mode：认证授权，启用RBAC 授权和节点自管理

–enable-bootstrap-token-auth：启用TLS bootstrap 机制

–token-auth-file：bootstrap token 文件

–service-node-port-range：Service nodeport 类型默认分配端口范围

–kubelet-client-xxx：apiserver 访问kubelet 客户端证书

–tls-xxx-file：apiserver https 证书

–etcd-xxxfile：连接Etcd 集群证书

–audit-log-xxx：审计日志

2. 拷贝刚才生成的证书

把刚才生成的证书拷贝到配置文件中的路径：

cp ~/TLS/k8s/ca*pem ~/TLS/k8s/server*pem /opt/kubernetes/ssl/

3. 启用TLS Bootstrapping 机制

TLS Bootstraping：Master apiserver 启用TLS 认证后，Node 节点kubelet 和kubeproxy

要与kube-apiserver 进行通信，必须使用CA 签发的有效证书才可以，当Node

节点很多时，这种客户端证书颁发需要大量工作，同样也会增加集群扩展复杂度。为了

简化流程，Kubernetes 引入了TLS bootstraping 机制来自动颁发客户端证书，kubelet

会以一个低权限用户自动向apiserver 申请证书，kubelet 的证书由apiserver 动态签署。

所以强烈建议在Node 上使用这种方式，目前主要用于kubelet，kube-proxy 还是由我

们统一颁发一个证书。

TLS bootstraping 工作流程：

创建上述配置文件中token 文件：

cat > /opt/kubernetes/cfg/token.csv << EOF

c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node-bootstrapper"

EOF

格式：token，用户名，UID，用户组

token 也可自行生成替换：

head -c 16 /dev/urandom | od -An -t x | tr -d ' '

4. systemd 管理apiserver

cat > /usr/lib/systemd/system/kube-apiserver.service << EOF

[Unit]

Description=Kubernetes API Server

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

[Service]

EnvironmentFile=/opt/kubernetes/cfg/kube-apiserver.conf

ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS

Restart=on-failure

[Install]

WantedBy=multi-user.target

EOF

5. 启动并设置开机启动

systemctl daemon-reload

systemctl start kube-apiserver

systemctl enable kube-apiserver

开通8080端口

6. 授权kubelet-bootstrap 用户允许请求证书

kubectl create clusterrolebinding kubelet-bootstrap \

--clusterrole=system:node-bootstrapper \

--user=kubelet-bootstrap

7.5 部署kube-controller-manager

1. 创建配置文件

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

KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--leader-elect=true \\

--master=127.0.0.1:8080 \\

--bind-address=127.0.0.1 \\

--allocate-node-cidrs=true \\

--cluster-cidr=10.244.0.0/16 \\

--service-cluster-ip-range=10.0.0.0/24 \\

--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

–master：通过本地非安全本地端口8080 连接apiserver。

–leader-elect：当该组件启动多个时，自动选举（HA）

–cluster-signing-cert-file/–cluster-signing-key-file：自动为kubelet 颁发证书的CA，与apiserver 保持一致

2. systemd 管理controller-manager

cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF

[Unit]

Description=Kubernetes Controller Manager

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

[Service]

EnvironmentFile=/opt/kubernetes/cfg/kube-controller-manager.conf

ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS

Restart=on-failure

[Install]

WantedBy=multi-user.target

EOF

3. 启动并设置开机启动

systemctl daemon-reload

systemctl start kube-controller-manager

systemctl enable kube-controller-manager

6.6 部署kube-scheduler

1. 创建配置文件

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

KUBE_SCHEDULER_OPTS="--logtostderr=false \

--v=2 \

--log-dir=/opt/kubernetes/logs \

--leader-elect \

--master=127.0.0.1:8080 \

--bind-address=127.0.0.1"

EOF

–master：通过本地非安全本地端口8080 连接apiserver。

–leader-elect：当该组件启动多个时，自动选举（HA）

2. systemd 管理scheduler

cat > /usr/lib/systemd/system/kube-scheduler.service << EOF

[Unit]

Description=Kubernetes Scheduler

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

[Service]

EnvironmentFile=/opt/kubernetes/cfg/kube-scheduler.conf

ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS

Restart=on-failure

[Install]

WantedBy=multi-user.target

EOF

3. 启动并设置开机启动

systemctl daemon-reload

systemctl start kube-scheduler

systemctl enable kube-scheduler

4. 查看集群状态

所有组件都已经启动成功，通过kubectl 工具查看当前集群组件状态：

kubectl get cs

NAME STATUS MESSAGE ERROR

scheduler Healthy ok

controller-manager Healthy ok

etcd-2 Healthy {"health":"true"}

etcd-1 Healthy {"health":"true"}

etcd-0 Healthy {"health":"true"}

如上输出说明Master 节点组件运行正常。

快速添加自启动命令:

$ for i in $(ls /opt/kubernetes/bin);do systemctl enable $i;done

8、部署Worker Node

下面还是在Master Node 上操作，即同时作为Worker Node

8.1 创建工作目录并拷贝二进制文件

在所有worker node 创建工作目录：

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

从master 节点拷贝：

cd kubernetes/server/bin

cp kubelet kube-proxy /opt/kubernetes/bin # 本地拷贝

8.2 部署kubelet

1. 创建配置文件

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

KUBELET_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--hostname-override=master \\

--network-plugin=cni \\

--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\

--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\

--config=/opt/kubernetes/cfg/kubelet-config.yml \\

--cert-dir=/opt/kubernetes/ssl \\

--pod-infra-container-image=wangbaozhong/pause-amd64:3.0"

EOF

–hostname-override：显示名称，集群中唯一

–network-plugin：启用CNI

–kubeconfig：空路径，会自动生成，后面用于连接apiserver

–bootstrap-kubeconfig：首次启动向apiserver 申请证书

–config：配置参数文件

–cert-dir：kubelet 证书生成目录

–pod-infra-container-image：管理Pod 网络容器的镜像

2. 配置参数文件

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

kind: KubeletConfiguration

apiVersion: kubelet.config.k8s.io/v1beta1

address: 0.0.0.0

port: 10250

readOnlyPort: 10255

cgroupDriver: cgroupfs

clusterDNS:

- 10.0.0.2

clusterDomain: cluster.local

failSwapOn: false

authentication:

anonymous:

enabled: false

webhook:

cacheTTL: 2m0s

enabled: true

x509:

clientCAFile: /opt/kubernetes/ssl/ca.pem

authorization:

mode: Webhook

webhook:

cacheAuthorizedTTL: 5m0s

cacheUnauthorizedTTL: 30s

evictionHard:

imagefs.available: 15%

memory.available: 100Mi

nodefs.available: 10%

nodefs.inodesFree: 5%

maxOpenFiles: 1000000

maxPods: 110

EOF

开通端口10250，10255

3. 生成bootstrap.kubeconfig 文件

$ KUBE_APISERVER="https://192.168.1.123:6443" # apiserver IP:PORT

$ TOKEN="c47ffb939f5ca36231d9e3121a252940" # 与token.csv 里保持一致

# 生成kubelet bootstrap kubeconfig 配置文件

$ kubectl config set-cluster kubernetes \

--certificate-authority=/opt/kubernetes/ssl/ca.pem \

--embed-certs=true \

--server=${KUBE_APISERVER} \

--kubeconfig=bootstrap.kubeconfig

$ kubectl config set-credentials "kubelet-bootstrap" \

--token=${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

拷贝到配置文件路径：

cp bootstrap.kubeconfig /opt/kubernetes/cfg

4. systemd 管理kubelet

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

[Unit]

Description=Kubernetes Kubelet

After=docker.service

[Service]

EnvironmentFile=/opt/kubernetes/cfg/kubelet.conf

ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS

Restart=on-failure

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

EOF

5. 启动并设置开机启动

systemctl daemon-reload

systemctl start kubelet

systemctl enable kubelet

8.3 批准kubelet 证书申请并加入集群

# 查看kubelet 证书请求

kubectl get csr

NAME AGE SIGNERNAME

REQUESTOR CONDITION

node-csr-uCEGPOIiDdlLODKts8J658HrFq9CZ--K6M4G7bjhk8A 6m3s

kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending

# 批准申请

kubectl certificate approve node-csr-uCEGPOIiDdlLODKts8J658HrFq9CZ--

K6M4G7bjhk8A

# 查看节点

kubectl get node

注：由于网络插件还没有部署，节点会没有准备就绪NotReady

8.4 部署kube-proxy

1. 创建配置文件

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

KUBE_PROXY_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--config=/opt/kubernetes/cfg/kube-proxy-config.yml"

EOF

2. 配置参数文件

cat > /opt/kubernetes/cfg/kube-proxy-config.yml << EOF

kind: KubeProxyConfiguration

apiVersion: kubeproxy.config.k8s.io/v1alpha1

bindAddress: 0.0.0.0

metricsBindAddress: 0.0.0.0:10249

clientConnection:

kubeconfig: /opt/kubernetes/cfg/kube-proxy.kubeconfig

hostnameOverride: node1

clusterCIDR: 10.0.0.0/24

mode: ipvs

ipvs:

scheduler: "rr"

iptables:

masqueradeAll: true

EOF

mode: ipvs ---模式，使用ipvs(性能比较好),默认是IPtables

开通10249端口

3. 生成kube-proxy.kubeconfig 文件

生成kube-proxy 证书：

# 切换工作目录

cd TLS/k8s

# 创建证书请求文件

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

ls kube-proxy*pem

kube-proxy-key.pem kube-proxy.pem

cp kube-proxy*pem /opt/kubernetes/ssl/

scp ca.pem kube-proxy*pem 192.168.9.32:/opt/kubernetes/ssl/ ---只拷贝这3个即可

生成kubeconfig 文件：

KUBE_APISERVER="https://192.168.1.123:6443"

kubectl config set-cluster kubernetes \

--certificate-authority=/opt/kubernetes/ssl/ca.pem \

--embed-certs=true \

--server=${KUBE_APISERVER} \

--kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \

--client-certificate=./kube-proxy.pem \

--client-key=./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

拷贝到配置文件指定路径：

cp kube-proxy.kubeconfig /opt/kubernetes/cfg/

4. systemd 管理kube-proxy

cat > /usr/lib/systemd/system/kube-proxy.service << EOF

[Unit]

Description=Kubernetes Proxy

After=network.target

[Service]

EnvironmentFile=/opt/kubernetes/cfg/kube-proxy.conf

ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS

Restart=on-failure

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

EOF

5. 启动并设置开机启动

systemctl daemon-reload

systemctl start kube-proxy

systemctl enable kube-proxy

8.5 部署CNI 网络

先准备好CNI 二进制文件：

下载地址：

https://github.com/containernetworking/plugins/releases/download/v0.9.1/cni-plugins-linux-amd64-v0.9.1.tgz

解压二进制包并移动到默认工作目录：

mkdir /opt/cni/bin

tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin

部署CNI 网络：

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kubeflannel.yml

sed -i -r "s#quay.io/coreos/flannel:.*-amd64#wangbaozhong/flannel:v0.12.0-

amd64#g" kube-flannel.yml

生成kube-flannel.yml

$ cat > kube-flannel.yml << EOF

---

apiVersion: policy/v1beta1

kind: PodSecurityPolicy

metadata:

annotations:

seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default

seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default

apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default

apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default

spec:

privileged: false

volumes:

- configMap

- secret

- emptyDir

- hostPath

allowedHostPaths:

- pathPrefix: "/etc/cni/net.d"

- pathPrefix: "/etc/kube-flannel"

- pathPrefix: "/run/flannel"

readOnlyRootFilesystem: false

# Users and groups

runAsUser:

rule: RunAsAny

supplementalGroups:

rule: RunAsAny

fsGroup:

rule: RunAsAny

# Privilege Escalation

allowPrivilegeEscalation: false

defaultAllowPrivilegeEscalation: false

# Capabilities

allowedCapabilities: ['NET_ADMIN']

defaultAddCapabilities: []

requiredDropCapabilities: []

# Host namespaces

hostPID: false

hostIPC: false

hostNetwork: true

hostPorts:

- min: 0

max: 65535

# SELinux

seLinux:

# SELinux is unsed in CaaSP

rule: 'RunAsAny'

---

kind: ClusterRole

apiVersion: rbac.authorization.k8s.io/v1beta1

metadata:

rules:

- apiGroups: ['extensions']

resources: ['podsecuritypolicies']

verbs: ['use']

resourceNames: ['psp.flannel.unprivileged']

- apiGroups:

- ""

resources:

- pods

verbs:

- get

- apiGroups:

- ""

resources:

- nodes

verbs:

- list

- watch

- apiGroups:

- ""

resources:

- nodes/status

verbs:

- patch

---

kind: ClusterRoleBinding

apiVersion: rbac.authorization.k8s.io/v1beta1

metadata:

roleRef:

apiGroup: rbac.authorization.k8s.io

kind: ClusterRole

subjects:

- kind: ServiceAccount

namespace: kube-system

---

apiVersion: v1

kind: ServiceAccount

metadata:

namespace: kube-system

---

kind: ConfigMap

apiVersion: v1

metadata:

namespace: kube-system

labels:

tier: node

app: flannel

data:

cni-conf.json: |

{

"cniVersion": "0.2.0",

"name": "cbr0",

"plugins": [

{

"type": "flannel",

"delegate": {

"hairpinMode": true,

"isDefaultGateway": true

}

{

"type": "portmap",

"capabilities": {

"portMappings": true

}

]

}

net-conf.json: |

{

"Network": "10.244.0.0/16", ---这个网络要与kube-controller-manager.conf的cluster-cidr的一致

"Backend": {

"Type": "vxlan"

}

---

apiVersion: apps/v1

kind: DaemonSet

metadata:

namespace: kube-system

labels:

tier: node

app: flannel

spec:

selector:

matchLabels:

app: flannel

template:

metadata:

labels:

tier: node

app: flannel

spec:

affinity:

nodeAffinity:

requiredDuringSchedulingIgnoredDuringExecution:

nodeSelectorTerms:

- matchExpressions:

- key: beta.kubernetes.io/os

operator: In

values:

- linux

- key: beta.kubernetes.io/arch

operator: In

values:

- amd64

hostNetwork: true

tolerations:

- operator: Exists

effect: NoSchedule

serviceAccountName: flannel

initContainers:

- name: install-cni

image: wangbaozhong/flannel:v0.11.0-amd64

command:

- cp

args:

- -f

- /etc/kube-flannel/cni-conf.json

- /etc/cni/net.d/10-flannel.conflist

volumeMounts:

- name: cni

mountPath: /etc/cni/net.d

- name: flannel-cfg

mountPath: /etc/kube-flannel/

containers:

- name: kube-flannel

image: wangbaozhong/flannel:v0.11.0-amd64

command:

- /opt/bin/flanneld

args:

- --ip-masq

- --kube-subnet-mgr

resources:

requests:

cpu: "100m"

memory: "50Mi"

limits:

cpu: "100m"

memory: "50Mi"

securityContext:

privileged: false

capabilities:

add: ["NET_ADMIN"]

env:

- name: POD_NAME

valueFrom:

fieldRef:

fieldPath: metadata.name

- name: POD_NAMESPACE

valueFrom:

fieldRef:

fieldPath: metadata.namespace

volumeMounts:

- name: run

mountPath: /run/flannel

- name: flannel-cfg

mountPath: /etc/kube-flannel/

volumes:

- name: run

hostPath:

path: /run/flannel

- name: cni

hostPath:

path: /etc/cni/net.d

- name: flannel-cfg

configMap:

默认镜像地址无法访问，修改为docker hub 镜像仓库。

kubectl apply -f kube-flannel.yml

kubectl get pods -n kube-system

kubectl get node

部署好网络插件，Node 准备就绪。

8.6 授权apiserver 访问kubelet

cat > apiserver-to-kubelet-rbac.yaml<< EOF

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRole

metadata:

annotations:

rbac.authorization.kubernetes.io/autoupdate: "true"

labels:

kubernetes.io/bootstrapping: rbac-defaults

rules:

- apiGroups:

- ""

resources:

- nodes/proxy

- nodes/stats

- nodes/log

- nodes/spec

- nodes/metrics

- pods/log

verbs:

- "*"

---

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRoleBinding

metadata:

namespace: ""

roleRef:

apiGroup: rbac.authorization.k8s.io

kind: ClusterRole

subjects:

- apiGroup: rbac.authorization.k8s.io

kind: User

EOF

kubectl apply -f apiserver-to-kubelet-rbac.yaml

7.7 新增加Worker Node

1. 拷贝已部署好的Node 相关文件到新节点

在master 节点将Worker Node 涉及文件拷贝到新节点192.168.31.72/73

scp -r /opt/kubernetes root@192.168.31.72:/opt/

scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service

root@192.168.31.72:/usr/lib/systemd/system

scp -r /opt/cni/ root@192.168.31.72:/opt/

scp /opt/kubernetes/ssl/ca.pem root@192.168.31.72:/opt/kubernetes/ssl

2. 删除kubelet 证书和kubeconfig 文件

rm /opt/kubernetes/cfg/kubelet.kubeconfig

rm -f /opt/kubernetes/ssl/kubelet*

注：这几个文件是证书申请审批后自动生成的，每个Node 不同，必须删除重新生成。

3. 修改主机名

vi /opt/kubernetes/cfg/kubelet.conf

--hostname-override=k8s-node1

vi /opt/kubernetes/cfg/kube-proxy-config.yml

hostnameOverride: k8s-node1

4. 启动并设置开机启动

systemctl daemon-reload

systemctl start kubelet

systemctl enable kubelet

systemctl start kube-proxy

systemctl enable kube-proxy

5. 在Master 上批准新Node kubelet 证书申请

kubectl get csr

NAME AGE SIGNERNAME

REQUESTOR CONDITION

node-csr-4zTjsaVSrhuyhIGqsefxzVoZDCNKei-aE2jyTP81Uro 89s

kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending

kubectl certificate approve node-csr-4zTjsaVSrhuyhIGqsefxzVoZDCNKeiaE2jyTP81Uro

6. 查看Node 状态

Kubectl get node

Node2（192.168.31.73 ）节点同上。记得修改主机名！

FOREVERHOPE_WBZ

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
笔记 K8S 环境搭建 kubeadm 与二进制方式（初学）

Etcd是一个分布式键值存储系统，kubernetes使用etcd进行数据存储，需要首先准备一个ETCD数据库，为解决etcd单点故障，应采用集群方式部署，这里使用3台组件集群，可容忍1台机器故障，当然，也可以使用5台组建集群，可容忍2台机器故障。* 部署master组件：kube-apiserver，kube-controller-mamanger，kube-scheduler，etcd。总体过程：通过service统一入口进行访问，由controller创建pod进行部署，一个pod是一组容器的集合。
复制链接

扫一扫