1. Toy模板网首页
  2. > Toy博客

二级制部署kubernetes（1.20）

9月前 作者：Sure云小硕 分类：Toy博客 阅读(34) 违法举报

这篇具有很好参考价值的文章主要介绍了二级制部署kubernetes（1.20）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

😘作者简介：一名运维工作人员。
👊宣言：人生就是B（birth）和D（death）之间的C（choise），做好每一个选择。
🙏创作不易，动动小手给个点赞加关注吧，有什么意见评论区告诉我，一起学习。 

 一、前言

生产环境中有两种部署k8s的方法：

       

kubeadm
Kubeadm是一个K8s部署工具，提供kubeadm init和kubeadm join，用于快速部署Kubernetes集群。

二进制包
从github下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群。
小结：Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署Kubernetes集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

这里就使用二进制的方式来部署k8s，在企业中一般也是使用二级制来部署。

1、kubernetes核心概念

  • k8s-master 负责任务调度，控制节点
  • k8s-node1 承载运行pod(容器)
  • k8s-node2 承载运行pod(容器

1）Master

Master主要负责资源调度，控制pod副本，和提供统一访问集群的入口。--核心节点也是管理节点

2）Node

Node是Kubernetes集群架构中运行Pod的服务节点。Node是Kubernetes集群操作的单元，用来承载被分配Pod的运行，是Pod运行的宿主机，由Master管理，并汇报容器状态给Master，同时根据Master要求管理容器生命周期。

3）Node IP

   Node节点的IP地址，是Kubernetes集群中每个节点的物理网卡的IP地址，是真实存在的物理网络，所有属于这个网络的服务器之间都能通过这个网络直接通信；

4）Pod

   Pod直译是豆荚，可以把容器想像成豆荚里的豆子，把一个或多个关系紧密的豆子包在一起就是豆荚（一个Pod）。在k8s中我们不会直接操作容器，而是把容器包装成Pod再进行管理运行于Node节点上， 若干相关容器的组合。Pod内包含的容器运行在同一宿主机上，使用相同的网络命名空间、IP地址和端口，能够通过localhost进行通信。Pod是k8s进行创建、调度和管理的最小单位，它提供了比容器更高层次的抽象，使得部署和管理更加灵活。一个Pod可以包含一个容器或者多个相关容器。

   Pod 就是 k8s 集群里的"应用"；而一个平台应用，可以由多个容器组成。

二、服务器规划

1、一Matser双Node

因为电脑配置原因，做不了高可用，所以以一主二从为例。

1）服务器规划

主机 IP 组件
k8s-master         192.168.79.148

kube-apiserver，kube-controller-manager，kube-scheduler，etcd

k8s-node1

 192.168.79.149

kubelet，kube-proxy，docker，etcd
k8s-node2 192.168.79.150

kubelet，kube-proxy，docker，etcd

2）服务器架构

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

 Kubernetes Master：

集群控制节点，负责整个集群的管理和控制，基本上Kubernetes所有的控制命令都是发给它，它来负责具体的执行过程，我们后面所有执行的命令基本都是在Master节点上运行的；

包含如下组件:
1.Kubernetes API Server
作为Kubernetes系统的入口，其封装了核心对象的增删改查操作，以RESTful API接口方式提供给外部客户和内部组件调用。维护的REST对象持久化到Etcd中存储。

2.Kubernetes Scheduler
为新建立的Pod进行节点(node)选择(即分配机器)，负责集群的资源调度。组件抽离，可以方便替换成其他调度器。

3.Kubernetes Controller
负责执行各种控制器，目前已经提供了很多控制器来保证Kubernetes的正常运行。
   Replication Controller
       管理维护Replication Controller，关联Replication Controller和Pod，保证Replication Controller定义的副本数量与实际运行Pod数量一致。

​  Deployment Controller
       管理维护Deployment，关联Deployment和Replication  Controller，保证运行指定数量的Pod。当Deployment更新时，控制实现Replication  Controller和　Pod的更新。

   Node Controller
      管理维护Node，定期检查Node的健康状态，标识出(失效|未失效)的Node节点。

   Namespace Controller
      管理维护Namespace，定期清理无效的Namespace，包括Namesapce下的API对象，比如Pod、Service等。

   Service Controller
      管理维护Service，提供负载以及服务代理。

   EndPoints Controller
      管理维护Endpoints，关联Service和Pod，创建Endpoints为Service的后端，当Pod发生变化时，实时更新Endpoints。

   Service Account Controller
      管理维护Service Account，为每个Namespace创建默认的Service Account，同时为Service Account创建Service Account Secret。

   Persistent Volume Controller
      管理维护Persistent Volume和Persistent Volume  Claim，为新的Persistent Volume Claim分配Persistent Volume进行绑定，为释放的Persistent  Volume执行清理回收。

   Daemon Set Controller
      管理维护Daemon Set，负责创建Daemon Pod，保证指定的Node上正常的运行Daemon Pod。

　　Job Controller
      管理维护Job，为Jod创建一次性任务Pod，保证完成Job指定完成的任务数目

   Pod Autoscaler Controller
      实现Pod的自动伸缩，定时获取监控数据，进行策略匹配，当满足条件时执行Pod的伸缩动作。

Kubernetes Node：
除了Master，Kubernetes集群中的其他机器被称为Node节点，Node节点才是Kubernetes集群中的工作负载节点，每个Node都会被Master分配一些工作负载（Docker容器），当某个Node宕机，其上的工作负载会被Master自动转移到其他节点上去；

包含如下组件:
　　1.Kubelet
　　　　负责管控容器，Kubelet会从Kubernetes API Server接收Pod的创建请求，启动和停止容器，监控容器运行状态并汇报给Kubernetes API Server。

　　2.Kubernetes Proxy
　　　　负责为Pod创建代理服务，Kubernetes Proxy会从Kubernetes API  Server获取所有的Service信息，并根据Service的信息创建代理服务，实现Service到Pod的请求路由和转发，从而实现Kubernetes层级的虚拟转发网络。

　　3.Docker Engine（docker），Docker引擎，负责本机的容器创建和管理工作；  
　　4.网络插件：解决node之间pod的通信问题。

数据库

etcd数据库，可以部署到master、node上，推荐独立部署
分布式键值存储系统。用于保存集群状态数据，比如Pod、Service等对象信息

3）配置主机映射 

[root@k8s-master ~]# vim /etc/hosts
[root@k8s-master ~]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.79.148	k8s-master
192.168.79.149	k8s-node1
192.168.79.150	k8s-node2

 使用scp将hosts文件发送给node1和node2。

三、Etc集群

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

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

1、准备cfssl证书生成工具

cfssl是一个开源的证书管理工具，使用json文件生成证书，相比openssl更方便使用。

cfssl工具的网盘

链接：https://pan.baidu.com/s/1zf6ZaDYS2r4OZWz0zHr7zQ?pwd=nar2 
提取码：nar2 

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

这里我用rz将本地的cfssl工具拷到虚拟机，然后给他们执行的命令，为了方便使用这些工具，将这些拷到/usr/bin目录下。

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

这样就可以直接使用cfssl、cfssl-certinfo、cfssljson这三个命令了。

2、生成Etcd证书

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

先创建工作目录，并进入到该目录

mkdir opt/etcd -p

cd opt/etcd

[root@k8s-master1 etcd]#vim ca-config.json
[root@k8s-master etcd]# cat ca-config.json 
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}


