一、Kubernetes的基本知识

Pod
Pod是若干个相关容器的组合，是一个逻辑概念，Pod包含的容器运行在同一个宿主机上，这些容器使用相同的网络命名空间、IP地址和端口，相互之间能通过localhost来发现和通信，共享一块存储卷空间。在Kubernetes中创建、调度和管理的最小单位是Pod。一个Pod一般只放一个业务容器和一个用于统一网络管理的网络容器。
Replication Controller
Replication Controller是用来控制管理Pod副本(Replica，或者称实例)，Replication Controller确保任何时候Kubernetes集群中有指定数量的Pod副本在运行，如果少于指定数量的Pod副本，Replication Controller会启动新的Pod副本，反之会杀死多余的以保证数量不变。另外Replication Controller是弹性伸缩、滚动升级的实现核心。
Service
Service是真实应用服务的抽象，定义了Pod的逻辑集合和访问这个Pod集合的策略，Service将代理Pod对外表现为一个单一访问接口，外部不需要了解后端Pod如何运行，这给扩展或维护带来很大的好处，提供了一套简化的服务代理和发现机制。
Label
Label是用于区分Pod、Service、Replication Controller的Key/Value键值对，实际上Kubernetes中的任意API对象都可以通过Label进行标识。每个API对象可以有多个Label，但是每个Label的Key只能对应一个Value。Label是Service和Replication Controller运行的基础，它们都通过Label来关联Pod，相比于强绑定模型，这是一种非常好的松耦合关系。
Node
Kubernets属于主从的分布式集群架构，Kubernets Node（简称为Node，早期版本叫做Minion）运行并管理容器。Node作为Kubernetes的操作单元，将用来分配给Pod（或者说容器）进行绑定，Pod最终运行在Node上，Node可以认为是Pod的宿主机。

需求

目前生产部署Kubernetes集群主要有两种方式：

kubeadm

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

二进制包

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

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

1. 安装要求

部署Kubernetes集群服务器需要满足以下几个条件：

一台或多台机器，操作系统 CentOS7.x-86_x64
硬件配置：2GB或更多RAM，2个CPU或更多CPU，硬盘30GB或更多
集群中所有机器之间网络互通
可以访问外网，需要拉取镜像
禁止swap分区

软件环境：

软件	版本
操作系统	CentOS7.6.1810
Docker	docker-ce 19.03.11
Kubernetes	1.18

服务器整体规划：

角色	IP	组件
k8s-master1	192.168.0.10	kube-apiserver，kube-controller-manager，kube-scheduler，etcd
k8s-master2	192.168.0.11	kube-apiserver，kube-controller-manager，kube-scheduler，etcd
k8s-node1	192.168.0.20	kubelet，kube-proxy，docker，etcd
k8s-node2	192.168.0.30	kubelet，kube-proxy，docker，etcd
Load Balancer (master)	192.168.0.40	nginx L4 ，master节点的高可用 192.168.0.41(VIP)
Load Balancer (Backup)	192.168.0.41	nginx L4

须知：考虑电脑配置环境较低，这么多虚拟机跑不动，所以这一套高可用集群分两部分实施，先部署一套单Master架构（192.168.0.10/20/30），再扩容为多Master架构（上述规划）。

单Master节点服务器规划：

角色	IP	组件
k8s-master	192.168.0.10	kube-apiserver，kube-controller-manager，kube-scheduler，etcd
k8s-node1	192.168.0.20	kubelet，kube-proxy，docker etcd
k8s-node2	192.168.0.30	kubelet，kube-proxy，docker，etcd

kubernetes架构图

2. 系统初始化配置

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config
setenforce 0

# 关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

# 根据规划设置主机名
hostnamectl set-hostname < name >

# 在master添加hosts
cat >> /etc/hosts << EOF
192.168.0.10 k8s-master
192.168.0.20 k8s-node1
192.168.0.30 k8s-node2
EOF

# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl --system  # 生效
sysctl -p /etc/sysctl.d/k8s.conf

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com

