kubernetes集群部署

浅浅的花香味﹌ 2023-08-17 17:13 93阅读 0赞

# 一、环境准备 #

**1、Kubernetes****部署方式**

*  **minikube**

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

官方地址：[https://kubernetes.io/docs/setup/minikube/][https_kubernetes.io_docs_setup_minikube]

*  **kubeadm**

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

官方地址：[https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/][https_kubernetes.io_docs_reference_setup-tools_kubeadm_kubeadm]

*  **二进制包**

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

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

**2、软件环境**

<table> 
 <thead> 
  <tr> 
   <td> <p><strong>软件</strong></p> </td> 
   <td> <p><strong>版本</strong></p> </td> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p>操作系统</p> </td> 
   <td> <p>CentOS7.5_x64</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Docker</p> </td> 
   <td> <p>18-ce</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Kubernetes</p> </td> 
   <td> <p>1.12</p> </td> 
  </tr> 
 </tbody> 
</table>

**3、服务器角色**

<table> 
 <thead> 
  <tr> 
   <td> <p><strong>角色</strong></p> </td> 
   <td> <p><strong>IP</strong></p> </td> 
   <td> <p><strong>组件</strong></p> </td> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p>k8s-master</p> </td> 
   <td> <p>10.11.97.191</p> </td> 
   <td> <p>kube-apiserver，kube-controller-manager，kube-scheduler，etcd</p> </td> 
  </tr> 
  <tr> 
   <td> <p>k8s-node1</p> </td> 
   <td> <p>10.11.97.71</p> </td> 
   <td> <p>kubelet，kube-proxy，docker，flannel，etcd</p> </td> 
  </tr> 
  <tr> 
   <td> <p>k8s-node2</p> </td> 
   <td> <p>10.11.97.181</p> </td> 
   <td> <p>kubelet，kube-proxy，docker，flannel，etcd</p> </td> 
  </tr> 
 </tbody> 
</table>

**4、自签SSL证书**

![462684-20190815095449010-1967638250.png][]

CA(Certification Authority)证书，指的是权威机构给我们颁发的证书。

密钥就是用来加解密用的文件或者字符串。密钥在非对称加密的领域里，指的是私钥和公钥，他们总是成对出现，其主要作用是加密和解密。常用的加密强度是2048bit。

RSA即非对称加密算法。非对称加密有两个不一样的密码，一个叫私钥，另一个叫公钥，用其中一个加密的数据只能用另一个密码解开，用自己的都解不了，也就是说用公钥加密的数据只能由私钥解开。

#### 证书签名请求(CSR) ####

CSR(Certificate Signing Request)，它是向CA机构申请数字×××书时使用的请求文件。在生成请求文件前，我们需要准备一对对称密钥。私钥信息自己保存，请求中会附上公钥信息以及国家，城市，域名，Email等信息，CSR中还会附上签名信息。

当我们准备好CSR文件后就可以提交给CA机构，等待他们给我们签名，签好名后我们会收到crt文件，即证书。

注意：CSR并不是证书。而是向权威证书颁发机构获得签名证书的申请。

把CSR交给权威证书颁发机构,权威证书颁发机构对此进行签名,完成。保留好`CSR`,当权威证书颁发机构颁发的证书过期的时候,你还可以用同样的`CSR`来申请新的证书,key保持不变.

#### 数字签名 ####

数字签名就是"非对称加密+摘要算法"，其目的不是为了加密，而是用来防止他人篡改数据。

其核心思想是：比如A要给B发送数据，A先用摘要算法得到数据的指纹，然后用A的私钥加密指纹，加密后的指纹就是A的签名，B收到数据和A的签名后，也用同样的摘要算法计算指纹，然后用A公开的公钥解密签名，比较两个指纹，如果相同，说明数据没有被篡改，确实是A发过来的数据。

假设C想改A发给B的数据来欺骗B，因为篡改数据后指纹会变，要想跟A的签名里面的指纹一致，就得改签名，但由于没有A的私钥，所以改不了，如果C用自己的私钥生成一个新的签名，B收到数据后用A的公钥根本就解不开。

常用的摘要算法有MD5、SHA1、SHA256。

使用私钥对需要传输的文本的摘要进行加密，得到的密文即被称为该次传输过程的签名。

#### 数字证书和公钥 ####

数字证书则是由证书认证机构（CA）对证书申请者真实身份验证之后，用CA的根证书对申请人的一些基本信息以及申请人的公钥进行签名（相当于加盖发证书机 构的公章）后形成的一个数字文件。实际上，数字证书就是经过CA认证过的公钥，除了公钥，还有其他的信息，比如Email，国家，城市，域名等。

k8s证书生成过程

### 1、创建认证中心(CA) ###

CFSSL可以创建一个获取和操作证书的内部认证中心。

运行认证中心需要一个CA证书和相应的CA私钥。任何知道私钥的人都可以充当CA颁发证书。因此，私钥的保护至关重要。

#### 生成CA证书和私钥(root 证书和私钥) ####

创建一个文件`ca-csr.json`：

{
        "CN": "kubernetes",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "Beijing",
                "ST": "Beijing",
                "O": "k8s",
                "OU": "System"
            }
        ]
    }

