centos7 k8s二进制部署项目 k8s二进制部署好处

       Kubernetes（k8s）是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效，Kubernetes提供了应用部署，规划，更新，维护的一种机制。
       简单的说，k8s就是容器的编排工具，有了它我们不需要单独管理容器，可以使用k8s对容器进行统一管理。

目录

• 一、Kubernetes 概述
• 二、Kubernetes部署

• 1.资源准备
• 2.系统环境配置
• 3.自签SSL证书
• 4.Etcd数据库集群部署
• 5.Node安装Docker
• 6.Flannel容器集群网络部署
• 7.部署Master组件
• 8.部署Node组件

一、Kubernetes 概述

       Kubernetes是什么：

• Kubernetes是Google在2014年开源的一个容器集群管理系统，Kubernetes简称K8S。
• K8S用于容器化应用程序的部署，扩展和管理。
• K8S提供了容器编排，资源调度，弹性伸缩，部署管理，服务发现等一系列功能。
• Kubernetes目标是让部署容器化应用简单高效。

       Kubernetes架构与组件：

Master组件：

• kube-apiserver：Kubernetes API，集群的统一入口，各组件协调者，以 RESTful API提供接口服务，所有对象资源的增删改查和监听 操作都交给APIServer处理后再提交给Etcd存储。
• kube-controller-manager：处理集群中常规后台任务，一个资源对应一个控制器，而 ControllerManager就是负责管理这些控制器的。
• kube-scheduler：根据调度算法为新创建的Pod选择一个Node节点，可以任意 部署,可以部署在同一个节点上,也可以部署在不同的节点上。
• etcd：分布式键值存储系统。用于保存集群状态数据，比如Pod、 Service等对象信息。

Node组件：

• kubelet：kubelet是Master在Node节点上的Agent，管理本机运行容器 的生命周期，比如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作。kubelet将每个Pod转换成一组容器。
• kube-proxy：在Node节点上实现Pod网络代理，维护网络规则和四层负载均 衡工作。

       Kubernetes的几种部署方式：

• Minikube：Minikube是一个工具，可以在本地快速运行一个单点的Kubernetes，仅用于尝试Kubernetes或日常开发的用户使用。
• kubeadm：Kubeadm也是一个工具，提供kubeadm init和kubeadm join，用于快速部署Kubernetes集群。
• 二进制：从官方下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群。 这种方式搭建的集群，可以在集群报错的情况下，通过自定义的日志文件快速定位到错误。

       Kubernetes核心概念：

Pod：

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

Controllers：

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

Service： 定义一组Pod的访问策略
Label ： 标签，附加到某个资源上，用于关联对象、查询和筛选
Namespace ： 命名空间，将对象逻辑上隔离

       因为生产环境上采用的基本都是二进制方式搭建，本博客会按照二进制的方式，一步步搭建一个高可用的并且使用本地镜像仓库harbor的k8s集群。

二、Kubernetes部署

1.资源准备

• k8s-master：10.3.214.20
• k8s-node-01:10.3.214.21
• k8s-node-02:10.3.214.22
• k8s-harbor：10.3.214.23

以上所有服务器配置均为：Centos7，4核cpu，8G内存，200G磁盘
最低服务器配置：2核cpu，4G内存

2.系统环境配置

（1）关闭selinux：setenforce 0 （2）禁用selinux：vim /etc/selinux/config

SELINUX=disabled

（3）关闭防火墙并且禁用：systemctl stop firewalld && systemctl disable firewalld （4）修改主机名，集群主机进行通讯：vim /etc/hostname

10.3.214.20：k8s-master-01
10.3.214.21：k8s-node-01
10.3.214.22：k8s-node-02
10.3.214.23：k8s-harbor
修改配置文件需要重启才能生效，可用立即生效命令：hostname k8s-master-01
退出终端，重新打开终端即可生效。

（5）集群的每一台服务器都同步互联网时间：

安装工具：yum install -y ntp
同步时间：ntpdate time.windows.com

3.自签SSL证书

       生产环境下的k8s集群每个组件之间进行相互访问必须进行加密，因此我们需要为每个集群组件自签SSL证书。

下图是每个组件需要生成的证书：

（1）安装生成证书的工具cfssl：

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