[root@k8s-master etcd]# cat ca-csr.json 
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}

2）生成证书

[root@k8s-master etcd]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca -


[root@k8s-master etcd]# ls
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem

可以看到当前目录多了两个ca-key.pem  ca.pem文件，这就是证书文件。

3）使用自签CA签发Etcd HTTPS证书

创建证书申请文件
[root@k8s-master1 etcd]# vim server-csr.json
[root@k8s-master etcd]# cat server-csr.json
{
    "CN": "etcd",
    "hosts": [
    "192.168.79.148",
    "192.168.79.149",
    "192.168.79.150"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}

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

#生成证书
[root@k8s-master1 etcd]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

#查看证书生成情况
[root@k8s-master etcd]# ls *pem
ca-key.pem  ca.pem  server-key.pem  server.pem

又多出server-key.pem和server.pem文件。

3、部署Etcd集群

首先需要etcd的二进制文件。

etcd的二进制文件的网盘。

链接：https://pan.baidu.com/s/1va2DkgJSZ-lL5T5xBKVodg?pwd=j5gt 
提取码：j5gt 

1）获取etcd的软件包

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

注意：我这里为了防止etcd目录下文件太多太乱，先进入到了家目录，然后通过rz将本地的etcd包拷到虚拟机。

2）解压etcd包

 解压后在etcd-v3.4.9-linux-amd64目录下有etcd和etcdctl两个可执行的文件。

[root@k8s-master ~]# tar xfz etcd-v3.4.9-linux-amd64.tar.gz

[root@k8s-master ~]# ls
anaconda-ks.cfg  cfssl_1.6.4_linux_amd64  cfssl-certinfo_1.6.4_linux_amd64  cfssljson_1.6.4_linux_amd64  etcd-v3.4.9-linux-amd64  etcd-v3.4.9-linux-amd64.tar.gz  opt

[root@k8s-master ~]# ls etcd-v3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md

3）创建工作目录并且将etcd和etcdctl拷到工作目录

[root@k8s-master ~]# mkdir -p /opt/etcd/{bin,cfg,ssl}
[root@k8s-master ~]# cp etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
[root@k8s-master ~]# tree /opt/
/opt/
└── etcd
    ├── bin
    │   ├── etcd
    │   └── etcdctl
    ├── cfg
    └── ssl

这里在/opt/etcd/目录下创建了bin，cfg，ssl三个文件夹，bin存放的是命令文件，cfg存放的是 

4）创建etcd的配置文件

[root@k8s-master ~]# vim /opt/etcd/cfg/etcd.conf
[root@k8s-master ~]# cat /opt/etcd/cfg/etcd.conf
#[Member]
ETCD_NAME="etcd-1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.79.148:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.79.148:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.79.148:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.79.148:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.79.148:2380,etcd-2=https://192.168.79.149:2380,etcd-3=https://192.168.79.150:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

 *参数解释

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

•      ETCD_DATA_DIR：数据目录

•      ETCD_LISTEN_PEER_URLS：集群通信监听地址，填本机ip

•      ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址，填本机ip

•      ETCD_INITIAL_ADVERTISE_PEERURLS：集群通告地址，填本机ip

•      ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址，填本机ip

•      ETCD_INITIAL_CLUSTER：集群节点地址

•      ETCD_INITIALCLUSTER_TOKEN：集群Token

•      ETCD_INITIALCLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群

 5）system管理etcd

system管理etcd需要再/usr/lib/systemd/system下编写相应的service文件。

[root@k8s-master ~]# vim /usr/lib/systemd/system/etcd.service
[root@k8s-master ~]# 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.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

注意这里的证书文件要记得拷到/opt/etcd/bin/目录下，这里system管理etcd读取的证书写到了这个目录，当然也可以改，就是为了方便整理，是放到了这个文件夹下。

[root@k8s-master ~]# cp  opt/etcd/*pem   /opt/etcd/ssl/
[root@k8s-master ~]# tree /opt/
/opt/
└── etcd
    ├── bin
    │   ├── etcd
    │   └── etcdctl
    ├── cfg
    │   └── etcd.conf
    └── ssl
        ├── ca-key.pem
        ├── ca.pem
        ├── server-key.pem
        └── server.pem

4 directories, 7 files

将这些证书和etcd.conf以及service的文件、etcd执行文件都要拷到node1和node2上，其中etcd.conf内需要更改ip。

6）拷贝文件到node1和node2并修改etcd.conf文件

6.1）node1和node2创建相同的工作目录

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

拷贝etcd.conf文件
[root@k8s-master ~]# scp /opt/etcd/cfg/etcd.conf  k8s-node1:/opt/etcd/cfg/
  
[root@k8s-master ~]# scp /opt/etcd/cfg/etcd.conf  k8s-node2:/opt/etcd/cfg/


#拷贝证书
[root@k8s-master ~]# scp /opt/etcd/ssl/* k8s-node1:/opt/etcd/ssl/
   
[root@k8s-master ~]# scp /opt/etcd/ssl/* k8s-node2:/opt/etcd/ssl/


#拷贝etcd执行文件
[root@k8s-master ~]# scp /opt/etcd/bin/etcd k8s-node1:/opt/etcd/bin/
  
[root@k8s-master ~]# scp /opt/etcd/bin/etcd k8s-node2:/opt/etcd/bin/


#拷贝system管理etcd文件配置
[root@k8s-master ~]# scp /usr/lib/systemd/system/etcd.service  k8s-node1:/usr/lib/systemd/system/

[root@k8s-master ~]# scp /usr/lib/systemd/system/etcd.service  k8s-node2:/usr/lib/systemd/system/
6.2）修改node1上的etcd.conf文件

需要修改的位置：

ETCD_NAME

ETCD_LISTEN_PEER_URLS

ETCD_LISTEN_CLIENT_URLS

ETCD_INITIAL_ADVERTISE_PEER_URLS

ETCD_ADVERTISE_CLIENT_URLS

[root@k8s-node1 ~]# cat /opt/etcd/cfg/etcd.conf 
#[Member]
ETCD_NAME="etcd-2"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.79.149:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.79.149:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.79.149:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.79.149:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.79.148:2380,etcd-2=https://192.168.79.149:2380,etcd-3=https://192.168.79.150:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
6.3）修改node2上的etcd.conf文件 

需要修改的位置：

ETCD_NAME

ETCD_LISTEN_PEER_URLS

ETCD_LISTEN_CLIENT_URLS

ETCD_INITIAL_ADVERTISE_PEER_URLS

ETCD_ADVERTISE_CLIENT_URLS

[root@k8s-node2 ~]# cat /opt/etcd/cfg/etcd.conf 
#[Member]
ETCD_NAME="etcd-3"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.79.150:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.79.150:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.79.150:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.79.150:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.79.148:2380,etcd-2=https://192.168.79.149:2380,etcd-3=https://192.168.79.150:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

node1和node2都要改相应的位置。ETCD_NAME这里要保证不能重复。

 7）启动etcd

使用systemctl启动服务。

这里需要注意：单启动一个etcd，bash页面会进入等待状态，等待集群中的另一台启动，因为etcd启动至少需要集群中的两台都启动，才会真正的启动。

分别执行这三条命令：

systemctl daemon-reload 
systemctl start etcd.service 
systemctl enable etcd.service 

#master
[root@k8s-moster ~]# systemctl daemon-reload 
[root@k8s-moster ~]# systemctl start etcd.service 
[root@k8s-moster ~]# systemctl enable etcd.service 


#node1
[root@k8s-node1 ~]# systemctl daemon-reload 
[root@k8s-node1 ~]# systemctl start etcd.service 
[root@k8s-node1 ~]# systemctl enable etcd.service 


#node2
[root@k8s-node2 ~]# systemctl daemon-reload 
[root@k8s-node2 ~]# systemctl start etcd.service 
[root@k8s-node2 ~]# systemctl enable etcd.service

因为添加了system控制etcd所以这里需要用systemctl  daemon-reload加载一下文件。 

8）查看etcd集群状态

[root@k8s-master ~]# /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.79.148:2379,https://192.168.79.149:2379,https://192.168.79.150:2379" endpoint health --write-out=table
+-----------------------------+--------+-------------+-------+
|          ENDPOINT           | HEALTH |    TOOK     | ERROR |
+-----------------------------+--------+-------------+-------+
| https://192.168.79.148:2379 |   true | 10.984284ms |       |
| https://192.168.79.149:2379 |   true | 11.169278ms |       |
| https://192.168.79.150:2379 |   true | 11.828544ms |       |
+-----------------------------+--------+-------------+-------+

 etcd部署成功！如果出现错误，可以查看/var/log/messages日志进行排错。

四、部署Master节点组件

Master节点组件：kube-apiserver，kube-controller-manager，kube-scheduler

1、下载kubernetes1.20的二进制包

将kubernetes-v1.20.4-server-linux-amd64.tar.gz拷到虚拟机

该包中包含了k8s中所需要的所有需要的组件。

该包在网盘中，链接如下：

链接：https://pan.baidu.com/s/1utWPPj-CJ08Tbx0AgKyMNA?pwd=xiji 
提取码：xiji 

[root@k8s-master k8s]# cd
[root@k8s-master ~]# rz

[root@k8s-master ~]# ls
anaconda-ks.cfg  cfssl_1.6.4_linux_amd64           cfssljson_1.6.4_linux_amd64  etcd-v3.4.9-linux-amd64.tar.gz                opt
ca               cfssl-certinfo_1.6.4_linux_amd64  etcd-v3.4.9-linux-amd64      kubernetes-v1.20.4-server-linux-amd64.tar.gz

还是一样，我先回到家目录然后把包拷到家目录中。

1）创建k8s的部署工作目录

[root@k8s-master ~]# mkdir /opt/kubernetes/{bin,cfg,ssl} -p
[root@k8s-master ~]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
├── cfg
└── ssl

3 directories, 0 files

2）拷贝需要的组件 

解压kubernetes包并将kubernetes/server/bin目录下中master需要的组件执行文件拷到工作目录下的bin文件夹下。

[root@k8s-master ~]# tar xfz kubernetes-v1.20.4-server-linux-amd64.tar.gz

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

[root@k8s-master ~]# cp kubernetes/server/bin/{kube-apiserver,kube-scheduler,kube-controller-manager} /opt/kubernetes/bin/
[root@k8s-master ~]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
└── ssl

3 directories, 3 files

3）拷贝kubectl工具 

 将kubectl拷贝到/usr/bin目录下，kubectl是Kubernetes的命令行工具，可以用来管理Kubernetes集群。

[root@k8s-master ~]# cp kubernetes/server/bin/kubectl  /usr/bin/

2、部署kube-apiserver

作为Kubernetes系统的入口，其封装了核心对象的增删改查操作，以RESTful API接口方式提供给外部客户和内部组件调用。维护的REST对象持久化到Etcd中存储。

1）生成kube-apiserver证书

首先创建证书工作目录

[root@k8s-master ~]# mkdir ca/k8s -p
[root@k8s-master ~]# cd ca/k8s

自签证书颁发机构（CA）

[root@k8s-master k8s]# vim ca-config.json
[root@k8s-master k8s]# cat ca-config.json 
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}