*  CN: Common Name，浏览器使用该字段验证网站是否合法，一般写的是域名。非常重要。浏览器使用该字段验证网站是否合法
 *  C: Country， 国家
 *  L: Locality，地区，城市
 *  O: Organization Name，组织名称，公司名称
 *  OU: Organization Unit Name，组织单位名称，公司部门
 *  ST: State，州，省

生成CA证书和CA私钥和CSR(证书签名请求):

# cfssl gencert -initca ca-csr.json | cfssljson -bare ca  ## 初始化ca
    # ls ca*
    ca.csr  ca-csr.json  ca-key.pem  ca.pem
    该命令会生成运行CA所必需的文件ca-key.pem（私钥）和ca.pem（证书），还会生成ca.csr（证书签名请求），用于交叉签名或重新签名。
    
    使用现有的CA私钥，重新生成：

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

使用现有的CA私钥和CA证书，重新生成：

cfssl gencert -renewca -ca cert.pem -ca-key key.pem

查看cert(证书信息):

# cfssl certinfo -cert ca.pem

查看CSR(证书签名请求)信息：

# cfssl certinfo -csr ca.csr

#### 2、配置证书生成策略 ####

cat ca-config.json

{
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "kubernetes": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }

这个策略，有一个默认的配置，和一个`profile`，可以设置多个`profile`，这里的`profile`是kubernetes。

*  默认策略，指定了证书的有效期是一年(8760h)
 *  etcd策略，指定了证书的用途
 *  signing, 表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE
 *  server auth：表示 client 可以用该 CA 对 server 提供的证书进行验证
 *  client auth：表示 server 可以用该 CA 对 client 提供的证书进行验证

cfssl常用命令：

*  `cfssl gencert -initca ca-csr.json | cfssljson -bare ca ## 初始化ca`
 *  `cfssl gencert -initca -ca-key key.pem ca-csr.json | cfssljson -bare ca ## 使用现有私钥, 重新生成`
 *  `cfssl certinfo -cert ca.pem`
 *  `cfssl certinfo -csr ca.csr`

**5、架构图**

![462684-20190815094905688-1652708185.png][]

**6、安装环境目录**

ll /opt/kubernetes/

[root@k8s-master01 cfg]# ll /opt/kubernetes/
    total 12
    drwxr-xr-x 2 root root 4096 Jul 26 07:31 bin
    drwxr-xr-x 2 root root 4096 Jul 26 08:00 cfg
    drwxr-xr-x 2 root root 4096 Jul 26 07:55 ssl

*  bin：二进制目录
 *  cfg：配置文件目录
 *  ssl：证书目录

# 二、单Master集群部署 #

## **1.** **部署****Etcd****集群** ##

使用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/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

**1.1** **生成证书**

创建以下三个文件：

*cat ca-config.json*

{
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "www": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }

*cat ca-csr.json*

{
        "CN": "etcd CA",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "Beijing",
                "ST": "Beijing"
            }
        ]
    }

*cat server-csr.json*