（2）生成自签的CA机构：

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

当前执行目录会生成2个json文件

（3）生成CA的根证书：cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

当前执行目录生成根证书，ca-key.pem、ca.pem两个根证书。

（4）根证书为etcd生成证书：

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

当前执行目录生成json文件：server-csr.json

使用server.json文件请求生成etcd证书：cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

当前执行目录生成2个证书文件，server.pem、server-key.pem

4.Etcd数据库集群部署

对于所有二进制安装来讲，每一个组件部署都是：生成配置文件 — systemd管理组件 — 启动服务

（1）github下载etcd的二进制包：https://github.com/etcd-io/etcd/releases

（2）上传到服务器的/root/k8s/soft目录下解压：tar -xzvf etcd-v3.3.10-linux-amd64.tar.gz

（3）创建目录，用于存放每个组件的服务：mkdir /opt/etcd/{cfg,bin,ssl} -pv

cfg：存放配置文件
bin：存放可执行文件
ssl：存放证书

（4）移动可执行文件：mv etcd etcdctl /opt/etcd/bin/ （5）拷贝etcd的证书到etcd的ssl目录下：cp {ca,server-key,server}.pem /opt/etcd/ssl/ （6）执行脚本，生成etcd的配置文件，下边是脚本文件内容：vim etcd.sh

#!/bin/bash

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

WORK_DIR=/opt/etcd

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

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

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

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

[Install]
WantedBy=multi-user.target
EOF

（7）执行脚本：./etcd.sh etcd01 10.3.214.20 etcd02=https://10.3.214.21:2380,etcd03=https://10.3.214.22:2380

（8）启动服务，并且设置开机自启：

systemctl daemon-reload
systemctl enable etcd
systemctl start etcd

此时etcd只启动了一台，并且查看日志，etcd会一直提示无法连接到其他两个节点：

（9）在其他两个节点安装etcd，我们将etcd服务相关的文件拷贝即可，不需要重新生成：

拷贝配置文件、可执行文件、SSL证书：
scp -r /opt/etcd/ root@10.3.214.21:/opt
scp -r /opt/etcd/ root@10.3.214.22:/opt
拷贝服务：
scp /usr/lib/systemd/system/etcd.service root@10.3.214.21:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@10.3.214.22:/usr/lib/systemd/system/

（10）拷贝到其他节点的etcd服务文件需要修改ip信息：vim /opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd02"  ##此处修改为节点名字
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://10.3.214.21:2380"   ##修改ip为本节点ip
ETCD_LISTEN_CLIENT_URLS="https://10.3.214.21:2379"  ##修改ip为本节点ip

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.3.214.21:2380"  ##修改ip为本节点ip
ETCD_ADVERTISE_CLIENT_URLS="https://10.3.214.21:2379"  ##修改ip为本节点ip
ETCD_INITIAL_CLUSTER="etcd01=https://10.3.214.20:2380,etcd02=https://10.3.214.21:2380,etcd03=https://10.3.214.22:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

同理，etcd03节点也是如此操作。

（11）启动etcd：

因为修改了配置文件，需要重读一下配置文件：
systemctl daemon-reload
systemctl start etcd
systemctl enable etcd

同理，etcd03节点也是如此操作。

（12）查看etcd01节点的日志：

三个节点全部建立连接，说明etcd集群部署成功。

5.Node安装Docker

（1）docker官网指导安装：https://docs.docker.com/v17.12/install/linux/docker-ce/centos/#prerequisites，选择Centos版本

1.卸载旧版本的docker：
      yum remove docker \
      docker-client \
      docker-client-latest \
      docker-common \
      docker-latest \
      docker-latest-logrotate \
      docker-logrotate \
      docker-selinux \
      docker-engine-selinux \
      docker-engine
  2.安装所需软件包：
      yum install -y yum-utils \
      device-mapper-persistent-data \
      lvm2
  3.添加稳定的存储库：yum-config-manager \
      --add-repo \
      https://download.docker.com/linux/centos/docker-ce.repo
  4.安装最新的docker版本：yum install docker-ce
  5.打印docker历史版本，并且指定版本安装：yum list docker-ce --showduplicates | sort -r
                                       yum install docker-ce-18.09.9 -y
                                       第一次安装会确认指纹，输入y，进行安装
  6.设置docker开机启动：systemctl enable docker
  7.启动docker：systemctl start docker