[root@k8s-master k8s]# vim ca-csr.json
[root@k8s-master k8s]# cat ca-csr.json
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}

生成证书

[root@k8s-master k8s]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

[root@k8s-master k8s]# ls 
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem

多出ca-csr.pem和ca-key.pem两个文件。

使用自签CA签发kube-apiserver HTTPS证书。

[root@k8s-master k8s]# vim server-csr.json
[root@k8s-master k8s]# cat server-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.79.148",    #master的ip    
      "192.168.79.149",    #node的ip
      "192.168.79.150",    #node2的ip
      "192.168.79.151",    #预留ip
      "192.168.79.133",    #预留ip
      "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"
        }
    ]
}

生成证书

#生成证书
[root@k8s-master k8s]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

#查看证书生成情况
[root@k8s-master k8s]# ls
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem  server.csr  server-csr.json  server-key.pem  server.pem

将生成的证书都拷贝到/opt/kubernetes/ssl文件夹，一共是四个pem文件。

[root@k8s-master ~]# cp ca/k8s/*pem /opt/kubernetes/ssl/
[root@k8s-master ~]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── server-key.pem
    └── server.pem

3 directories, 7 files

多出两个serber-csr和server-key.pem文件。

2）kube-apiserver配置文件

--etcd-servers=要改为自己的集群ip