{
        "CN": "etcd",
        "hosts": [
        "10.11.97.191",
        "10.11.97.192",
        "10.11.97.71"
        ],
        "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*

![462684-20190815100936983-1330632551.png][]

**1.2** **部署****Etcd**

二进制包下载地址：[https://github.com/coreos/etcd/releases/tag/v3.2.12][https_github.com_coreos_etcd_releases_tag_v3.2.12]

**以下部署步骤在规划的三个****etcd****节点操作一样，唯一不同的是****etcd****配置文件中的服务器****IP****要写当前的！**

解压二进制包：

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

**\#** tar zxvf etcd-v3.2.12-linux-amd64.tar.gz

**\#** mv etcd-v3.2.12-linux-amd64/\{etcd,etcdctl\} /opt/etcd/bin/

创建etcd配置文件：

*\# cat /opt/etcd/cfg/etcd*

#[Member]
    ETCD_NAME="etcd01"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    ETCD_LISTEN_PEER_URLS="https://10.11.97.191:2380"
    ETCD_LISTEN_CLIENT_URLS="https://10.11.97.191:2379"
    
    #[Clustering]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.11.97.191:2380"
    ETCD_ADVERTISE_CLIENT_URLS="https://10.11.97.191:2379"
    ETCD_INITIAL_CLUSTER="etcd01=https://10.11.97.191:2380,etcd02=https://10.11.97.192:2380,etcd03=https://10.11.97.71:2380"
    ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
    ETCD_INITIAL_CLUSTER_STATE="new"

*  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表示加入已有集群

systemd管理etcd

*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
    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 ca\*pem server\*pem /opt/etcd/ssl

启动并设置开启启动：

**\#** systemctl start etcd

**\#** systemctl enable etcd

都部署完成后，检查etcd集群状态：

/opt/etcd/bin/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://10.11.97.191:2379,https://10.11.97.192:2379,https://10.11.97.71:2379" \
    cluster-health

![462684-20190815101320086-311828113.png][]

如果输出上面信息，就说明集群部署成功。如果有问题第一步先看日志：/var/log/message 或 journalctl -u etcd

## **2.** **在****Node****安装****Docker** ##

# yum install -y yum-utils device-mapper-persistent-data lvm2
    # yum-config-manager \
        --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
    # yum install docker-ce -y
    # curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://bc437cce.m.daocloud.io
    # systemctl start docker
    # systemctl enable docker

## **3.** **部署****Flannel****网络** ##

原理说明

Flannel为每个host分配一个subnet，容器从这个subnet中分配IP，这些IP可以在host间路由，容器间无需使用nat和端口映射即可实现跨主机通信

每个subnet都是从一个更大的IP池中划分的，flannel会在每个主机上运行一个叫flanneld的agent，其职责就是从池子中分配subnet

Flannel使用etcd存放网络配置、已分配 的subnet、host的IP等信息

Flannel数据包在主机间转发是由backend实现的，目前已经支持UDP、VxLAN、host-gw、AWS VPC和GCE路由等多种backend

**![462684-20190815102955170-617300391.png][]**

数据流过程：

1.  容器直接使用目标容器的ip访问，默认通过容器内部的eth0发送出去。
2.  报文通过veth pair被发送到vethXXX。
3.  vethXXX是直接连接到虚拟交换机docker0的，报文通过虚拟bridge docker0发送出去。
4.  查找路由表，外部容器ip的报文都会转发到flannel0虚拟网卡，这是一个P2P的虚拟网卡，然后报文就被转发到监听在另一端的flanneld。
5.  flanneld通过etcd维护了各个节点之间的路由表，把原来的报文UDP封装一层，通过配置的iface发送出去。
6.  报文通过主机之间的网络找到目标主机。
7.  报文继续往上，到传输层，交给监听在8285端口的flanneld程序处理。
8.  数据被解包，然后发送给flannel0虚拟网卡。
9.  查找路由表，发现对应容器的报文要交给docker0。
10. docker0找到连到自己的容器，把报文发送过去。

Falnnel要用etcd存储自身一个子网信息，所以要保证能成功连接Etcd，写入预定义子网段：

**以下部署步骤在规划的每个****node****节点都操作。**

下载二进制包：

# wget https://github.com/coreos/flannel/releases/download/v0.10.0/flannel-v0.10.0-linux-amd64.tar.gz
    # tar zxvf flannel-v0.9.1-linux-amd64.tar.gz
    # mv flanneld mk-docker-opts.sh /opt/kubernetes/bin

配置Flannel：

*cat /opt/kubernetes/cfg/flanneld*

FLANNEL_OPTIONS="--etcd-endpoints=

https://10.11.97.191:2379,https://10.11.97.192:2379,https://10.11.97.71:2379 -etcd-cafile=/opt/etcd/ssl/ca.pem -etcd-certfile=/opt/etcd/ssl/server.pem -etcd-keyfile=/opt/etcd/ssl/server-key.pem"

systemd管理Flannel：

*cat /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

配置Docker启动指定子网段：

*cat /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

重启flannel和docker：

**\#** systemctl daemon-reload

**\#** systemctl start flanneld

**\#** systemctl enable flanneld

**\#** systemctl restart docker

检查是否生效：

![462684-20190815105309427-1349603346.png][]

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

![462684-20190815105513470-1866534339.png][]

![462684-20190815105530787-1246124267.png][]

测试不同node之间互ping是通的。

node02节点：

![462684-20190815105657875-98434405.png][]

在node02节点上ping node01节点：

![462684-20190815105734945-924379343.png][]

在node01节点上ping node02节点：

![462684-20190815105828056-1157509636.png][]

## **4.** **在****Master****节点部署组件** ##

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

**4.1** **生成证书**

创建CA证书：

*\# cat ca-config.json*

*\# cat ca-csr.json*

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

生成apiserver证书：

*\# cat server-csr.json*

{
        "CN": "kubernetes",
        "hosts": [
          "10.0.0.1",
          "127.0.0.1",
          "10.11.97.191",
          "10.11.97.192",
          "10.11.97.193",
          "10.11.97.71",
          "10.11.97.181",
          "10.11.97.187",
          "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"
            }
        ]
    }

注意：这里要规划好将来需要加入的Master ServerIP。

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

生成kube-proxy证书：

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

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

最终生成以下证书文件：

![462684-20190815110729652-1664833309.png][]

**4.2** **部署****apiserver****组件**

下载二进制包：[https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.12.md][https_github.com_kubernetes_kubernetes_blob_master_CHANGELOG-1.12.md]  
 下载这个包（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

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

*\# cat /opt/kubernetes/cfg/token.csv*

674c457d4dcf2eefe4920d7dbb6b0ddc,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

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

创建apiserver配置文件：

\# cat /opt/kubernetes/cfg/kube-apiserver

KUBE_APISERVER_OPTS="--logtostderr=true \
    --v=4 \
    --etcd-servers=https://10.11.97.191:2379,https://10.11.97.192:2379,https://10.11.97.71:2379 \
    --bind-address=10.11.97.191 \
    --secure-port=6443 \
    --advertise-address=10.11.97.191 \
    --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"

配置好前面生成的证书，确保能连接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：

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

**4.3** **部署****scheduler****组件**

创建schduler配置文件：

*\# cat /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组件：

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

**4.4** **部署****controller-manager****组件**

创建controller-manager配置文件：

\# cat /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 \
    --experimental-cluster-signing-duration=87600h0m0s"

systemd管理controller-manager组件：

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

*![462684-20190815111236317-1488281326.png][]*

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

## **5.** **在****Node****节点部署组件** ##

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

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

![462684-20190815111416900-296204284.png][]

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

kubectl **create** clusterrolebinding kubelet-bootstrap \\

*--clusterrole=system:node-bootstrapper \\*

*--user=kubelet-bootstrap*

**5.2** **创建****kubeconfig****文件**

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

**\#** **创建****kubelet bootstrapping kubeconfig**

BOOTSTRAP\_TOKEN=674c457d4dcf2eefe4920d7dbb6b0ddc

KUBE\_APISERVER="https://192.168.31.63: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

\# **ls**

**bootstrap**.kubeconfig **kube-proxy**.kubeconfig

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

**5.2** **部署****kubelet****组件**

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

**创建****kubelet****配置文件：**

\# cat /opt/kubernetes/cfg/kubelet

KUBELET_OPTS="--logtostderr=true \
    --v=4 \
    --address=10.11.97.71 \
    --hostname-override=10.11.97.71 \
    --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"

参数说明：

*  \--hostname-override 在集群中显示的主机名
 *  \--kubeconfig 指定kubeconfig文件位置，会自动生成
 *  \--bootstrap-kubeconfig 指定刚才生成的bootstrap.kubeconfig文件
 *  \--cert-dir 颁发证书存放位置
 *  \--pod-infra-container-image 管理Pod网络的镜像

**其中****/opt/kubernetes/cfg/kubelet.config****配置文件如下：**

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

**systemd管理kubelet组件**

*\# cat /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

启动：

**\#** systemctl daemon-reload

**\#** systemctl enable kubelet

**\#** systemctl restart kubelet

**在****Master****审批****Node****加入集群：**

启动后还没加入到集群中，需要手动允许该节点才可以。  
 在Master节点查看请求签名的Node：

**\#** kubectl get csr

**\#** kubectl certificate approve XXXXID

**\#** kubectl get node

**5.3** **部署****kube-proxy****组件**

创建kube-proxy配置文件：

\# cat /opt/kubernetes/cfg/kube-proxy

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

systemd管理kube-proxy组件：

*\# cat /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

启动：

**\#** systemctl daemon-reload

**\#** systemctl enable kube-proxy

**\#** systemctl restart kube-proxy

Node2部署方式一样。

## **6.** **查看集群状态** ##

**查看node**

*\# kubectl get node*

[root@k8s-master01 cfg]# kubectl get node
    NAME           STATUS   ROLES    AGE   VERSION
    10.11.97.181   Ready    <none>   20d   v1.12.1
    10.11.97.71    Ready    <none>   20d   v1.12.1

kubectl get cs

[root@k8s-master01 cfg]# 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"}

## **7.** **运行一个测试示例** ##

创建一个Nginx Web，测试集群是否正常工作：

**\#** kubectl run nginx --image=nginx --replicas=3

![462684-20190815112149514-900732631.png][]

**\#** kubectl expose deployment nginx --port=88 --target-port=80 --type=NodePort

![462684-20190815112201443-1113125460.png][]

查看service和pods

![462684-20190815112346411-582504354.png][]

通过46613端口访问Nginx：

![462684-20190815112306944-1275957696.png][]

转载于:https://www.cnblogs.com/skyflask/articles/11356130.html

[https_kubernetes.io_docs_setup_minikube]: https://kubernetes.io/docs/setup/minikube/
[https_kubernetes.io_docs_reference_setup-tools_kubeadm_kubeadm]: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/
[462684-20190815095449010-1967638250.png]: /images/20230808/6deaeacf83104151b12177b92a263de0.png
[462684-20190815094905688-1652708185.png]: /images/20230808/049ac739a2e948ba9f405fdd262e5059.png
[462684-20190815100936983-1330632551.png]: /images/20230808/3f1ca84b465e4be0afd7e3d402ed9fb8.png
[https_github.com_coreos_etcd_releases_tag_v3.2.12]: https://github.com/coreos/etcd/releases/tag/v3.2.12
[462684-20190815101320086-311828113.png]: /images/20230808/4abe0159e8be4684b55f1c18f8a8ead1.png
[462684-20190815102955170-617300391.png]: /images/20230808/b87d9798872e4d69bd3473a7618c0773.png
[462684-20190815105309427-1349603346.png]: /images/20230808/57f1e8a52a724763a464ce356048403e.png
[462684-20190815105513470-1866534339.png]: /images/20230808/0780663334524a9493c7a8d584e8e510.png
[462684-20190815105530787-1246124267.png]: /images/20230808/8a29ec9ca8e54410a4d3a637ed3c9add.png
[462684-20190815105657875-98434405.png]: /images/20230808/76db4fa746654355b356c72e0f49c2e4.png
[462684-20190815105734945-924379343.png]: /images/20230808/b80e4c087e794a1fa48fcd0586084d59.png
[462684-20190815105828056-1157509636.png]: /images/20230808/3aed2f09dc44493b852763f896ace6dd.png
[462684-20190815110729652-1664833309.png]: /images/20230808/ecd85e74d15d4014ad25b9ccd3db297e.png
[https_github.com_kubernetes_kubernetes_blob_master_CHANGELOG-1.12.md]: https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.12.md
[462684-20190815111236317-1488281326.png]: /images/20230808/53caf67425a94183b1a773ae639b339d.png
[462684-20190815111416900-296204284.png]: /images/20230808/2e074dff1a754177a78a9b02c37be8b8.png
[462684-20190815112149514-900732631.png]: /images/20230808/80a6370dca7a4791a288c8efcfc3d5a9.png
[462684-20190815112201443-1113125460.png]: /images/20230808/a1f7ee487569469cbc32aa5f553fa143.png
[462684-20190815112346411-582504354.png]: /images/20230808/406fc8e8375a4fbcaa9829c2cf1cccef.png
[462684-20190815112306944-1275957696.png]: /images/20230808/40b4789500c54082b6141359cb8ce27d.png