组件	使用的证书
etcd	ca.pem，server.pem，server-key.pem
flannel	ca.pem，server.pem，server-key.pem
kube-apiserver	ca.pem，server.pem，server-key.pem
kubelet(自动颁发)	ca.pem，ca-key.pem
kube-proxy	ca.pem，kube-proxy.pem，kube-proxy-key.pem
kubectl	ca.pem，admin.pem，admin-key.pem

二、部署Etcd集群

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

节点名称	IP
etcd-1 (k8s-master)	192.168.0.10
etcd-2 (k8s-node1)	192.168.0.20
etcd-3 (k8s-node2)	192.168.0.30

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

2.1 准备cfssl证书生成工具

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/bin/cfssl-certinfo

2.2 生成Etcd证书

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

# 创建工作目录
mkdir -p ~/TLS/{etcd,k8s}
cd TLS/etcd

# 自签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": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

# 生成证书
cfssl gencert -initca ca-csr.json | cfssljson -bare ca

[root@k8s-master etcd]# ll *pem
-rw-------. 1 root root 1675 Jul 10 15:32 ca-key.pem
-rw-r--r--. 1 root root 1265 Jul 10 15:32 ca.pem

2.2.2 使用自签CA签发Etcd HTTPS证书

# 创建证书申请文件
cat > server-csr.json <

 
  
  注：文件hosts字段中IP为所有etcd节点的集群内部通信IP，一个都不能少！为了方便后期扩容也可以多写几个预留的IP。 
  
 # 生成证书
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 etcd]# ll server*pem
-rw-------. 1 root root 1679 Jul 10 15:38 server-key.pem
-rw-r--r--. 1 root root 1338 Jul 10 15:38 server.pem
 
 2.3 从Github下载Etcd二进制文件 
 # 下载地址
#官网写了，因为新版3.4以上版本不支持旧版API，建议换成3.3的etcd
wget https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz
 
 2.4 部署Etcd集群 
 在master节点上操作，为简化操作，可以将master节点生成的所有文件拷贝到俩台node节点 
 2.4.1 创建目录并解压二进制包 
 mkdir /opt/etcd/{bin,cfg,ssl} -p
tar zxvf etcd-v3.3.22-linux-amd64.tar.gz
chown -R root:root etcd-v3.3.22-linux-amd64
mv etcd-v3.3.22-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
 
 2.4.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.0.10:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.10:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.0.10:2380,etcd-2=https://192.168.0.20:2380,etcd-3=https://192.168.0.30: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表示加入已有集群 
  
 2.4.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
 
 2.4.3 拷贝生成的证书 
 把刚才生成的证书拷贝到配置文件中的路径 
 cp ~/TLS/etcd/ca*pem ~/TLS/etcd/server*pem /opt/etcd/ssl/
 
 2.4.5 启动并设置自启动 
 systemctl daemon-reload
systemctl restart etcd
systemctl enable etcd

# 如果报错无法启动，则需要将其他etcd节点设置完成后才可以启动
 
 2.4.6 将master节点生成所有的文件拷贝到两台node节点 
 scp -rp /opt/etcd/ k8s-node1:/opt/
scp -rp /opt/etcd/ k8s-node2:/opt/

scp -rp /usr/lib/systemd/system/etcd.service k8s-node1:/usr/lib/systemd/system/
scp -rp /usr/lib/systemd/system/etcd.service k8s-node2:/usr/lib/systemd/system/
 
 2.4.7 在node节点分别修改etcd.conf配置文件中的节点名称和当前服务器IP 
 #node1和node2节点都进行修改
vim /opt/etcd/cfg/etcd.conf
#[Member]
ETCD_NAME="etcd-2"  # 修改此处，节点2改为etcd-2，节点3改为etcd-3
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"  # 修改此处为当前服务器IP
ETCD_LISTEN_PEER_URLS="https://192.168.0.20:2380"   # 修改此处为当前服务器IP
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.20:2379" # 修改此处为当前服务器IP

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.20:2380"    # 修改此处为当前服务器IP
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.20:2379"  # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.0.10:2380,etcd-2=https://192.168.0.20:2380,etcd-3=https://192.168.0.30:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"


