k8s集群二进制部署

1.Kubernetes部署方式

minikube

Minikube是一个工具，可以在本地快速运行一个单点的Kubernetes，尝试Kubernetes或日常开发的用户使用。不能用于生产环境。

官方地址：https://kubernetes.io/docs/setup/minikube/

kubeadm

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

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

二进制包

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

小结:

生产环境中部署Kubernetes集群，只有Kubeadm和二进制包可选，Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。我们这里使用二进制包部署Kubernetes集群，推荐大家使用这种方式，虽然手动部署麻烦点，但学习很多工作原理，更有利于后期维护。

2.环境准备

2.1 软件环境

软件	版本
操作系统	Ubuntu16.04
Docker	18.09.7
Kubernetes	1.17.3

2.2 服务器角色

角色	IP	组件
k8s-master、node01	172.23.17.27	kube-apiserver，kube-controller-manager，kube-scheduler，etcd，flannel，kubelet，kube-proxy，docker
k8s-node02	172.23.17.28	kubelet，kube-proxy，docker，flannel，etcd
k8s-node03	172.23.17.29	kubelet，kube-proxy，docker，flannel，etcd

2.3 架构图

2.4 初始化操作

所有机器执行：

关闭防火墙：

#ufw disable

关闭swap分区：

#swapoff -a

关闭SELinux：

#setenforce 0

3.部署Etcd集群

etcd 是基于 Raft 的分布式 key-value 存储系统，由 CoreOS 开发，常用于服务发现、共享配置以及并发控制（如 leader 选举、分布式锁等）。kubernetes 使用 etcd 存储所有运行数据。

3.1 下载工具

使用cfssl来生成自签证书，先下载cfssl工具：

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

将工具移动到指定目录并添加到环境变量：

#mv cfssl_linux-amd64 /work/k8s/cfssl/cfssl
#mv cfssljson_linux-amd64 /work/k8s/cfssl/cfssljson
#mv cfssl-certinfo_linux-amd64 /work/k8s/cfssl/cfssl-certinfo
#export PATH=/work/k8s/cfssl:$PATH

3.2 生成证书

只需要在其中任何一台机器生成证书，拷贝到另外的机器需要的位置即可。

mkdir -p /work/k8s/pem && cd /work/k8s/pem

创建以下三个文件：

#vim ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
#vim ca-csr.json
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}