--bind-address=改为自己master的ip

--advertise-address=自己的master的ip

--service-cluster-ip-range=10.0.0.0/24虚拟网关不要改

[root@k8s-master ~]# vim /opt/kubernetes/cfg/kube-apiserver.conf
[root@k8s-master ~]# cat /opt/kubernetes/cfg/kube-apiserver.conf
KUBE_APISERVER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--etcd-servers=https://192.168.79.148:2379,https://192.168.79.149:2379,https://192.168.79.150:2379 \
--bind-address=192.168.79.148 \
--secure-port=6443 \
--advertise-address=192.168.79.148 \
--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 \
--service-account-issuer=api \
--service-account-signing-key-file=/opt/kubernetes/ssl/server-key.pem \
--etcd-cafile=/opt/etcd/ssl/ca.pem \
--etcd-certfile=/opt/etcd/ssl/server.pem \
--etcd-keyfile=/opt/etcd/ssl/server-key.pem \
--requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \
--proxy-client-cert-file=/opt/kubernetes/ssl/server.pem \
--proxy-client-key-file=/opt/kubernetes/ssl/server-key.pem \
--requestheader-allowed-names=kubernetes \
--requestheader-extra-headers-prefix=X-Remote-Extra- \
--requestheader-group-headers=X-Remote-Group \
--requestheader-username-headers=X-Remote-User \
--enable-aggregator-routing=true \
--audit-log-maxage=30 \
--audit-log-maxbackup=3 \
--audit-log-maxsize=100 \
--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"

参考说明

•      --logtostderr：启用日志

•      ---v：日志等级

•      --log-dir：日志目录

•      --etcd-servers：etcd集群地址                #k8s集群的所有阶段的ip

•      --bind-address：监听地址                        #master的ip地址

•      --secure-port：https安全端口

•      --advertise-address：集群通告地址                #master的ip地址

•      --allow-privileged：启用授权

•      --service-cluster-ip-range：Service虚拟IP地址段        #10.0.0.0/24这里不用改

•      --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证书

•      1.20版本必须加的参数：--service-account-issuer，--service-account-signing-key-file

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

•      --audit-log-xxx：审计日志

•      启动聚合层相关配置：--requestheader-client-ca-file，--proxy-client-cert-file，--proxy-client-key-file，--requestheader-allowed-names，--requestheader-extra-headers-prefix，--requestheader-group-headers，--requestheader-username-headers，--enable-aggregator-routing

3）配置token文件

Master apiserver启用TLS认证后，Node节点kubelet组件想要加入集群，必须使用CA签发的有效证书才能与apiserver通信，当Node节点很多时，签署证书是一件很繁琐的事情，因此有了TLS Bootstrapping机制，kubelet会以一个低权限用户自动向apiserver申请证书，kubelet的证书由apiserver动态签署。
认证大致工作流程如图所示：

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

#生成一个32位的随机码
[root@k8s-master ~]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
c47ffb939f5ca36231d9e3121a252940

[root@k8s-master ~]# vim /opt/kubernetes/cfg/token.csv
[root@k8s-master ~]# cat /opt/kubernetes/cfg/token.csv 
c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node-bootstrapper"

这里的token可以自己自定义，需要和后续的配置保持一致，否则后面部署kubelet将会认证错误。 

4）systemd管理apiserver 