# 最后启动etcd并设置开机启动
systemctl daemon-reload
systemctl restart etcd
systemctl enable etcd

[root@k8s-master etcd]# netstat -lntup|grep etcd
tcp        0      0 192.168.0.10:2379       0.0.0.0:*               LISTEN      10529/etcd          
tcp        0      0 192.168.0.10:2380       0.0.0.0:*               LISTEN      10529/etcd 

#为三台节点都创建系统执行指令命令
cp /opt/etcd/bin/etcdctl /usr/bin/
 
 2.4.8 查看etcd集群状态 
 [root@k8s-master etcd]# etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.0.10:2379,https://192.168.0.20:2379,https://192.168.0.30:2379" endpoint health
https://192.168.0.30:2379 is healthy: successfully committed proposal: took = 18.649662ms
https://192.168.0.20:2379 is healthy: successfully committed proposal: took = 20.469511ms
https://192.168.0.10:2379 is healthy: successfully committed proposal: took = 22.428573ms
 
  
  如果输出上面信息，就说明Etcd集群部署成功。如果有问题先看日志：/var/log/message或 journalctl -u etcd 
  
 三、所有节点部署Docker 
  
   
     
    
   
  
    image 
   
  
 我这里采用yum安装，用二进制安装也一样 
 二进制包下载链接 
 # 1. 卸载旧版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                  
# 2. 使用存储库安装
yum install -y yum-utils

# 3. 设置镜像仓库(修改为国内源地址)
yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 5. 更新索引
yum makecache fast

# 4. 安装docker相关的依赖 默认最新版(docker-ce:社区版 ee:企业版)
yum install docker-ce docker-ce-cli containerd.io -y

#5. 安装特定docker版本(先列出列出可用版本)
yum list docker-ce --showduplicates | sort -r
yum install docker-ce-19.03.9 docker-ce-cli-19.03.9 containerd.io

# 所有节点设置防火墙规则，并让生效
vim /lib/systemd/system/docker.service
[Service]
ExecStartPost=/sbin/iptables -I FORWARD -s 0.0.0.0/0 -j ACCEPT

# 7. 启动docker
systemctl enable docker
systemctl restart docker

# 8. 查看版本
[root@k8s-master ~]# docker --version
Docker version 19.03.11, build 42e35e61f3

# 9. 配置docker镜像加速器
## 镜像加速器：阿里云加速器，daocloud加速器，中科大加速器
## Docker 中国官方镜像加速：https://registry.docker-cn.com
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}
EOF
systemctl daemon-reload
systemctl restart docker
 
 四、部署Master节点 
  
  kube-apiserver， 
  kube-controller-manager， 
  kube-scheduler 
  
 4.1 生成kube-apiserver证书 
 4.1.1 自签CA证书颁发机构 
 cd /root/TLS/k8s

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 -

[root@k8s-master k8s]# ll *pem
-rw-------. 1 root root 1675 Jul 13 14:49 ca-key.pem
-rw-r--r--. 1 root root 1359 Jul 13 14:49 ca.pem
 
 4.1.2 使用自签CA签发kube-apiserver HTTPS证书 
 # 创建证书申请文件:
cat > server-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "10.240.0.1",
      "172.16.0.1",
      "127.0.0.1",
      "192.168.0.10",
      "192.168.0.11",
      "192.168.0.12",
      "192.168.0.20",
      "192.168.0.21",
      "192.168.0.22",
      "192.168.0.30",
      "192.168.0.31",
      "192.168.0.32",
      "192.168.0.40",
      "192.168.0.41",
      "192.168.0.42",
      "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

#上述文件hosts字段中IP为所有Master/LB/VIP IP，一个都不能少！为了方便后期扩容可以多写几个预留的IP