#vim server-csr.json
{
    "CN": "etcd",
    "hosts": [
    "172.23.17.27",
    "172.23.17.28",
    "172.23.17.29"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}

生成证书

#cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
#cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server
# ls *pem
ca-key.pem  ca.pem  server-key.pem  server.pem

3.3部署Etcd（所有节点）

证书可以复用，需要每台Node操作以下步骤。下载最新版本的etcd（本文下载的3.3.18版本）：https://github.com/etcd-io/etcd/releases

#mkdir -p /opt/etcd/{bin,cfg,ssl}
#tar -xvzf etcd-v3.3.18-linux-amd64.tar.gz 
#mv etcd-v3.3.18-linux-amd64/{etcd,etcdctl} /opt/etcd/bin

修改/etc/profile，将/opt/etcd/bin加入到环境变量：

#export PATH=/opt/etcd/bin:$PATH

创建etcd配置文件，每台机器需要将ETCD_INITIAL_CLUSTER之外的字段，改成本机IP，ETCD_NAME修改为本机定义好的node名称。

#vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://172.23.17.27:2380"
ETCD_LISTEN_CLIENT_URLS="https://172.23.17.27:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://172.23.17.27:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://172.23.17.27:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://172.23.17.27:2380,etcd02=https://172.23.17.28:2380,etcd03=https://172.23.17.29:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

字段解释：

l ETCD_NAME 节点名称
l ETCD_DATA_DIR 数据目录
l ETCD_LISTEN_PEER_URLS 集群通信监听地址
l ETCD_LISTEN_CLIENT_URLS 客户端访问监听地址
l ETCD_INITIAL_ADVERTISE_PEER_URLS 集群通告地址
l ETCD_ADVERTISE_CLIENT_URLS 客户端通告地址
l ETCD_INITIAL_CLUSTER 集群节点地址
l ETCD_INITIAL_CLUSTER_TOKEN 集群Token
l ETCD_INITIAL_CLUSTER_STATE 加入集群的当前状态，new是新集群，existing表示加入已有集群

配置systemd管理etcd

#vim /etc/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

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

[Install]
WantedBy=multi-user.target

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

#cp  pem/*.pem /opt/etcd/ssl/

　　所有机器都配置好了之后，同时启动并设置开启启动：

#systemctl start etcd
#systemctl enable etcd

　　如果执行失败，可以通过 journalctl -ex -u etcd查看错误日志。

　　搭建完成，使用3.0版本做命令检查。本文使用的是etcd 3.3.18,所以每台节点是要设置export ETCDCTL_API=3，保证etcd 3版本API正常调用，可以设置到/etc/profile。

　　查询节点列表：etcdctl member list

　　k8s现在使用的是etcd v3，必须提供ca、key、cert，否则会出现Error: context deadline exceeded：

　　不加--endpoint参数时，默认访问的127.0.0.1:2379，而使用--endpoint参数时，必须提供ca,key,cert。

#etcdctl endpoint health

　　提供ca,key,cert：

#etcdctl  --endpoints=https://172.23.17.27:2379,https://172.23.17.28:2379,https://172.23.17.29:2379  --cacert=/opt/etcd/ssl/ca.pem --key=/opt/etcd/ssl/server-key.pem  --cert=/opt/etcd/ssl/server.pem  endpoint health

　　常见错误：

　　配置完master执行systemctl start etcd，无法启动，journalctl -ex -u etcd查询到错误日志：publish error: etcdserver: request timed out，etcd.service中制定了其他etcd主机，所以当单独启动一台是连接其他主机不通，那么etcd就启动失败。所以要把etcd集群中所有主机都配置好，同时启动就OK了。

4.Node安装docker

　　每台机器执行apt-get install docker.io

5.部署Flannel网络

5.1 工作原理

　　Flannel 实质上是一种“覆盖网络(overlay network)”，也就是将TCP数据包装在另一种网络包里面进行路由转发和通信，目前已经支持UDP、VxLAN、AWS VPC和GCE路由等数据转发方式。Flannel 在 Kubernetes中用于配置第三层（网络层）网络结构。

　　Flannel 负责在集群中的多个节点之间提供第 3 层 IPv4 网络。Flannel 不控制容器如何与主机联网，只负责主机之间如何传输流量。但是，Flannel 确实为 Kubernetes 提供了 CNI 插件，并提供了与 Docker 集成的指导。

　　[^]: 没有 Flanneld 网络，Node节点间的 pod 不能通信，只能 Node 内通信。有 Flanneld 服务启动时主要做了以下几步的工作：从 ETCD 中获取 NetWork 的配置信息划分 Subnet，并在 ETCD 中进行注册,将子网信息记录到 /run/flannel/subnet.env 中。

5.2添加flannel网络配置信息到etcd

　　目录（coreos.com）自己可以定义，但是此处设置的目录必须与flannel配置文件（后续会配置）中FLANNEL_ETCD_PREFIX="/coreos.com/network"配置保持一致，flannel启动程序只认带“config”的key，否则会报错Not a directory (/coreos.com/network) 。

　　这里需要注意的是，Flanneld 当前版本 (v0.11.0) 不支持 ETCD v3，所以使用 ETCD v2 API 写入配置 key 和网段数据；写入的 Pod 网段 ${CLUSTER_CIDR} 必须是 /16 段地址，必须与 kube-controller-manager 的 –cluster-cidr 参数值一致；必须使用etcd2.0版本的API设置，需要现在机器执行

#export ETCDCTL_API=2

　　然后执行下面命令：

#etcdctl --ca-file=/opt/etcd/ssl/ca.pem --cert-file=/opt/etcd/ssl/server.pem --key-file=/opt/etcd/ssl/server-key.pem --endpoints="https://172.23.17.27:2379,https://172.23.17.28:2379,https://172.23.17.29:2379" set /coreos.com/network/config '{"Network":"172.17.0.0/16","Backend":{"Type":"vxlan"}}'

5.3 部署flannel（所有节点）

　　下载二进制包（本文下载的0.11.0版本）：https://github.com/coreos/flannel/releases/。

#tar -xvzf flannel-v0.11.0-linux-amd64.tar.gz 
#mkdir -p /opt/kubernetes/{bin,cfg}
#mv flanneld mk-docker-opts.sh /opt/kubernetes/bin/

　　配置：

#vim /opt/kubernetes/cfg/flanneld 

FLANNEL_OPTIONS="--etcd-endpoints=https://172.23.17.27:2379,https://172.23.17.28:2379,https://172.23.17.29:2379 -etcd-cafile=/opt/etcd/ssl/ca.pem -etcd-certfile=/opt/etcd/ssl/server.pem -etcd-keyfile=/opt/etcd/ssl/server-key.pem"
FLANNEL_ETCD_PREFIX="-etcd-prefix=/coreos.com/network"

　　systemd管理Flannel：

#vim /etc/systemd/system/flanneld.service

[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service

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

[Install]
WantedBy=multi-user.target

　　配置Docker启动指定子网段：

#vim /etc/systemd/system/docker.service

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

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

[Install]
WantedBy=multi-user.target

　　重启flannel和docker：

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

　　注：启动Flannel后，一定要记得重启docker，这样Flannel配置分配的ip才能生效，即docker0虚拟网卡的ip会变成上面flannel设定的ip段。

　　检验是否生效，通过ps -ef | grep docker和ip addr检验。

　　确保docker0与flannel.1在同一网段。

　　测试不同节点互通，在当前节点访问另一个Node节点docker0 IP：

　　etcd01上docker0的地址为：172.17.8.1

　　etcd02上的docker0的地址为：172.17.30.1

　　在etcd01 ping etcd02的docker0地址：ping 172.17.30.1，能ping通则表示 flannel部署成功，不成功则检查下日志：journalctl -u flanneld

　　常见错误：

　　flannel启动失败，查看日志： Couldn't fetch network config: 104: Not a directory (/coreos.com/network)。

　　问题定位：是否使用的etcd 2.0的API插入网络配置信息，当前版本（V0.11.0及以下）只能支持etcdV2版本的API，3.0的API即使使用put命令设置了key，flannel也是无法读取；/opt/kubernetes/cfg中的配置文件中$FLANNEL_ETCD_PREFIX设置是否有误。

6.在Master节点部署组件

6.1 组件概述

　　Kubernetes Master 节点运行如下组件：

APIServer

　　APIServer负责对外提供RESTful的kubernetes API的服务，它是系统管理指令的统一接口，任何对资源的增删该查都要交给APIServer处理后再交给etcd，kubectl(kubernetes提供的客户端工具，该工具内部是对kubernetes API的调用）是直接和APIServer交互的。

Scheduler

　　scheduler负责调度Pod到合适的Node上，如果把scheduler看成一个黑匣子，那么它的输入是pod和由多个Node组成的列表，输出是Pod和一个Node的绑定。 kubernetes目前提供了调度算法，同样也保留了接口。用户根据自己的需求定义自己的调度算法。

Controller manager

　　如果APIServer做的是前台的工作的话，那么controller manager就是负责后台的。每一个资源都对应一个控制器。而control manager就是负责管理这些控制器的，比如我们通过APIServer创建了一个Pod，当这个Pod创建成功后，APIServer的任务就算完成了。

ETCD

　　etcd是一个高可用的键值存储系统，kubernetes使用它来存储各个资源的状态，从而实现了Restful的API。

Flannel

　　默认没有flanneld网络，Node节点间的pod不能通信，只能Node内通信，Flannel从etcd中获取network的配置信息划分subnet，并在etcd中进行注册将子网信息记录

　　注:kube-scheduler 和 kube-controller-manager 可以以集群模式运行，通过 leader 选举产生一个工作进程，其它进程处于阻塞模式。

　　在部署Kubernetes之前一定要确保etcd、flannel、docker是正常工作的，否则先解决问题再继续。

6.2 生成证书

　　创建CA证书

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

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

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

　　生成apiserver证书：

#vim server-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "172.23.17.27",
      "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"
        }
    ]
}
#cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