[root@k8s-master ~]# vim /usr/lib/systemd/system/kube-apiserver.service
[root@k8s-master ~]# cat /usr/lib/systemd/system/kube-apiserver.service
[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

5）加载system配置并启动apiserver设置开机自启

[root@k8s-master ~]# systemctl daemon-reload 
[root@k8s-master ~]# systemctl start kube-apiserver.service 
[root@k8s-master ~]# systemctl enable kube-apiserver.service

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维 查看api-server的服务状态是running。

3、部署kube-controller-manager

负责执行各种控制器，目前已经提供了很多控制器来保证Kubernetes的正常运行。

1）编写配置文件

[root@k8s-master ~]# vim /opt/kubernetes/cfg/kube-controller-manager.conf
[root@k8s-master ~]# cat /opt/kubernetes/cfg/kube-controller-manager.conf
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--leader-elect=true \
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \
--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"    #签证到期时间为10年

参数说明

•      --kubeconfig：连接apiserver配置文件

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

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

2）生成kube-controller-manager证书

到 ca/k8s目录下。

#到k8s目录
[root@k8s-master ~]# cd ca/k8s

#编写生成证书的json文件
[root@k8s-master k8s]# vim kube-controller-manager-csr.json
[root@k8s-master k8s]# cat kube-controller-manager-csr.json
{
  "CN": "system:kube-controller-manager",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}

生成证书

#生成证书
[root@k8s-master k8s]# cfssl gencert -ca=/root/ca/k8s/ca.pem -ca-key=/root/ca/k8s/ca-key.pem -config=/root/ca/k8s/ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

#查看证书生成情况
[root@k8s-master k8s]# ls kube-controller-manager*
kube-controller-manager.csr  kube-controller-manager-csr.json  kube-controller-manager-key.pem  kube-controller-manager.pem

发现多出kube-controller-manager-key.pem、kube-controller-manager.pem两个文件

将生成的证书拷贝到kubernetes/ssl文件夹内。

[root@k8s-master k8s]# cp kube-controller-manager*pem /opt/kubernetes/ssl/
[root@k8s-master k8s]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
│   ├── kube-apiserver.conf
│   ├── kube-controller-manager.conf
│   └── token.csv
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── kube-controller-manager-key.pem
    ├── kube-controller-manager.pem
    ├── server-key.pem
    └── server.pem

3 directories, 12 files

3）生成manager的kubeconfig文件

因为在生成该文件的时候会用到刚刚生成的证书，为了方便建议进入到存有manager证书的目录操作

[root@k8s-master k8s]# KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"    #生成kubeconfig文件的存放位置
[root@k8s-master k8s]# KUBE_APISERVER="https://192.168.79.148:6443"   #master的ip

执行以下四句命令。 

#设置集群参数
[root@k8s-master k8s]# kubectl config set-cluster kubernetes \
>   --certificate-authority=/opt/kubernetes/ssl/ca.pem \
>   --embed-certs=true \
>   --server=${KUBE_APISERVER} \
>   --kubeconfig=${KUBE_CONFIG}

#设置客户端认证参数
[root@k8s-master k8s]# kubectl config set-credentials kube-controller-manager   --client-certificate=./kube-controller-manager.pem   --client-key=/opt/kubernetes/ssl/kube-controller-manager-key.pem   --embed-certs=true   --kubeconfig=${KUBE_CONFIG}

#设置上下文参数
[root@k8s-master k8s]# kubectl config set-context default \
>   --cluster=kubernetes \
>   --user=kube-controller-manager \
>   --kubeconfig=${KUBE_CONFIG}
Context "default" created.

#设置默认上下文
[root@k8s-master k8s]# kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

 查看kubeconfig生成情况。

[root@k8s-master k8s]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
│   ├── kube-apiserver.conf
│   ├── kube-controller-manager.conf
│   ├── kube-controller-manager.kubeconfig
│   └── token.csv
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── kube-controller-manager-key.pem
    ├── kube-controller-manager.pem
    ├── server-key.pem
    └── server.pem

3 directories, 13 files

在cfg，刚刚指定的位置生成了 kube-controller-manager.kubeconfig文件。

4）systemd管理controller-manager

[root@k8s-master k8s]# vim /usr/lib/systemd/system/kube-controller-manager.service
[root@k8s-master k8s]# cat /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.conf
ExecStart=/opt/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

5）加载service并启动controller-manager，设置开机自启

[root@k8s-master k8s]# systemctl daemon-reload 
[root@k8s-master k8s]# systemctl start kube-controller-manager.service 
[root@k8s-master k8s]# systemctl enable kube-controller-manager.service

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

 启动成功！

 4、部署kube-scheduler

为新建立的Pod进行节点(node)选择(即分配机器)，负责集群的资源调度。组件抽离，可以方便替换成其他调度器。

1）创建配置文件

[root@k8s-master k8s]# vim /opt/kubernetes/cfg/kube-scheduler.conf
[root@k8s-master k8s]# cat /opt/kubernetes/cfg/kube-scheduler.conf
KUBE_SCHEDULER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--leader-elect \
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \
--bind-address=127.0.0.1"

参数说明

•      --kubeconfig：连接apiserver配置文件

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

2）生成kube-scheduler证书

[root@k8s-master k8s]# vim kube-scheduler-csr.json
[root@k8s-master k8s]# cat kube-scheduler-csr.json
{
  "CN": "system:kube-scheduler",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}

生成证书

#生成证书
[root@k8s-master k8s]# cfssl gencert -ca=/root/ca/k8s/ca.pem -ca-key=/root/ca/k8s/ca-key.pem -config=/root/ca/k8s/ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

#查看证书生成情况
[root@k8s-master k8s]# ls kube-scheduler*
kube-scheduler.csr  kube-scheduler-csr.json  kube-scheduler-key.pem  kube-scheduler.pem

将证书拷贝到kubernetes/ssl文件夹。 

[root@k8s-master k8s]# cp kube-scheduler-key*pem /opt/kubernetes/ssl/

该文件夹下多出 kube-scheduler-key.pem 、kube-scheduler.pem两个文件。

3）生成schedule的kubeconfig文件

#指定生成kubeconfig的路径
[root@k8s-master k8s]# KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
#master的ip
[root@k8s-master k8s]# KUBE_APISERVER="https://192.168.79.148:6443"

执行以下四个命令 。

#设置集群参数
[root@k8s-master k8s]# kubectl config set-cluster kubernetes \
>   --certificate-authority=/opt/kubernetes/ssl/ca.pem \
>   --embed-certs=true \
>   --server=${KUBE_APISERVER} \
>   --kubeconfig=${KUBE_CONFIG}

#设置客户端认证参数
[root@k8s-master k8s-scheduler]# kubectl config set-credentials kube-scheduler \
>   --client-certificate=./kube-scheduler.pem \
>   --client-key=./kube-scheduler-key.pem \
>   --embed-certs=true \
>   --kubeconfig=${KUBE_CONFIG}

#设置上下文参数
[root@k8s-master k8s]# kubectl config set-context default \
>   --cluster=kubernetes \
>   --user=kube-scheduler \
>   --kubeconfig=${KUBE_CONFIG}

#设置默认上下文
[root@k8s-master k8s]# kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

查看kubeconfig生成情况。

[root@k8s-master k8s]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
│   ├── kube-apiserver
│   ├── kube-controller-manager
│   └── kube-scheduler
├── cfg
│   ├── kube-apiserver.conf
│   ├── kube-controller-manager.conf
│   ├── kube-controller-manager.kubeconfig
│   ├── kube-scheduler.conf
│   ├── kube-scheduler.kubeconfig
│   └── token.csv
└── ssl
    ├── ca-key.pem
    ├── ca.pem
    ├── kube-controller-manager-key.pem
    ├── kube-controller-manager.pem
    ├── kube-scheduler-key.pem
    ├── kube-scheduler.pem
    ├── server-key.pem
    └── server.pem

3 directories, 17 files

发现cfg下多出了kube-scheduler.kubeconfig文件，说明生成成功！

4）systemd管理scheduler

[root@k8s-master k8s]# vim /usr/lib/systemd/system/kube-scheduler.service
[root@k8s-master k8s]# cat /usr/lib/systemd/system/kube-scheduler.service
[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

5）加载service配置，并启动scheduler，设置开机启动

[root@k8s-master k8s]# systemctl daemon-reload 
[root@k8s-master k8s]# systemctl start kube-scheduler.service
[root@k8s-master k8s]# systemctl enable kube-scheduler.service

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

启动成功！

 5、查看集群状态

需要用到kubuctl工具。

1）生成kubectl连接集群的证书

[root@k8s-master k8s]# vim admin-csr.json
[root@k8s-master k8s]# cat admin-csr.json
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}

生成证书

#生成证书
[root@k8s-master k8s]# cfssl gencert -ca=/root/ca/k8s/ca.pem -ca-key=/root/ca/k8s/ca-key.pem -config=/root/ca/k8s/ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

#查看证书生成情况
[root@k8s-master k8s]# ls admin*
admin.csr  admin-csr.json  admin-key.pem  admin.pem

该文件夹下多出两个pem文件。

2）生成kubeconfig文件

 创建存放config的目录，这里在root下创建一个隐藏的文件夹，因为kubectl是个工具不是服务，就直接在root下创建隐藏的文件夹。

[root@k8s-master k8s]# mkdir /root/.kube

#设置两个变量分别表示生成的config的存放位置，和需要用到的master的ip
[root@k8s-master k8s]# KUBE_CONFIG="/root/.kube/config"
[root@k8s-master k8s]# KUBE_APISERVER="https://192.168.79.148:6443"

执行以下四句命令

#设置集群参数
[root@k8s-master k8s]# kubectl config set-cluster kubernetes \
    --certificate-authority=/opt/kubernetes/ssl/ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=${KUBE_CONFIG}

#设置客户端认证参数
[root@k8s-master k8s]# kubectl config set-credentials cluster-admin \
    --client-certificate=./admin.pem \
    --client-key=./admin-key.pem \
    --embed-certs=true \
    --kubeconfig=${KUBE_CONFIG}

#设置上下文参数
[root@k8s-master k8s]# kubectl config set-context default \
    --cluster=kubernetes \
    --user=cluster-admin \
    --kubeconfig=${KUBE_CONFIG}

#设置默认上下文
[root@k8s-master k8s]# kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

3）kubectl查看集群状态

[root@k8s-master k8s]# kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
scheduler            Healthy   ok                  
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}