# 生成证书
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]# ll server*pem
-rw-------. 1 root root 1679 Jul 13 14:55 server-key.pem
-rw-r--r--. 1 root root 1700 Jul 13 14:55 server.pem
 
 4.2下载二进制文件包并解压 
 下载地址： https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.18.md#v1183 
 打开链接会发现里面有很多包，下载一个最新版server包就够了，包含了Master和Node二进制文件。 
 # 解压二进制包
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/
 
 4.3 部署kube-apiserver 
 4.3.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.0.10:2379,https://192.168.0.20:2379,https://192.168.0.30:2379 \\
--bind-address=192.168.0.10 \\
--secure-port=6443 \\
--advertise-address=192.168.0.10 \\
--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：启用日志
--log-dir:日志目录
--v：日志等级，越小越多
--etcd-servers: etcd集群地址
--bind-address :监听地址
--secure-port：https安全端口
--advertise-address：集群通告地址
--allow-privileged：启用授权
--service-cluster-ip-range：Service虚拟IP地址段
--enable-admission-plugins：准入控制模块，决定是否启用k8s高级功能
--authorization-mode：认证授权，启用RBAC授权和节点自管理
--enable-bootstrap-token-auth：启用TLS bootstrap机制
--token-auth-file：bootstrap token文件
--service-node-port-range：Service nodeport类型默认分配端口范围
--kubelet-https：apiserver主动访问kubectl时默认使用https
--kubelet-client-xxx：apiserver访问kubelet客户端证书
--tls-xxx-file：apiserver https证书
--etcd-xxxfile：连接Etcd集群证书
--audit-log-xxx：审计日志
 
 启用 TLS Bootstrapping 机制 
 TLS Bootstraping：Master apiserver启用TLS认证后，Node节点kubelet和kube-proxy要与kube-apiserver进行通信，必须使用CA签发的有效证书才可以，当Node节点很多时，这种客户端证书颁发需要大量工作，同样也会增加集群扩展复杂度。为了简化流程，Kubernetes引入了TLS bootstraping机制来自动颁发客户端证书，kubelet会以一个低权限用户自动向apiserver申请证书，kubelet的证书由apiserver动态签署。所以强烈建议在Node上使用这种方式，目前主要用于kubelet，kube-proxy还是由我们统一颁发一个证书。 
 此图仅用来学习，不为本人原创 
  
   
    
      
     
    
   
     image 
    
   
  
 4.3.2 拷贝刚才生成的证书 
 cp ~/TLS/k8s/ca*pem ~/TLS/k8s/server*pem /opt/kubernetes/ssl/
 
 4.3.3 创建配置文件中的token文件 
 # 获取16位token随机值的命令
head -c 16 /dev/urandom | od -An -t x | tr -d ' '
863b2ebebecffbb3a6493ff15dfc57c6

# 添加token文件（格式：token,用户名,UID,用户组）
BOOTSTRAP_TOKEN=863b2ebebecffbb3a6493ff15dfc57c6
cat > /opt/kubernetes/cfg/token.csv <
 
 4.3.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
 
 4.3.5 启动并设置开机启动 
 systemctl daemon-reload
systemctl restart kube-apiserver
systemctl enable kube-apiserver
 
 4.3.6 授权kubelet-bootstrapper用户允许请求证书 
 kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap
 
 4.4 部署controller-manager 
 5.4.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保持一致 
  
 4.4.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
 
 4.4.3 启动并设置开机启动 
 systemctl daemon-reload
systemctl restart kube-controller-manager
systemctl enable kube-controller-manager
 
 4.5 部署kube-scheduler 
 4.5.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） 
  
 4.5.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
 
 4.5.3 启动并设置开机启动 
 systemctl daemon-reload
systemctl restart kube-scheduler
systemctl enable kube-scheduler
 
 4.6 查看集群状态 
 所有组件都已经启动成功，通过kubectl工具查看当前集群组件状态 
 [root@k8s-master TLS]# kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}  
 
 输出如上内容说明Master节点组件运行正常 
 五、部署Node节点 
 5.1 创建工作目录并拷贝二进制文件 
 如果想把Master也当做Node节点的话，也可以在Master节点上安装kubelet和kube-proxy 
 # 1.在所有node节点创建工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs} 