　　生成kube-proxy证书：

#vim 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"
    }
  ]
}

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

　　最终生成以下证书文件：

6.3 部署apiserver组件

　　下载二进制包（本文下载的是V1.17.3）：https://github.com/kubernetes/kubernetes/releases。

　　下载kubernetes-server-linux-amd64.tar.gz就够了，包含了所需的所有组件。

#mkdir /opt/kubernetes/{bin,cfg,ssl} -p
#tar zxvf kubernetes-server-linux-amd64.tar.gz
#cd kubernetes/server/bin
#cp kube-apiserver kube-scheduler kube-controller-manager kubectl /opt/kubernetes/bin

　　将刚才生成的pem证书拷贝到将要部署的目录.

#cp *pem /opt/kubernetes/ssl

　　添加/opt/kubernetes/bin到环境变量，也可写入/etc/profile

#export PATH=/opt/kubernetes/bin:$PATH

　　创建token文件，用途后面会讲到：

#vim /opt/kubernetes/cfg/token.csv
674c457d4dcf2eefe4920d7dbb6b0ddc,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

　　配置解释：

第一列：随机字符串，自己可生成
第二列：用户名
第三列：UID
第四列：用户组

　　创建apiserver配置文件：

#vim /opt/kubernetes/cfg/kube-apiserver 
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://172.23.17.27:2379,https://172.23.17.28:2379,https://172.23.17.29:2379 \
--bind-address=172.23.17.27 \
--secure-port=6443 \
--advertise-address=172.23.17.27 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/opt/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--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"