#查看命名空间
[root@k8s-master k8s]# kubectl get ns
NAME              STATUS   AGE
default           Active   66m
kube-node-lease   Active   66m
kube-public       Active   66m
kube-system       Active   66m

集群状态都是healthy表示集群状态正常，如果出错，查看日志进行排错。

五、部署node组件

kubelet，kube-proxy，docker，etcd

注：两台node的操作是一样的。

1、安装docker

1）下载国内阿里云的docker源

[root@k8s-node1 ~]# wget -O /etc/yum.repos.d/docker-ce.repo

2）安装docker（node节点都要安装）

[root@k8s-node1 ~]# yum install -y docker-ce

#配置加速器，为了加快docker从dockerhub上pull镜像的速度
[root@k8s-node1 ~]# sudo tee /etc/docker/daemon.json <<-'EOF'
  {
    "registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],
    "exec-opts": ["native.cgroupdriver=systemd"],
    "log-driver": "json-file",
    "log-opts": {
      "max-size": "100m"
    },
    "storage-driver": "overlay2"
  }
  EOF
[root@k8s-node1 ~]# systemctl daemon-reload
[root@k8s-node1 ~]# systemctl start docker
[root@k8s-node1 ~]# systemctl enable docker

node1 

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

 node2

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

 2、创建node组件的工作目录并拷问文件（node都要创建）

#node1
[root@k8s-node1 ~]# mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
[root@k8s-node1 ~]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
├── cfg
├── logs
└── ssl

#node2
[root@k8s-node2 ~]# mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
[root@k8s-node2 ~]# tree /opt/kubernetes/
/opt/kubernetes/
├── bin
├── cfg
├── logs
└── ssl

master将kubelet和kube-proxy以及k8s需要的ca证书拷贝给node节点

kubelet和kube-proxy都在master的kubernetes包的server/bin目录下。

#传到node1
[root@k8s-master ~]# scp  kubernetes/server/bin/{kubelet,kube-proxy} k8s-node1:/opt/kubernetes/bin/

#传到node2
[root@k8s-master ~]# scp  kubernetes/server/bin/{kubelet,kube-proxy} k8s-node2:/opt/kubernetes/bin/

3、部署kubelet

负责管控容器，Kubelet会从Kubernetes API Server接收Pod的创建请求，启动和停止容器，监控容器运行状态并汇报给Kubernetes API Server。

1）创建配置文件（node都要创建）

#node1
[root@k8s-node1 ~]# vim /opt/kubernetes/cfg/kubelet.conf
KUBELET_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--hostname-override=k8s-node1 \
--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=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.0"

#node2
[root@k8s-node2 ~]# vim /opt/kubernetes/cfg/kubelet.conf
KUBELET_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--hostname-override=k8s-node2 \
--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=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.0"

注意： --hostname-override=不能一样。其余位置不用改。

参数说明

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

•      --network-plugin：启用CNI

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

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

•      --config：配置参数文件

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

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

registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.0"这个镜像最好提前pull下来。

2）拉取镜像

#node1
[root@k8s-node1 ~]# docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.0

#node2
[root@k8s-node2 ~]# docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.0

3）配置参数文件（node都要配置）

[root@k8s-node1 ~]# vim /opt/kubernetes/cfg/kubelet-config.yml
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

node1和node2这里的内容是一致的，所以可以只用使用scp拷到node2的 /opt/kubernetes/cfg/下

[root@k8s-node1 ~]# scp /opt/kubernetes/cfg/kubelet-config.yml k8s-node2:/opt/kubernetes/cfg/

4）生成kubelet初次加入集群引导kubeconfig文件

这里需要再master节点操作。

在生成kubernetes证书的目录下执行以下命令生成kubeconfig文件

#授权kubelet-bootstrap用户允许请求证书
[root@k8s-master k8s]# kubectl create clusterrolebinding kubelet-bootstrap \
  --clusterrole=system:node-bootstrapper \
  --user=kubelet-bootstrap

[root@k8s-master ~]# cd ca/k8s
[root@k8s-master k8s]# KUBE_CONFIG="/opt/kubernetes/cfg/bootstrap.kubeconfig"
[root@k8s-master k8s]# KUBE_APISERVER="https://192.168.79.148:6443"

#这里的token要和上面/opt/kubernetes/cfg/token.csv的token要一样
[root@k8s-master k8s]# TOKEN="c47ffb939f5ca36231d9e3121a252940"

执行设置集群参数、设置客户端认证参数、设置上下文参数、设置默认上下文四步。

#设置集群参数
[root@k8s-master k8s]# kubectl config set-cluster kubernetes \
    --certificate-authority=/opt/kubernetes/ssl/ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=${KUBE_CONFIG}

#设置客户端认证参数
[root@k8s-master k8s]# kubectl config set-credentials "kubelet-bootstrap" \
    --token=${TOKEN} \
    --kubeconfig=${KUBE_CONFIG}


#设置上下文参数
[root@k8s-master k8s]# kubectl config set-context default \
    --cluster=kubernetes \
    --user="kubelet-bootstrap" \
    --kubeconfig=${KUBE_CONFIG}

#设置默认上下文
[root@k8s-master k8s]# kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

5）将生成的kubeconfig拷贝到node节点

[root@k8s-master k8s]# scp /opt/kubernetes/cfg/bootstrap.kubeconfig  k8s-node1:/opt/kubernetes/cfg/