# 2. 从master节点上解压的kubernetes压缩包中拷贝文件到所有node节点
for ip in 20 30 ;do scp -rp ./kubernetes/server/bin/{kubelet,kube-proxy} 192.168.0.$ip:/opt/kubernetes/bin/ ;done
 
 5.2 部署kubelet 
 5.2.1 创建配置文件 
  
  pod的基础容器镜像改为国内的下载的镜像地址或自己的Docker Hub 
  registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0 
  245684979/pause-amd64:3.0 
  
 # node1节点
cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=k8s-node1 \\
--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=245684979/pause-amd64:3.0"
EOF

# node2节点
cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=k8s-node2 \\
--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=245684979/pause-amd64:3.0"
EOF
 
  
  –hostname-override：显示主机名称，集群中唯一 
  –network-plugin：启用CNI 
  –kubeconfig：空路径，会自动生成，后面用于连接apiserver 
  –bootstrap-kubeconfig：首次启动向apiserver申请证书 
  –config：配置参数文件 
  –cert-dir：kubelet证书生成目录 
  –pod-infra-container-image：管理Pod网络容器的镜像，用于实现Kubernetes集群里pod之间的网络通讯 
  
 5.2.2 配置参数文件 
 # node1节点和node2节点配置相同
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
 
 5.2.3 生成bootstrap.kubeconfig文件 
 在master节点将node节点需要的CA证书文件拷贝过去 
 [root@k8s-master ~]# scp /opt/kubernetes/ssl/ca.pem k8s-node1:/opt/kubernetes/ssl
[root@k8s-master ~]# scp /opt/kubernetes/ssl/ca.pem k8s-node2:/opt/kubernetes/ssl
 
 在master上查看Token文件的随机值 
 [root@k8s-master ~]# cat /opt/kubernetes/cfg/token.csv 
863b2ebebecffbb3a6493ff15dfc57c6,kubelet-bootstrap,10001,"system:kubelet-bootstrapper"
 
 在master上生成bootstrap.kubeconfig文件 
 KUBE_APISERVER="https://192.168.0.10:6443" # apiserverIP:PORT
TOKEN="863b2ebebecffbb3a6493ff15dfc57c6" # 与token.csv里保持一致

# 设置集群参数
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/

# 拷贝到node节点的/opt/kubernetes/cfg/下
scp -rp /opt/kubernetes/cfg/bootstrap.kubeconfig k8s-node1:/opt/kubernetes/cfg
scp -rp /opt/kubernetes/cfg/bootstrap.kubeconfig k8s-node2:/opt/kubernetes/cfg
 
 5.2.4 配置systemd管理kubelet 
 # node1节点和node2节点配置相同
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.2.5 启动并设置开机启动 
 systemctl daemon-reload
systemctl restart kubelet
systemctl enable kubelet
 
 5.2.6 批准kubelet证书申请并加入集群 
 # 查看kubelet证书请求
[root@k8s-master ~]# kubectl get csr
NAME                                                   AGE   SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-1-0ue-UfiHoWna5v68PDMgrxk1cPPNFLG3EtoUUCdwk   85s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-zjBOatKIi69UhbL7ypngHFw5C7xfjCOZnFyTG4Ux1H0   76s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

# 批准请求
kubectl certificate approve node-csr-1-0ue-UfiHoWna5v68PDMgrxk1cPPNFLG3EtoUUCdwk
kubectl certificate approve node-csr-zjBOatKIi69UhbL7ypngHFw5C7xfjCOZnFyTG4Ux1H0

# 查看node节点状态
[root@k8s-master ~]# kubectl get nodes
NAME           STATUS     ROLES    AGE   VERSION
k8s-node1   NotReady      1s    v1.18.5
k8s-node2   NotReady      1s    v1.18.5
#@注：由于网络插件还没有部署，节点会没有准备就绪 NotReady
 
 5.4 部署kube-proxy 
 5.4.1 创建配置文件 
 # node1节点和node2节点配置相同
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
 
 5.4.2 配置参数文件 
 # node1
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: k8s-node1
clusterCIDR: 10.0.0.0/24
EOF