　　配置好前面生成的证书，确保能连接etcd。

　　参数说明：

–logtostderr 启用日志
–v 日志等级
–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 token文件
–service-node-port-range Service Node类型默认分配端口范围

　　systemd管理apiserver：

#vim /etc/systemd/system/kube-apiserver.service 
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
ExecStart=/opt/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

　　启动：

#systemctl daemon-reload
#systemctl enable kube-apiserver
#systemctl restart kube-apiserver

6.4 部署scheduler组件

　　创建schduler配置文件：

#vim /opt/kubernetes/cfg/kube-scheduler 
KUBE_SCHEDULER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect"

　　参数说明：

–master 连接本地apiserver
–leader-elect 当该组件启动多个时，自动选举（HA）

　　systemd管理schduler组件：

#vim /etc/systemd/system/kube-scheduler.service 
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

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

[Install]
WantedBy=multi-user.target

　　启动

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

6.5 部署controller-manager组件

　　创建controller-manager配置文件：

#vim /opt/kubernetes/cfg/kube-controller-manager 
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \
--root-ca-file=/opt/kubernetes/ssl/ca.pem \
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem"
systemd管理controller-manager组件：
vim /etc/systemd/system/kube-controller-manager.service 
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

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

[Install]
WantedBy=multi-user.target

　　启动：

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

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

#/opt/kubernetes/bin/kubectl get cs

　　如上输出说明组件都正常。

7.在Node节点部署组件

7.1 组件概述

　　Kubernetes Node 节点运行如下组件：

Proxy

　　该模块实现了kubernetes中的服务发现和反向代理功能。kube-proxy支持TCP和UDP连接转发，默认基Round Robin算法将客户端流量转发到与service对应的一组后端pod。服务发现方面，kube-proxy使用etcd的watch机制监控集群中service和endpoint对象数据的动态变化，并且维护一个service到endpoint的映射关系，从而保证了后端pod的IP变化不会对访问者造成影响，另外，kube-proxy还支持session affinity。

Kublet

　　kublet是Master在每个Node节点上面的agent，是Node节点上面最重要的模块，它负责维护和管理该Node上的所有容器，但是如果容器不是通过kubernetes创建的，它并不会管理。本质上，它负责使Pod的运行状态与期望的状态一致。 kublet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况; 为确保安全，只开启接收 https 请求的安全端口，对请求进行认证和授权，拒绝未授权的访问(如apiserver、heapster)。

Flannel

　　默认没有flanneld网络，Node节点间的pod不能通信，只能Node内通信，Flannel从etcd中获取network的配置信息划分subnet，并在etcd中进行注册将子网信息记录。

ETCD

　　ETCD是一个高可用的键值存储系统，kubernetes使用它来存储各个资源的状态，从而实现了Restful的API。