6）systemd管理kubelet（node执行）

这一步需要在node节点操作。

[root@k8s-node1 ~]# vim /usr/lib/systemd/system/kubelet.service
[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

这里的配置，所有node都是一样的可以直接scp拷到node2的 /usr/lib/systemd/system/目录下

[root@k8s-node1 ~]# scp /usr/lib/systemd/system/kubelet.service k8s-node2:/usr/lib/systemd/system/

7）启动kubelet，设置开机自启

#node1
[root@k8s-node1 ~]# systemctl daemon-reload 
[root@k8s-node1 ~]# systemctl start kubelet.service
[root@k8s-node1 ~]# systemctl enable kubelet.service

#node2
[root@k8s-node2 ~]# systemctl daemon-reload 
[root@k8s-node2 ~]# systemctl start kubelet.service
[root@k8s-node2 ~]# systemctl enable kubelet.service

node1 

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

node2 

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

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

1）查看kubelet证书请求

在master上查看。

[root@k8s-master k8s]# kubectl  get csr
NAME                                                   AGE    SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-o3SeaoanVHssuQi5DVKfXQKhAJ39CROp4QidAE6u24U   2m5s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-p6DbmorzFDSsdfCp7OIWfISKjKC60CKOp9dsCe9o63M   2m5s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

可以看到该申请是pending状态。 

2）批准申请

kubectl  certificate  approve   申请的NAME

[root@k8s-master k8s]# kubectl certificate approve node-csr-o3SeaoanVHssuQi5DVKfXQKhAJ39CROp4QidAE6u24U

[root@k8s-master k8s]# kubectl certificate approve node-csr-node-csr-node-csr-node-csr-p6DbmorzFDSsdfCp7OIWfISKjKC60CKOp9dsCe9o63M


#再次查看发现状态变为了approve
[root@k8s-master k8s]# kubectl  get csr
NAME                                                   AGE     SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-o3SeaoanVHssuQi5DVKfXQKhAJ39CROp4QidAE6u24U   3m44s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-p6DbmorzFDSsdfCp7OIWfISKjKC60CKOp9dsCe9o63M   3m44s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

3）查看node

[root@k8s-master k8s]# kubectl get node
NAME        STATUS   ROLES    AGE     VERSION
k8s-node1   NotReady    <none>   3h13m   v1.20.4
k8s-node2   NotReady    <none>   3h17m   v1.20.4

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

5、部署kube-proxy

负责为Pod创建代理服务，Kubernetes Proxy会从Kubernetes API  Server获取所有的Service信息，并根据Service的信息创建代理服务，实现Service到Pod的请求路由和转发，从而实现Kubernetes层级的虚拟转发网络。

1）创建证书请求文件（在master节点）

在/root/ca/k8s下创建证书请求文件

[root@k8s-master k8s]# pwd
/root/ca/k8s
[root@k8s-master k8s]# vim kube-proxy-csr.json
[root@k8s-master k8s]# cat kube-proxy-csr.json
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

生成证书

[root@k8s-master k8s]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
#查看证书生成情况
[root@k8s-master k8s]# ls kube-proxy*
kube-proxy.csr  kube-proxy-csr.json  kube-proxy-key.pem  kube-proxy.pem

2）生成kubeconfig文件（master节点）

#定义两个变量
[root@k8s-master k8s]# KUBE_CONFIG="/opt/kubernetes/cfg/kube-proxy.kubeconfig"
[root@k8s-master k8s]# KUBE_APISERVER="https://192.168.79.148:6443"

执行以下四条命令

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

#设置客户端认证参数
kubectl config set-credentials kube-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}

#设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=${KUBE_CONFIG}

#设置默认上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维3）将 kube-proxy.kubeconfig文件传到node节点的cfg下。

两个node都要传。

#传到node1
[root@k8s-master k8s]# scp /opt/kubernetes/cfg/kube-proxy.kubeconfig  k8s-node1:/opt/kubernetes/cfg/

#传到node2
[root@k8s-master k8s]# scp /opt/kubernetes/cfg/kube-proxy.kubeconfig  k8s-node2:/opt/kubernetes/cfg/

4）创建kube-proxy配置文件（node节点）

两个node一致。

[root@k8s-node1 ~]# vim /opt/kubernetes/cfg/kube-proxy.conf
KUBE_PROXY_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/opt/kubernetes/logs \
--config=/opt/kubernetes/cfg/kube-proxy-config.yml"

#拷贝到node2上
[root@k8s-node1 ~]# scp /opt/kubernetes/cfg/kube-proxy.conf k8s-node2:/opt/kubernetes/cfg/

5）配置kube-proxy参数文件（node节点）

[root@k8s-node1 ~]# vim /opt/kubernetes/cfg/kube-proxy-config.yml
[root@k8s-node1 ~]# cat /opt/kubernetes/cfg/kube-proxy-config.yml
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: k8s-node1
clusterCIDR: 10.244.0.0/16

#拷贝到node2上
[root@k8s-node1 ~]# scp  kube-proxy.conf kube-proxy-config.yml kube-proxy.kubeconfig k8s-node2:/opt/kubernetes/cfg/

这里的hostnameOverride要改为自己本机的ip或者名。

修改node2上的 hostnameOverride为k8s-node2。

[root@k8s-node2 ~]# cat /opt/kubernetes/cfg/kube-proxy-config.yml 
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: k8s-node2
clusterCIDR: 10.244.0.0/16

6）system管理kube-proxy（node节点）

两个node一致。