（2）添加docker加速器，目的是为了集群拉取镜像的速度更快：curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io （3）重启docker：systemctl restart docker

6.Flannel容器集群网络部署

（1）下载flannel二进制包：https://github.com/coreos/flannel/releases

（2）将可供flanneld分配给容器的网段，存入到etcd中：

/opt/etcd/bin/etcdctl \
--ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem \
--endpoints="https://10.3.214.20:2379,https://10.3.214.21:2379,https://10.3.214.22:2379" \
set /coreos.com/network/config  '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

（3）解压flannel的二进制压缩包：
（4）创建flannel的工作目录：mkdir /opt/kubernetes/{bin,cfg,ssl} -pv （5）一定flannel的执行文件到flannel工作目录：mv flanneld mk-docker-opts.sh /opt/kubernetes/bin/ （6）下边是生成flannel的配置文件以及服务的脚本：vim flannel.sh

#!/bin/bash

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

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

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

EOF

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

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

[Install]
WantedBy=multi-user.target

EOF

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

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

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

[Install]
WantedBy=multi-user.target

EOF

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

（7）执行脚本，这个脚本需要带etcd的地址参数：./flannel.sh https://10.3.214.20:2379,https://10.3.214.21:2379,https://10.3.214.22:2379

（8）查看flanneld进程：

（9）查看docker是否已经分配了flanneld的网段：ps aux | grep dockerd

（10）部署node节点的flannel网络，将flannel生成的配置文件以及服务文件拷贝到node节点（当然，你也可以在node节点重复执行master节点的操作）：

scp -r /opt/kubernetes/ root@10.3.214.21:/opt/
scp /usr/lib/systemd/system/{flanneld,docker}.service root@10.3.214.21:/usr/lib/systemd/system/
scp -r /opt/kubernetes/ root@10.3.214.22:/opt/
scp /usr/lib/systemd/system/{flanneld,docker}.service root@10.3.214.22:/usr/lib/systemd/system/

（11）node节点重启flanneld服务：

systemctl daemon-reload
systemctl start flanneld

（12）node节点重启docker服务：systemctl restart docker （13）验证flannel网络：flannel构建的是一个扁平化的网络，我们在三个节点都启动一个容器，然后三个节点和三个容器的网络都是互通的，那么证明flannel网络构建成功

下载busybox镜像：docker pull busybox
启动容器：docker run -it busybox
看三个容器的ip地址：ifconfig
三个容器与三个节点互相ping，看是否ping的通

验证通过，flannel网络部署完成。

7.部署Master组件

master需要部署的组件共三个：

• kube-apiserver
• kube-controller-manager
• scheduler

（1）下载master组件的二进制包：https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.18.md#v1186

（2）下载的二进制包解压：tar -xzvf kubernetes-server-linux-amd64.tar.gz

（3）拷贝master组件的执行文件到服务的配置目录：cp kube-apiserver kube-controller-manager kube-scheduler /opt/kubernetes/bin/

（4）执行脚本，生成每个组件（包括master和node）的证书文件：vim k8s-cert.sh

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

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

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

#-----------------------
#--这里的IP地址是自己以后规划的集群ip地址，可以写多个。
cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "10.3.214.20",
      "10.3.214.21",
      "10.3.214.22",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

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

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

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

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

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

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

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

（5）执行脚本，生成各个组件的证书：`./k8s-cert.sh`

（6）拷贝证书到组件服务的证书目录下：cp ca.pem ca-key.pem server.pem server-key.pem /opt/kubernetes/ssl/

（7）生成集群的token（认证文件）文件token.csv，执行下边的指令：

BOOTSTRAP_TOKEN=0fb61c46f8991b718eb38d27b605b008

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

（8）拷贝token文件到集群的配置文件中：cp token.csv /opt/kubernetes/cfg/

（9）执行下边脚本，生成api-server的配置文件：vim apiserver.sh

#!/bin/bash

MASTER_ADDRESS=$1
ETCD_SERVERS=$2

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