# node2
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: k8s-node2
clusterCIDR: 10.0.0.0/24
EOF
 
 5.4.3 生成kube-proxy.kubeconfig文件 
 在master节点生成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

[root@k8s-master k8s]# ll kube-proxy*pem
-rw-------. 1 root root 1679 Jul 14 15:41 kube-proxy-key.pem
-rw-r--r--. 1 root root 1403 Jul 14 15:41 kube-proxy.pem
 
 5.4.3 生成kube-proxy.kubeconfig文件 
 在master节点生成kube-proxy.kubeconfig文件 
 KUBE_APISERVER="https://192.168.0.10: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/

# 拷贝到node节点的/opt/kubernetes/cfg/下
scp -rp /opt/kubernetes/cfg/kube-proxy.kubeconfig k8s-node1:/opt/kubernetes/cfg
scp -rp /opt/kubernetes/cfg/kube-proxy.kubeconfig k8s-node2:/opt/kubernetes/cfg
 
 5.4.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.4.5 启动并设置开机启动 
 systemctl daemon-reload
systemctl restart kube-proxy
systemctl enable kube-proxy
 
 六、部署CNI网络 
 6.1 Kubernetes网络模型 (CNI)介绍 
  
  kubernetes集群的网络官方文档 
  github上的CNI文档 
  
 容器网络接口 
 kubernetes网络模型设计的基本要求： 
  
  一个pod一个ip 
  每个pod独立的ip，pod内所有容器共享网络(同一个ip) 
  所有容器都可以与所有其他容器通信 
  所有节点都可以与所有容器通信 
  
 目前支持的技术 
  
   
   . 
   
    
      
     
    
   
     image 
    
   
  
 最常用的是flannel和calic 
  
  Flannel：适合百台以下服务器，小规模集群，使用操作简单 
  calico：适合数百台以上，大规模集群 
  
 6.2 下载安装包 
 下载最新版地址：https://github.com/containernetworking/plugins/releases/tag/v0.8.6 
 wget https://github.com/containernetworking/plugins/releases/download/v0.8.6/cni-plugins-linux-amd64-v0.8.6.tgz

# 解压二进制包并移动到默认工作目录
mkdir -p /opt/cni/bin
tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin

# 在node节点创建cni目录
mkdir -p /opt/cni/bin