[root@k8s-node1 ~]# vim /usr/lib/systemd/system/kube-proxy.service
[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

#拷贝到node2
[root@k8s-node1 ~]# scp /usr/lib/systemd/system/kube-proxy.service  k8s-node2:/usr/lib/systemd/system/

7）启动并设置开机启动

[root@k8s-node1 ~]# systemctl daemon-reload
[root@k8s-node1 ~]# systemctl enable kube-proxy
[root@k8s-node1 ~]# systemctl start kube-proxy

[root@k8s-node2 ~]# systemctl daemon-reload
[root@k8s-node2 ~]# systemctl enable kube-proxy
[root@k8s-node2 ~]# systemctl start kube-proxy

node1 

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

 node2

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

6、部署网络插件（Calico）

Calico是一个纯三层的数据中心网络方案，是目前Kubernetes主流的网络方案。

1）拷贝calico.yaml文件到node（master）

链接：https://pan.baidu.com/s/1QhZ3zUrD8OifY5n2FZ0ZZQ?pwd=b22c 
提取码：b22c 

并将该yaml问价拷贝到/opt/kubernetes/cfg/

2）部署Calico（master）

该插件是用yaml以pod的形式部署到node上的所以需要在master上使用kubectl工具。

这个时间可能会久一点几分钟也可能是十几分钟，直到看到status为running即可就代表部署完成。

[root@k8s-master k8s]# cd /opt/kubernetes/cfg/
[root@k8s-master cfg]# kubectl apply -f calico.yaml

#查看pods的创建情况
[root@k8s-master cfg]# kubectl get pods -n kube-system 
NAME                                      READY   STATUS    RESTARTS   AGE
calico-kube-controllers-97769f7c7-vjzdg   1/1     Running   0          99m
calico-node-dx6sr                         0/1     Running   0          8s
calico-node-nm4t2                         1/1     Running   0          99m

二级制部署kubernetes（1.20）,kubernetes,kubernetes,容器,云原生,云计算,运维

在node主机上查看ip可以看到多了一个网卡，这就是calico。

注：calico.yaml用到了DaemonSet控制器，意思是在所有node上都会创建一个该pod，以后新加入的node会自动创建一个calico的pod在主机上。文章来源地址https://www.toymoban.com/news/detail-619510.html

到了这里，关于二级制部署kubernetes（1.20）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 探索云原生容器编排技术:如Kubernetes如何为大数据处理和AI模型的自动化部署带来便利

    探索云原生容器编排技术:如Kubernetes如何为大数据处理和AI模型的自动化部署带来便利

    🎈个人主页：程序员 小侯 🎐CSDN新晋作者 🎉欢迎 👍点赞✍评论⭐收藏 ✨收录专栏：云原生 ✨文章内容： 🤝希望作者的文章能对你有所帮助，有不足的地方请在评论区留言指正，大家一起学习交流！🤗 Kubernetes是一个强大的容器编排和自动化部署工具，它为大数据处理和

    2024年02月10日
    浏览(57)

  • 【云原生】Kubernetes临时容器

    特性状态： Kubernetes v1.25 [stable] 本页面概述了临时容器：一种特殊的容器，该容器在现有 Pod 中临时运行，以便完成用户发起的操作，例如故障排查。 你会使用临时容器来检查服务，而不是用它来构建应用程序 Pod 是 Kubernetes 应用程序的基本构建块。 由于 Pod 是一次性且可替

    2024年02月15日
    浏览(38)
  • 【云原生】Kubernetes容器编排工具

    【云原生】Kubernetes容器编排工具

    目录 1. K8S介绍 1.1 k8s的由来 下载地址 1.2 docker编排与k8s编排相比 1.3 传统后端部署与k8s 的对比 传统部署 k8s部署  ​2. k8s的集群架构与组件 （1） Kube-apiserver （2）Kube-controller-manager  （3）Kube-scheduler   2.2 k8s的配置存储中心 2.3  k8s的Node 组件   （1）Kubelet   （2）Kube-Proxy 

    2024年02月10日
    浏览(39)
  • 【云原生】容器编排工具Kubernetes

    【云原生】容器编排工具Kubernetes

    目录 一、 K8S介绍 官网地址： 1.1docker编排与k8s编排相比 1.2特性 1.3功能 二、K8S重要组件 2.1核心组件 （1）Kube-apiserver （2）Kube-controller-manager （3）Kube-scheduler （4）Node ①kubelet ②kube-proxy ③docker （5）etcd 2.2Kubernetes工作原理 三、Pod 3.1 Pod控制器 （1）Deployment （2）ReplicaSet （3）

    2024年02月09日
    浏览(45)

  • 云原生、容器化、Kubernetes、微服务

    作者：禅与计算机程序设计艺术 云原生（Cloud Native）是一个开放且社区驱动的项目，它定义了一组架构原则、最佳实践和工具集，这些原则、实践和工具围绕业务需求和工程实践而设计，可用于开发人员在构建和运行分布式系统时更加顺畅地交付可靠的软件。云原生可以帮助

    2024年02月07日
    浏览(44)
  • 【云原生】kubernetes中容器的资源限制

    【云原生】kubernetes中容器的资源限制

    目录 1 metrics-server 2 指定内存请求和限制 3 指定 CPU 请求和限制 资源限制 在k8s中对于容器资源限制主要分为以下两类: 内存资源限制: 内存 请求 （request）和内存 限制 （limit）分配给一个容器。 我们保障容器拥有它请求数量的内存，但不允许使用超过限制数量的内存。 官网参

    2024年02月14日
    浏览(47)
  • 云原生Kubernetes:CRI 容器运行时接口

    云原生Kubernetes:CRI 容器运行时接口

    目录 一、理论 1.​CRI 2.容器运行时层级 3.容器运行时比较 二、总结 （1）概念       Kubernetes Node (kubelet) 的主要功能就是启动和停止容器的组件，我们 称之为容器运行时（ Container Runtime) ，其中最知名的就是 Docker 。为了 更具扩展性， Kubernetes 1.5 版本开始就加入了容器运行

    2024年02月09日
    浏览(42)

  • 【云原生|Kubernetes】08-Pod中的Init容器

    Init 容器是一种特殊容器，在 Pod内的应用容器启动之前运行。Init 容器可以包括一些应用镜像中不存在的实用工具和安装脚本。 你可以在 Pod 的spec中与用来描述应用容器的 containers 数组平行的位置指定 Init 容器。 Init 容器的状态在 status.initContainerStatuses 字段中以容器状态数组

    2024年02月09日
    浏览(51)
  • 容器和云原生（三）：kubernetes搭建与使用

    容器和云原生（三）：kubernetes搭建与使用

            目录 单机K8S docker containerd image依赖 kubeadm初始化 验证 crictl工具 K8S核心组件 上文安装单机docker是很简单docker，但是生产环境需要多个主机，主机上启动多个docker容器，相同容器会绑定形成1个服务service，微服务场景中多个service会互相调用，那么就需要保证多个servi

    2024年02月11日
    浏览(31)
  • 【云原生-深入理解Kubernetes-1】容器的本质是进程

    【云原生-深入理解Kubernetes-1】容器的本质是进程

    大家好，我是秋意零。 😈 CSDN作者主页 😎 博客主页 👿 简介 👻 普通本科生在读 在校期间参与众多计算机相关比赛，如：🌟 “省赛”、“国赛” ，斩获多项奖项荣誉证书 🔥 各个平台， 秋意零/秋意临 账号创作者 🔥 云社区 创建者 点赞、收藏+关注下次不迷路！ 欢迎加

    2024年02月02日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包