KUBE_APISERVER_OPTS="--logtostderr=true \\
--v=4 \\
--etcd-servers=${ETCD_SERVERS} \\
--bind-address=${MASTER_ADDRESS} \\
--secure-port=6443 \\
--advertise-address=${MASTER_ADDRESS} \\
--allow-privileged=true \\
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
--authorization-mode=RBAC,Node \\
--kubelet-https=true \\
--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"

EOF

cat <<EOF >/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
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

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

（10）执行脚本，生成api-server的配置文件：./apiserver.sh 10.3.214.20 https://10.3.214.20:2379,https://10.3.214.21:2379,https://10.3.214.22:2379

（11）查看是否api-server服务是否启动：ps aux | grep api

启动成功

（12）执行脚本，生成controller-manager服务的配置文件以及服务文件：vim controller-manager.sh

#!/bin/bash

MASTER_ADDRESS=$1

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


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

EOF

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

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

[Install]
WantedBy=multi-user.target
EOF

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

（13）执行脚本：./controller-manager.sh 127.0.0.1 （14）验证controller-manager是否启动：ps aux | grep controller-manager

启动成功

（15）执行下边脚本，生成scheduler组件的配置文件以及服务配置文件：vim scheduler.sh

#!/bin/bash

MASTER_ADDRESS=$1

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

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

EOF

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

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

[Install]
WantedBy=multi-user.target
EOF

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

（16）执行脚本：./scheduler.sh 127.0.0.1 （17）验证scheduler是否启动成功：

启动成功

（18）拷贝kubectl集群管理入口工具，检查集群装填：cp kubernetes/server/bin/kubectl /usr/bin/ 检查集群健康状态：kubectl get cs

集群以及组件状态健康

到此master的组件部署完毕

8.部署Node组件

（1）将kubelet-bootstrap用户绑定到系统集群的node角色，kubelet-bootstrap是我们刚才创建token时创建的一个角色（注意，这一步在master上执行）：

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

（2）创建kubeconfig文件（这个文件存放了连接api-server的认证信息）的脚本文件：vim kubeconfig.sh

APISERVER=$1
SSL_DIR=$2
BOOTSTRAP_TOKEN=0fb61c46f8991b718eb38d27b605b008

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

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

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

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

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

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

# 创建kube-proxy kubeconfig文件

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

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

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

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

（3）执行脚本，生成配置文件（脚本要指定之前生成ca证书的目录）：./kubeconfig.sh 10.3.214.20 /root/k8s/cert/

（4）拷贝生成的配置文件到node节点：

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@10.3.214.21:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@10.3.214.22:/opt/kubernetes/cfg/

（5）将之前解压的组件的二进制文件拷贝到node节点：

scp kubelet kube-proxy root@10.3.214.21:/opt/kubernetes/bin/
scp kubelet kube-proxy root@10.3.214.22:/opt/kubernetes/bin/

以下操作需要在node节点上执行
（6）生成kubelet的配置文件的脚本：vim kubelet.sh

#!/bin/bash

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

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

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

EOF

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

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

EOF

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

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

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

（6）执行脚本，生成配置文件和服务，并且启动服务：./kubelet.sh 10.3.214.21 （7）查看服务是否启动成功：ps uax | grep kubelet

（8）master节点执行，允许node节点加入集群：

查看请求记录：kubectl get csr

允许请求：kubectl certificate approve node-csr-2JQh7cFo_VNATYLjiryRtDyzTVhhbI1IVIrBk067X84

等待一会查看节点是否加入：kubectl get node

（9）生成kube-proxy的配置文件的脚本：vim kube-proxy.sh

#!/bin/bash

NODE_ADDRESS=$1

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

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

EOF

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

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

[Install]
WantedBy=multi-user.target
EOF

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

（10）执行脚本，生成kube-proxy的配置文件以及服务，并且启动服务：./kube-proxy.sh 10.3.214.21 （11）查看kube-proxy是否启动成功：ps aux |grep proxy

现在node节点的组件部署完成（12）部署第二个node节点和第一个node节点完全一致，按照以上操作在操作一遍

到这，一个高可用的集群部署完成：kubectl get node

       以上就是我们二进制部署高可用的k8s集群的详细操作，创作不易，喜欢的点个赞、收藏一下。后续的博客会继续从k8s集群的各种常用操作进行讲解。