7.2 节点认证流程

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

　　认证大致工作流程如图所示：

　　将kubelet-bootstrap用户绑定到系统集群角色

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

7.3 创建kubeconfig文件

　　在生成kubernetes证书的目录下生成kubeconfig文件：

　　将如下命令写入到脚本并执行：

#vim gen_config.sh
# 创建kubelet bootstrapping kubeconfig 
BOOTSTRAP_TOKEN=674c457d4dcf2eefe4920d7dbb6b0ddc
KUBE_APISERVER="https://172.23.17.27:6443"

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

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

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

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

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

# 创建kube-proxy kubeconfig文件

kubectl config set-cluster kubernetes \
  --certificate-authority=./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

　　执行

#./gen_config.sh

　　将生成bootstrap.kubeconfig和kube-proxy.kubeconfig两个文件。

　　将这两个文件拷贝到Node节点/opt/kubernetes/cfg目录下。

7.4 部署kubelet组件（所有节点）

　　将前面下载的二进制包中的kubelet和kube-proxy拷贝到/opt/kubernetes/bin目录下。

　　创建kubelet配置文件：

#vim /opt/kubernetes/cfg/kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=172.23.17.27 \
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
--config=/opt/kubernetes/cfg/kubelet.config \
--cert-dir=/opt/kubernetes/ssl \
--pod-infra-container-image=172.23.17.35:8082/neutron_public/google-containers/k8s.gcr.io/pause:3.1"

　　参数说明：

–hostname-override 在集群中显示的主机名
–kubeconfig 指定kubeconfig文件位置，会自动生成
–bootstrap-kubeconfig 指定刚才生成的bootstrap.kubeconfig文件
–cert-dir 颁发证书存放位置
–pod-infra-container-image 管理Pod网络的镜像，Pod的基础，如果无内网，可以配置自己搭建的harbor镜像仓库，本文配置的就是自己搭建的harbor仓库。

　　创建kubelet配置文件：

#vim /opt/kubernetes/cfg/kubelet.config
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 172.23.17.27
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS: ["10.0.0.2"]
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
enabled: true

　　systemd管理kubelet组件：

#vim /etc/systemd/system/kubelet.service 
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

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

[Install]
WantedBy=multi-user.target

　　启动：

#systemctl daemon-reload
#systemctl enable kubelet
#systemctl restart kubelet

　　在Master审批Node加入集群：

　　启动后还没加入到集群中，需要手动允许该节点才可以。

　　在Master节点查看请求签名的Node：

#kubectl get csr

　　审批加入集群：

#kubectl certificate approve XXXXID

　　xxxxID为kubectl get csr查询出来的ID。

　　验证是否加入集群：kubectl get csr

7.5部署kube-proxy组件（所有节点）

　　kube-proxy 运行在所有 Node 节点上，它监听 apiserver 中 service 和 Endpoint 的变化情况，创建路由规则来进行服务负载均衡

　　创建kube-proxy配置文件：

#vim /opt/kubernetes/cfg/kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=172.23.17.29 \
--cluster-cidr=10.0.0.0/24 \
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

　　systemd管理kube-proxy组件：

#vim /etc/systemd/system/kube-proxy.service 
[Unit]
Description=Kubernetes Proxy
After=network.target

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

[Install]
WantedBy=multi-user.target

　　启动：

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

8.查看集群状态

　　通过kubectl get node和kubectl get cs命令查看集群状态

posted @ 2021-03-17 17:11 Memset 阅读(590) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

渔舟唱晚

k8s集群二进制部署

1.Kubernetes部署方式

2.环境准备

2.1 软件环境

2.2 服务器角色

2.3 架构图

2.4 初始化操作

3.部署Etcd集群

3.1 下载工具

3.2 生成证书

3.3部署Etcd（所有节点）

4.Node安装docker

5.部署Flannel网络

6.在Master节点部署组件

6.3 部署apiserver组件

6.4 部署scheduler组件

6.5 部署controller-manager组件

7.在Node节点部署组件

7.3 创建kubeconfig文件

7.4 部署kubelet组件（所有节点）

7.5部署kube-proxy组件（所有节点）

8.查看集群状态

公告