# 在master节点上拷贝到node节点的cni目录
scp -rp /opt/cni/bin/* k8s-node1:/opt/cni/bin/
scp -rp /opt/cni/bin/* k8s-node2:/opt/cni/bin/
 
 6.3 部署CNI flannel 网络 
 所有的节点都需要安装flannel 
 # 部署CNI网络(网络问题可以多尝试几次)
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

# 默认镜像地址无法访问外网，可以修改为docker hub镜像仓库
# 245684979/flannel:v0.12.0-amd64
sed -ri "s#quay.io/coreos/flannel:.*-amd64#245684979/flannel:v0.11.0-amd64#g" kube-flannel.yml

#添加"--iface=eth0"一句指定网卡
...
containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.12.0-amd64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        - --iface=eth0
 
 [root@k8s-master ~]# kubectl apply -f kube-flannel.yml

#查看kube-system下的pod
[root@k8s-master cni]# kubectl get pods -n kube-system
NAME                          READY   STATUS    RESTARTS   AGE
kube-flannel-ds-amd64-lklmb   1/1     Running   0          74s
kube-flannel-ds-amd64-t5tcc   1/1     Running   0          74s

#查看node状态
[root@k8s-master ~]# kubectl get nodes
NAME        STATUS   ROLES    AGE    VERSION
k8s-node1   Ready       2m3s   v1.18.5
k8s-node2   Ready       104s   v1.18.5
 
 6.4 授权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
  name: system:kube-apiserver-to-kubelet
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:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kubernetes
EOF


kubectl apply -f apiserver-to-kubelet-rbac.yaml
 
 八、部署Dashboard和CoreDNS 
 8.1 部署Dashboard 
 https://github.com/kubernetes/dashboard 
 wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.3/aio/deploy/recommended.yaml
 
 默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部 
 # 修改yaml文件
[root@k8s-master yaml]# vim recommended.yaml    (32gg)
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001       #添加类型
  type: NodePort
  selector:
    k8s-app: kubernetes-dashboard


# 生成dashboard
kubectl apply -f recommended.yaml

# 查看dashboard状态
[root@k8s-master yaml]# kubectl get pods,svc -n kubernetes-dashboard
NAME                                             READY   STATUS              RESTARTS   AGE
pod/dashboard-metrics-scraper-6b4884c9d5-gqs7b   0/1     ContainerCreating   0          34s
pod/kubernetes-dashboard-7f99b75bf4-mgg46        0/1     ContainerCreating   0          35s

NAME                                TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)         AGE
service/dashboard-metrics-scraper   ClusterIP   10.0.0.105           8000/TCP        35s
service/kubernetes-dashboard        NodePort    10.0.0.80            443:30001/TCP   35s
 
 查看pod日志 
  kubectl -n kube-system  logs -f  kube-flannel-ds-amd64-24jxf

部署Kubernetes集群（二进制 v1.18.5版）

一、Kubernetes的基本知识

1. 安装要求

2. 系统初始化配置

二、部署Etcd集群

2.1 准备cfssl证书生成工具

2.2 生成Etcd证书

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

2.2.2 使用自签CA签发Etcd HTTPS证书

2.3 从Github下载Etcd二进制文件

2.4 部署Etcd集群

2.4.1 创建目录并解压二进制包

2.4.2 创建etcd配置文件

2.4.3 配置systemd管理etcd

2.4.3 拷贝生成的证书

2.4.5 启动并设置自启动

2.4.6 将master节点生成所有的文件拷贝到两台node节点

2.4.7 在node节点分别修改etcd.conf配置文件中的节点名称和当前服务器IP

2.4.8 查看etcd集群状态

三、所有节点部署Docker

四、部署Master节点

4.1 生成kube-apiserver证书

4.1.1 自签CA证书颁发机构

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

4.2下载二进制文件包并解压

4.3 部署kube-apiserver

4.3.1. 创建配置文件

4.3.2 拷贝刚才生成的证书

4.3.3 创建配置文件中的token文件

4.3.4 配置systemd启动apiserver

4.3.5 启动并设置开机启动

4.3.6 授权kubelet-bootstrapper用户允许请求证书

4.4 部署controller-manager

5.4.1 创建配置文件

4.4.2 配置systemd启动controller-manager

4.4.3 启动并设置开机启动

4.5 部署kube-scheduler

4.5.1 创建配置文件

4.5.2 配置systemd管理scheduler

4.5.3 启动并设置开机启动

4.6 查看集群状态

五、部署Node节点

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

5.2 部署kubelet

5.2.1 创建配置文件

5.2.2 配置参数文件

5.2.3 生成bootstrap.kubeconfig文件

5.2.4 配置systemd管理kubelet

5.2.5 启动并设置开机启动

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

5.4 部署kube-proxy

5.4.1 创建配置文件

5.4.2 配置参数文件

5.4.3 生成kube-proxy.kubeconfig文件

5.4.3 生成kube-proxy.kubeconfig文件

5.4.4 配置systemd管理kube-proxy

5.4.5 启动并设置开机启动

六、部署CNI网络

6.1 Kubernetes网络模型 (CNI)介绍

6.2 下载安装包

6.3 部署CNI flannel 网络

6.4 授权apiserver访问kubelet

八、部署Dashboard和CoreDNS

8.1 部署Dashboard

你可能感兴趣的:(部署Kubernetes集群（二进制 v1.18.5版）)