Kubernetes环境搭建(手动K8s集群安装配置、服务部署和管理使用详细步骤，入门K8s容器云平台架构）

关键词： docker、kubenetes、etcd、kubectl、kubenetes api service、kubenetes manager controller、kubenetes scheduler、kubelet、kube-proxy、flannel、coreDNS、dashboard、influxdb+grafana+heapster.

前言

说明： 本博客是教大家如何手动搭建kubernetes集群（业内简称K8s），包括集群中所有相关服务、存储、网络等等，本博客一到九章属于第一个阶段，就已经把基本架构搭建好了，后面几章属于锦上添花并在最后部署几个开源的集群可视化管理界面。尤其对于刚入门docker/k8s的新手，可以通过一步步搭建的详细过程了解集群的架构。本博客非常长，涵盖了K8s搭建的整个过程，所有内容，花了我很长时间，大家搭建的时候不必心急非要一次性完成，可以每天完成一到两步，我初学时搭建环境也是走了很多坑，很慢花了一周才完成，加油！

我们知道，在容器技术、微服务日益发展的今天，基于docker容器技术的kubernetes集群已经在行业内已经越来越流行，成为方便易操作的轻量级云平台，使得人们更容易、更灵活地部署自己的应用、管理自己的应用。其主从架构的分布式特点也与很多其他技术框架相似，使得开发人员更容易理解上手。

Kubernetes简介： 简称K8s，是Google开源的一个容器编排引擎，再简单地说，就是用于管理云平台中多个主机上的容器化的应用。K8s的目标是让部署容器化的应用简单并且高效，K8s提供了应用部署，规划，更新，维护的一种机制，它支持自动化部署、大规模可伸缩、应用容器化管理。 特点：

可移植: 支持公有云，私有云，混合云，多重云
可扩展: 模块化，插件化，可挂载，可组合
自动化: 自动部署，自动重启，自动复制，自动伸缩/扩展

我们知道，传统的应用部署方式是通过插件或脚本来安装应用。这样做的缺点是应用的运行、配置、管理、所有生存周期将与当前操作系统绑定，这样做并不利于应用的升级更新/回滚等操作，当然也可以通过创建虚拟机的方式来实现某些功能，但是虚拟机非常重，并不利于可移植性。

使用K8s新的方式是通过部署容器方式实现，优点是每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。相对于虚拟机，容器能快速部署，由于容器与底层设施、机器文件系统解耦的，所以它能在不同云、不同版本操作系统间进行迁移。

容器占用资源少、部署快，每个应用可以被打包成一个容器镜像，每个应用与容器间成一对一关系也使容器有更大优势，使用容器可以在build或release 的阶段，为应用创建容器镜像，因为每个应用不需要与其余的应用堆栈组合，也不依赖于生产环境基础结构，这使得从研发到测试、生产能提供一致环境。类似地，容器比虚拟机轻量、更“透明”，这更便于监控和管理。

一般情况下：我们在K8s生产环境中部署一个应用程序时，通常要部署该应用的多个实例以便对应用请求进行负载均衡。我们可以创建多个容器，每个容器里面运行一个应用实例，然后通过内置的负载均衡策略，实现对这一组应用实例的管理、发现、访问，而这些细节都不需要运维人员去进行复杂的手工配置和处理，由集群自动化管理方便运维人员使用。

关于K8s的介绍暂时就到这里，至于K8s的各个内部组件在本章节就不一一详细说明了，在下面的各个搭建步骤中，也会为大家简单介绍每个所搭建的组件，相信大家在每步搭建的过程中会逐步了解的。下面就让我们来开始具体搭建步骤！

搭建详细步骤

一、各节点基础配置

K8s集群的节点信息如下：

操作系统：Ubuntu16.04.3 Server

ip address	hostname	description
192.168.185.131	linux-node1	master，主节点
192.168.185.132	linux-node2	slave1，子节点
192.168.185.133	linux-node3	slave2，子节点
192.168.185.134	linux-node4	slave3，子节点
192.168.185.135	linux-node5	slave4，子节点

注意说明： 我们这里搭建的K8s集群，是在VMWare虚拟机中搭建的五个节点，均采用Ubuntu16.04.3 Server版本的系统，每个节点系统分配2G内存，20G的储存。整个集群主从架构包括1个主节点，4个子节点，相关信息如上表。

当然，并不是说一定就要搭建5个节点，节点信息也不一定非要按我上面这样设置，也不一定要像我这样分配每个节点的资源。毕竟考虑到每个人的电脑配置不同，可能受限制于自身电脑内存等影响。大家可以自己灵活选择，这丝毫不影响我们下面的搭建步骤。不过我的个人建议是：你至少至少要配置3个节点的集群（包括1个master主节点，2个slave子节点），每个节点最少最少要分配不低于1G内存，不低于15G的储存。当然具体怎么分配集群取决于你自己，你有多少数量的节点下面搭建配置过程就配置多少个，资源少点可能就跑的慢点，没有太大关系。好的，下面就让我们正式开始一步步搭建K8s集群！

1、节点基本信息配置

# 在每个节点配置自己的ip（注意每个节点address那里，只填自己对应的ip）
[root@linux-node1 ~]# vim /etc/network/interfaces
auto ens33
iface ens33 inet static
address 192.168.185.131
netmask 255.255.255.0
gateway 192.168.185.2
dns-nameserver 8.8.8.8


# 配置每台机器hostname名字（注意每个节点都只填自己对应的hostname）
[root@linux-node1 ~]# vim /etc/hostname
linux-node1


# 在每台机器上配置hosts解析文件（注意：这里，每个节点的hosts文件都是一样的，要配置集群所有节点的信息）
[root@linux-node1 ~]# vim /etc/hosts
192.168.185.131       linux-node1       
192.168.185.132       linux-node2       
192.168.185.133       linux-node3      
192.168.185.134       linux-node4       
192.168.185.135       linux-node5  


# 每个节点都重启
[root@linux-node1 ~]# reboot


# 测试一下看看
[root@linux-node1 ~]# ifconfig
[root@linux-node1 ~]# ping www.baidu.com 
# 节点之间都相互ping一下看看
[root@linux-node1 ~]# ping 192.168.185.132


# 各节点关闭防火墙
[root@linux-node1 ~]# ufw disable 


# 设置ssh免密登录
[root@linux-node1 ~]# ssh-keygen -t rsa
# 上面这条命令，遇到什么都别管，一路回车键敲下去

# 拷贝本密钥到五个节点上
[root@linux-node1 ~]# ssh-copy-id linux-node1
[root@linux-node1 ~]# ssh-copy-id linux-node2
[root@linux-node1 ~]# ssh-copy-id linux-node3
[root@linux-node1 ~]# ssh-copy-id linux-node4
[root@linux-node1 ~]# ssh-copy-id linux-node5

# 注意！！！将上面“设置ssh免密登录”和“拷贝本密钥到五个节点上”这两个步骤在其他所有节点上都要分别做一遍

# 每个节点都做完后，都要像下面这样测试一下，是否能在一个节点上免密登录到其他任何一个节点
[root@linux-node1 ~]# ssh linux-node1
# 免密登录到其他节点上后，若要退出回到本身节点，直接敲logout命令就行了
[root@linux-node1 ~]# ssh linux-node2
[root@linux-node1 ~]# ssh linux-node3
[root@linux-node1 ~]# ssh linux-node4
[root@linux-node1 ~]# ssh linux-node5

2、准备K8s的相关安装配置文件

为了方便各位读者的操作，我已将所有K8s相关安装配置文件打包上传到百度云了（链接:https://pan.baidu.com/s/17YxQnXd7SJhO9ucdE_IMMA 密码:urhu），提供给大家，读者可以自行下载，而不用再花费时间到处寻找了。然后将从百度云下载好的k8s-v1.10.1-manual.zip，上传到主节点的/usr/local/src下（如果不知道怎么上传，自己主机是windows可以用软件winSCP，如果自己主机是linux可以用scp命令）。上传后解压下：

[root@linux-node1:/usr/local/src]# ll
total 579824
-rw-r--r--  1 root root 593725046 Nov  9 19:16 k8s-v1.10.1-manual.zip

[root@linux-node1:/usr/local/src]# unzip k8s-v1.10.1-manual.zip

[root@linux-node1:/usr/local/src]# ls
k8s-v1.10.1-manual  k8s-v1.10.1-manual.zip

[root@linux-node1:/usr/local/src]# cd k8s-v1.10.1-manual/k8s-v1.10.1/

[root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1]# tar zxvf kubernetes-server-linux-amd64.tar.gz

[root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1]# tar zxvf kubernetes-client-linux-amd64.tar.gz

[root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1]# tar zxvf kubernetes-node-linux-amd64.tar.gz 

这样一来，我们所需要准备的相关文件，都已解压好统一放在主节点的/usr/local/src/k8s-v1.10.1-manual下了，往后我们需要用到其中某些东西时，直接过来该目录下拷就行了。

3、部署K8s安装目录

# 在每个节点都建立K8s的安装目录
[root@linux-node1 ~]#  mkdir -p /opt/kubernetes/{cfg,bin,ssl,log}

# 说明一下，其中子目录cfg/下为相关配置文件，bin/目录下为可执行文件，/ssl文件下为网络安全通信相关文件，log/下为日志文件
# 该/opt/kubernetes/才是我们真正的安装目录，每个节点都要配置
# 我们以后的工作，说白了就是从我们上一步准备好的相关安装配置文件中，
# 找到需要的文件，配置好后，分发到各个节点安装目录/opt/kubernetes/下对应的位置

# 在每个节点都配置kubernetes的环境变量
[root@linux-node1 ~]# vim /etc/profile
export PATH=$PATH:/opt/kubernetes/bin
[root@linux-node1 ~]# source /etc/profile

4、在各个节点上安装docker

[root@linux-node1 ~]# apt-get update
[root@linux-node1 ~]# curl -s https://get.docker.com | sh
[root@linux-node1 ~]# docker version

这步非常重要，因为我们知道，K8s技术本身就是基于docker容器技术的。安装docker时可能会很慢，这取决于你的网速问题，当然安装方法也不只我这一种，你也可以参考官方给出的其他方式安装，但务必要确保每个节点上都安装成功了docker，否则不能继续后面的操作。

二、制作CA证书

kubernetes系统各组件需要使用TLS(SSL)证书对通信进行加密，我们这里使用cfssl 来生成Certificate Authority (CA) 证书和秘钥文件，CA是自签名的证书，用来签名后续创建的其它证书。

1、在主节点上配置已下载好的cfssl

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# chmod +x cfssl*

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# mv cfssl-certinfo_linux-amd64 /opt/kubernetes/bin/cfssl-certinfo

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# mv cfssljson_linux-amd64  /opt/kubernetes/bin/cfssljson

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# mv cfssl_linux-amd64  /opt/kubernetes/bin/cfssl

# 然后使用scp命令分别拷到其余4个节点：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp -r /opt/kubernetes/bin/cfssl* 192.168.185.132:/opt/kubernetes/bin
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp -r /opt/kubernetes/bin/cfssl* 192.168.185.133:/opt/kubernetes/bin
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp -r /opt/kubernetes/bin/cfssl* 192.168.185.134:/opt/kubernetes/bin
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp -r /opt/kubernetes/bin/cfssl* 192.168.185.135:/opt/kubernetes/bin

# 在每个节点上/usr/local/src下建立ssl目录用来以后放相关的证书文件
root@linux-node1:/usr/local/src# mkdir ssl && cd ssl

2、创建用来生成 CA 文件的 JSON 配置文件：

root@linux-node1:/usr/local/src/ssl# vim ca-config.json
{
  "signing": {
    "default": {
      "expiry": "8760h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "8760h"
      }
    }
  }
}

3、创建用来生成 CA 证书签名请求（CSR）的 JSON 配置文件：

root@linux-node1:/usr/local/src/ssl# vim ca-csr.json
{
  "CN": "kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

4、生成CA证书（ca.pem）和密钥（ca-key.pem）：

root@linux-node1:/usr/local/src/ssl# cfssl gencert -initca ca-csr.json | cfssljson -bare ca

# 拷贝到我们之前创建的用来放证书的目录下
root@linux-node1:/usr/local/src/ssl# cp ca.csr ca.pem ca-key.pem ca-config.json /opt/kubernetes/ssl

5、分发证书，使用scp分别拷到其余4个节点放证书的位置：

root@linux-node1:/usr/local/src/ssl# scp -r ca.csr ca.pem ca-key.pem ca-config.json 192.168.185.132:/opt/kubernetes/ssl
root@linux-node1:/usr/local/src/ssl# scp -r ca.csr ca.pem ca-key.pem ca-config.json 192.168.185.133:/opt/kubernetes/ssl
root@linux-node1:/usr/local/src/ssl# scp -r ca.csr ca.pem ca-key.pem ca-config.json 192.168.185.134:/opt/kubernetes/ssl
root@linux-node1:/usr/local/src/ssl# scp -r ca.csr ca.pem ca-key.pem ca-config.json 192.168.185.135:/opt/kubernetes/ssl

ok！搞定！

三、配置etcd

etcd是Kubernetes提供默认的存储系统，保存所有集群数据，使用时需要为etcd数据提供备份计划。

1、将我们准备好的etcd软件包解压并拷贝到其他各个节点上

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# tar -zxvf etcd-v3.2.18-linux-amd64.tar.gz

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# cd etcd-v3.2.18-linux-amd64

# 拷贝到/opt/kubernetes/bin/下
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/etcd-v3.2.18-linux-amd64# cp etcd etcdctl /opt/kubernetes/bin/

# 再拷贝到其余四个节点上
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/etcd-v3.2.18-linux-amd64# scp etcd etcdctl 192.168.185.132:/opt/kubernetes/bin/

# 注意我这里只写了一条scp到132节点的命令，请自行使用scp命令拷贝到其他集群子节点，
# 往后我也是这样简略写一条，你自己复制粘贴更改一下ip就行了

2、创建 etcd 证书签名请求，生成 etcd 证书和私钥

# 创建
root@linux-node1:/usr/local/src/ssl# vim etcd-csr.json
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
"192.168.185.131",
"192.168.185.132",
"192.168.185.133",
"192.168.185.134",
"192.168.185.135"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

# 生成
root@linux-node1:/usr/local/src/ssl# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
  -ca-key=/opt/kubernetes/ssl/ca-key.pem \
  -config=/opt/kubernetes/ssl/ca-config.json \
  -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

# 拷到相应位置
root@linux-node1:/usr/local/src/ssl# cp etcd*.pem /opt/kubernetes/ssl

# 分发拷到其余4个节点：
root@linux-node1:/usr/local/src/ssl# scp etcd*.pem 192.168.185.132:/opt/kubernetes/ssl

4、配置etcd配置文件

root@linux-node1:/usr/local/src/ssl# vim /opt/kubernetes/cfg/etcd.conf
#[member]
ETCD_NAME="etcd-node1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#ETCD_SNAPSHOT_COUNTER="10000"
#ETCD_HEARTBEAT_INTERVAL="100"
#ETCD_ELECTION_TIMEOUT="1000"
ETCD_LISTEN_PEER_URLS="https://192.168.185.131:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.185.131:2379,https://127.0.0.1:2379"
#ETCD_MAX_SNAPSHOTS="5"
#ETCD_MAX_WALS="5"
#ETCD_CORS=""
#[cluster]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.185.131:2380"
# if you use different ETCD_NAME (e.g. test),
# set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."
ETCD_INITIAL_CLUSTER="etcd-node1=https://192.168.185.131:2380,etcd-node2=https://192.168.185.132:2380,etcd-node3=https://192.168.185.133:2380,etcd-node4=https://192.168.185.134:2380,etcd-node5=https://192.168.185.135:2380"
ETCD_INITIAL_CLUSTER_STATE="new"
ETCD_INITIAL_CLUSTER_TOKEN="k8s-etcd-cluster"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.185.131:2379"
#[security]
CLIENT_CERT_AUTH="true"
ETCD_CA_FILE="/opt/kubernetes/ssl/ca.pem"
ETCD_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
ETCD_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
PEER_CLIENT_CERT_AUTH="true"
ETCD_PEER_CA_FILE="/opt/kubernetes/ssl/ca.pem"
ETCD_PEER_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
ETCD_PEER_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"

5、创建etcd服务

# 注意服务是在系统文件夹/etc/systemd/system下创建哦
root@linux-node1:/etc/systemd/system#  vim /etc/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target

[Service]
Type=simple
WorkingDirectory=/var/lib/etcd
EnvironmentFile=-/opt/kubernetes/cfg/etcd.conf
# set GOMAXPROCS to number of processors
ExecStart=/bin/bash -c "GOMAXPROCS=$(nproc) /opt/kubernetes/bin/etcd"
Type=notify

[Install]
WantedBy=multi-user.target

6、将etcd配置文件和service文件分别拷到其他几个节点，并在不同节点分别修改配置文件的部分

# 分发到其余4个节点
root@linux-node1:~# scp /opt/kubernetes/cfg/etcd.conf 192.168.185.132:/opt/kubernetes/cfg/

# 分发到其余4个节点
root@linux-node1:~# scp /etc/systemd/system/etcd.service 192.168.185.132:/etc/systemd/system/

注意！！！在其余节点上，都要对配置文件做出相应修改，这里给出在node2下需要修改配置文件的地方，其他节点也一样做出对应修改不一一赘述。

在node2上，对配置文件做五处相应修改：

root@linux-node2:~# vim /opt/kubernetes/cfg/etcd.conf

红线标注的地方需要修改，其实就是改成该节点对应的ip，是不是很简单！

7、在“所有”节点上创建etcd存储目录并启动etcd

root@linux-node1:~# mkdir /var/lib/etcd
root@linux-node1:~# systemctl daemon-reload
root@linux-node1:~# systemctl enable etcd
root@linux-node1:~# systemctl start etcd

8、测试

# 在每个节点上测试etcd是否启动成功，若都active就成功
root@linux-node1:~# systemctl status etcd

# 在主节点上测试etcd集群是否都healthy
root@linux-node1:~# etcdctl --endpoints=https://192.168.185.131:2379 \
   --ca-file=/opt/kubernetes/ssl/ca.pem \
   --cert-file=/opt/kubernetes/ssl/etcd.pem \
   --key-file=/opt/kubernetes/ssl/etcd-key.pem cluster-health

ok！etcd搞定！

四、在master主节点上配置Kubernetes API服务

kube-apiserver用于暴露Kubernetes API。任何的资源请求/调用操作都是通过kube-apiserver提供的接口进行。

1、将相关文件拷到对应的K8s的目录下

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# cp kube-apiserver kube-controller-manager kube-scheduler /opt/kubernetes/bin/ 

2、创建生成CSR的 JSON 配置文件

root@linux-node1:/usr/local/src/ssl#  vim kubernetes-csr.json
{
  "CN": "kubernetes",
  "hosts": [
    "127.0.0.1",
    "192.168.185.131",
    "10.1.0.1",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

3、生成证书和私钥，并分发到所有节点

root@linux-node1:/usr/local/src/ssl#  cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
   -ca-key=/opt/kubernetes/ssl/ca-key.pem \
   -config=/opt/kubernetes/ssl/ca-config.json \
   -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes

root@linux-node1:/usr/local/src/ssl# cp kubernetes*.pem /opt/kubernetes/ssl/

# 分别拷到其他4个节点：
root@linux-node1:/usr/local/src/ssl#  scp kubernetes*.pem 192.168.185.132:/opt/kubernetes/ssl/

4、创建 kube-apiserver 使用的客户端 token 文件

root@linux-node1:/usr/local/src/ssl# head -c 16 /dev/urandom | od -An -t x | tr -d ' '

你会得到如下一串token码，你的和我的可能不一样：

创建一个bootstrap-token.csv 文件，然后填充下面内容（注意！别忘把第一个逗号前面的token码改成 -> 复制粘贴成你自己的）：

root@linux-node1:/usr/local/src/ssl#  vim /opt/kubernetes/ssl/bootstrap-token.csv 
ff9db9d8146a7bfe3e99c0f65ac2504a,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

5、创建基础用户名/密码认证配置

root@linux-node1:/usr/local/src/ssl# vim /opt/kubernetes/ssl/basic-auth.csv
admin,admin,1
readonly,readonly,2

6、部署Kubernetes API Server的service文件

root@linux-node1:~# vim /etc/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target

[Service]
ExecStart=/opt/kubernetes/bin/kube-apiserver \
  --admission-control=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota,NodeRestriction \
  --bind-address=192.168.185.131 \
  --insecure-bind-address=127.0.0.1 \
  --authorization-mode=Node,RBAC \
  --runtime-config=rbac.authorization.k8s.io/v1 \
  --kubelet-https=true \
  --anonymous-auth=false \
  --basic-auth-file=/opt/kubernetes/ssl/basic-auth.csv \
  --enable-bootstrap-token-auth \
  --token-auth-file=/opt/kubernetes/ssl/bootstrap-token.csv \
  --service-cluster-ip-range=10.1.0.0/16 \
  --service-node-port-range=20000-40000 \
  --tls-cert-file=/opt/kubernetes/ssl/kubernetes.pem \
  --tls-private-key-file=/opt/kubernetes/ssl/kubernetes-key.pem \
  --client-ca-file=/opt/kubernetes/ssl/ca.pem \
  --service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \
  --etcd-cafile=/opt/kubernetes/ssl/ca.pem \
  --etcd-certfile=/opt/kubernetes/ssl/kubernetes.pem \
  --etcd-keyfile=/opt/kubernetes/ssl/kubernetes-key.pem \
  --etcd-servers=https://192.168.185.131:2379,https://192.168.185.132:2379,https://192.168.185.133:2379,https://192.168.185.134:2379,https://192.168.185.135:2379 \
  --enable-swagger-ui=true \
  --allow-privileged=true \
  --audit-log-maxage=30 \
  --audit-log-maxbackup=3 \
  --audit-log-maxsize=100 \
  --audit-log-path=/opt/kubernetes/log/api-audit.log \
  --event-ttl=1h \
  --v=2 \
  --logtostderr=false \
  --log-dir=/opt/kubernetes/log
Restart=on-failure
RestartSec=5
Type=notify
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

注意：K8s集群的 api服务的Service文件只需要部署在master主节点上，也只需要启动在主节点上。不需要分发给其他节点，在本篇博客中，如需要分发给其他的节点的东西我都会特意注释出来说明的，没说要分发的就不用做；
另外，如果你的各个节点的ip地址并不是和我一样的，别忘了把文件中涉及节点ip的地方改成你自己的哦，以后也一样

6、在master节点上启动并测试

[root@linux-node1 ~]# systemctl daemon-reload
[root@linux-node1 ~]# systemctl enable kube-apiserver
[root@linux-node1 ~]# systemctl start kube-apiserver
[root@linux-node1 ~]# systemctl status kube-apiserver

若显示active（running），则成功。Ok，本步骤搞定！

五、在master主节点上部署Controller Manager、Kubernetes Scheduler

kube-controller-manager，运行管理控制器，它们是集群中处理常规任务的后台线程。逻辑上，每个控制器是一个单独的进程，但为了降低复杂性，它们都被编译成单个二进制文件，并在单个进程中运行。这些控制器包括：
节点（Node）控制器；
副本（Replication）控制器：负责维护系统中每个副本中的pod；
端点（Endpoints）控制器：填充Endpoints对象（即连接Services&Pods）；
Service Account和Token控制器：为新的Namespace创建默认帐户访问API Token。
kube-scheduler，监视新创建没有分配到Node的Pod，为Pod选择一个Node。

1、配置controller manager service文件

root@linux-node1:~# vim /etc/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]
ExecStart=/opt/kubernetes/bin/kube-controller-manager \
  --address=127.0.0.1 \
  --master=http://127.0.0.1:8080 \
  --allocate-node-cidrs=true \
  --service-cluster-ip-range=10.1.0.0/16 \
  --cluster-cidr=10.2.0.0/16 \
  --cluster-name=kubernetes \
  --cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \
  --cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem \
  --service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \
  --root-ca-file=/opt/kubernetes/ssl/ca.pem \
  --leader-elect=true \
  --v=2 \
  --logtostderr=false \
  --log-dir=/opt/kubernetes/log

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

2、启动并测试

[root@linux-node1 ~]# systemctl daemon-reload
[root@linux-node1 ~]# systemctl enable kube-controller-manager
[root@linux-node1 ~]# systemctl start kube-controller-manager
[root@linux-node1 ~]# systemctl status kube-controller-manager

若active（running），则成功。

3、配置kubernetes scheduler service文件

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

[Service]
ExecStart=/opt/kubernetes/bin/kube-scheduler \
  --address=127.0.0.1 \
  --master=http://127.0.0.1:8080 \
  --leader-elect=true \
  --v=2 \
  --logtostderr=false \
  --log-dir=/opt/kubernetes/log

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

4、启动并测试

[root@linux-node1 ~]# systemctl daemon-reload
[root@linux-node1 ~]# systemctl enable kube-scheduler
[root@linux-node1 ~]# systemctl start kube-scheduler
[root@linux-node1 ~]# systemctl status kube-scheduler

若active（running），则成功。
Ok，本步骤搞定！

六、在master主节点上部署kubectl命令行工具

kubectl其实就是一个命令行客户端，我们通过使用kubectl命令来操作集群。

1、拷贝相应文件到K8s相应目录

root@linux-node1:~# cd /usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/client/bin/

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/client/bin# cp kubectl /opt/kubernetes/bin/

2、创建 admin 证书签名请求

[root@linux-node1 ~]# cd /usr/local/src/ssl/
[root@linux-node1:/usr/local/src/ssl]# vim admin-csr.json
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}

3、生成 admin 证书和私钥

root@linux-node1:/usr/local/src/ssl# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
    -ca-key=/opt/kubernetes/ssl/ca-key.pem \
    -config=/opt/kubernetes/ssl/ca-config.json \
    -profile=kubernetes admin-csr.json | cfssljson -bare admin

# 拷贝到相应位置
root@linux-node1:/usr/local/src/ssl# cp admin*.pem /opt/kubernetes/ssl/

4、设置集群参数

root@linux-node1:/usr/local/src/ssl# kubectl config set-cluster kubernetes \
   --certificate-authority=/opt/kubernetes/ssl/ca.pem \
   --embed-certs=true \
   --server=https://192.168.185.131:6443

5、设置客户端认证参数

root@linux-node1:/usr/local/src/ssl# kubectl config set-credentials admin \
    --client-certificate=/opt/kubernetes/ssl/admin.pem \
    --embed-certs=true \
    --client-key=/opt/kubernetes/ssl/admin-key.pem

6、设置上下文参数

root@linux-node1:/usr/local/src/ssl# kubectl config set-context kubernetes \
    --cluster=kubernetes \
    --user=admin

7、设置默认上下文

root@linux-node1:/usr/local/src/ssl# kubectl config use-context kubernetes

8、测试使用kubectl工具

root@linux-node1:/usr/local/src/ssl#  kubectl get cs

Ok，搞定！

七、在slave子节点上部署kubelet

kubelet是节点组件，是在每个节点上运行的主要 “节点代理”。kubernetes 是一个分布式的集群管理系统，在每个节点（node）上都要运行一个 worker 对容器进行生命周期的管理，这个 worker 程序就是 kubelet。kubelet提供Kubernetes运行时的环境，以及维护Pod，它会监视已分配给节点的pod并提供等等其他功能。

1、拷贝相关文件到相应位置，并分发给子节点

root@linux-node1:~# cd /usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin/

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# cp kubelet kube-proxy /opt/kubernetes/bin/

# 分发到其他四个节点里：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# scp kubelet kube-proxy 192.168.185.132:/opt/kubernetes/bin/

2、创建角色绑定

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin#  kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

3、创建 kubelet bootstrapping kubeconfig 文件，设置集群参数

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# kubectl config set-cluster kubernetes \
    --certificate-authority=/opt/kubernetes/ssl/ca.pem \
    --embed-certs=true \
    --server=https://192.168.185.131:6443 \
--kubeconfig=bootstrap.kubeconfig

4、设置客户端认证参数（注意token是你之前在创建api service时的token）

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# kubectl config set-credentials kubelet-bootstrap \
    --token=ff9db9d8146a7bfe3e99c0f65ac2504a \
--kubeconfig=bootstrap.kubeconfig

5、设置上下文参数

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin#  kubectl config set-context default \
    --cluster=kubernetes \
    --user=kubelet-bootstrap \
--kubeconfig=bootstrap.kubeconfig

6、选择默认上下文

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

7、创建角色绑定

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin#  kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

8、把bootstrap.kubeconfig文件分发到所有节点上

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# cp bootstrap.kubeconfig /opt/kubernetes/cfg

# 分别拷到剩下四个node节点上：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/server/bin# scp bootstrap.kubeconfig 192.168.185.132:/opt/kubernetes/cfg

9、部署kubelet 设置CNI支持（注意下面三条命令，在每个节点上都要做一遍）

root@linux-node1:~# mkdir -p /etc/cni/net.d

root@linux-node1:~# vim /etc/cni/net.d/10-default.conf
{
        "name": "flannel",
        "type": "flannel",
        "delegate": {
            "bridge": "docker0",
            "isDefaultGateway": true,
            "mtu": 1400
        }
}

root@linux-node1:~# mkdir /var/lib/kubelet

10、创建kubelet服务配置

root@linux-node1:~# vim /etc/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service

[Service]
WorkingDirectory=/var/lib/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \
  --address=192.168.185.131 \
  --hostname-override=192.168.185.131 \
  --pod-infra-container-image=mirrorgooglecontainers/pause-amd64:3.0 \
  --experimental-bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
  --kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
  --cert-dir=/opt/kubernetes/ssl \
  --network-plugin=cni \
  --cni-conf-dir=/etc/cni/net.d \
  --cni-bin-dir=/opt/kubernetes/bin/cni \
  --cluster-dns=10.1.0.2 \
  --cluster-domain=cluster.local. \
  --hairpin-mode hairpin-veth \
  --allow-privileged=true \
  --fail-swap-on=false \
  --logtostderr=true \
  --v=2 \
  --logtostderr=false \
  --log-dir=/opt/kubernetes/log
Restart=on-failure
RestartSec=5

# 分发到其他所有子节点上：
root@linux-node1:~# scp /etc/systemd/system/kubelet.service 192.168.185.132:/etc/systemd/system/

# 注意！！！ 分发完后，在每个节点上把该文件的两个地方的ip改掉成该节点对应的，
# 比如node2上就改成：
# --address=192.168.185.132 \
# --hostname-override=192.168.185.132 \
# 其他节点以此类推

11、在所有slave子节点上启动kubelet（这里我们master主节点只用来管理，所以不启动kubelet)

[root@linux-node2 ~]# systemctl daemon-reload
[root@linux-node2 ~]# systemctl enable kubelet
[root@linux-node2 ~]# systemctl start kubelet
[root@linux-node2 ~]# systemctl status kubelet

12、查看csr请求 注意是在master主节点上执行

[root@linux-node1 ~]# kubectl get csr

我们注意上图，目前还是pending状态

13、在主节点上批准kubelet 的 TLS 证书请求

[root@linux-node1 ~]# kubectl get csr|grep 'Pending' | awk 'NR>0{print $1}'| xargs kubectl certificate approve

[root@linux-node1 ~]# kubectl get csr

注意，此时状态已经Approved了！

14、在主节点上查看集群子节点上kubelet状态

[root@linux-node1 ~]# kubectl get node

都已 Ready ! Ok，搞定！

八、在slave子节点上部署kube-proxy

Kube-proxy你可以就如他名字一样把它当作一个代理，运行在每个节点上，监听 API Server 中服务对象的变化，再通过管理 IPtables 来实现网络的转发。

1、配置kube-proxy使用LVS（在每个节点上都执行下面这条命令安装ipvsadm、ipset、conntrack，并等待所有节点安装完成）

root@linux-node1:/usr/local/src/ssl# apt install -y ipvsadm ipset conntrack

2、创建 kube-proxy 证书请求

root@linux-node1:~# cd /usr/local/src/ssl
root@linux-node1:/usr/local/src/ssl# vim kube-proxy-csr.json
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

3、生成证书，分发证书到所有节点

root@linux-node1:/usr/local/src/ssl#  
cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
    -ca-key=/opt/kubernetes/ssl/ca-key.pem \
    -config=/opt/kubernetes/ssl/ca-config.json \
-profile=kubernetes  kube-proxy-csr.json | cfssljson -bare kube-proxy

root@linux-node1:/usr/local/src/ssl# cp kube-proxy*.pem /opt/kubernetes/ssl/

# 分发给其余4个节点
root@linux-node1:/usr/local/src/ssl# scp kube-proxy*.pem 192.168.185.132:/opt/kubernetes/ssl/

4、创建kube-proxy配置文件，分发到所有节点

root@linux-node1:/usr/local/src/ssl# kubectl config set-cluster kubernetes \
   --certificate-authority=/opt/kubernetes/ssl/ca.pem \
   --embed-certs=true \
   --server=https://192.168.185.131:6443 \
   --kubeconfig=kube-proxy.kubeconfig

root@linux-node1:/usr/local/src/ssl# kubectl config set-credentials kube-proxy \
   --client-certificate=/opt/kubernetes/ssl/kube-proxy.pem \
   --client-key=/opt/kubernetes/ssl/kube-proxy-key.pem \
   --embed-certs=true \
   --kubeconfig=kube-proxy.kubeconfig

root@linux-node1:/usr/local/src/ssl# kubectl config set-context default \
   --cluster=kubernetes \
   --user=kube-proxy \
   --kubeconfig=kube-proxy.kubeconfig

root@linux-node1:/usr/local/src/ssl# kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

root@linux-node1:/usr/local/src/ssl# cp kube-proxy.kubeconfig /opt/kubernetes/cfg/

# 分发给其余4个节点
root@linux-node1:/usr/local/src/ssl# scp kube-proxy.kubeconfig 192.168.185.132:/opt/kubernetes/cfg/

6、创建kube-proxy服务，五个节点上都要照做一遍

root@linux-node1:~# mkdir /var/lib/kube-proxy

# 编写服务文件，注意每个节点上的ip要根据该节点做出修改，
# 例如下面的两个192.168.185.131到node2上就要改写成192.168.185.132
root@linux-node1:~# vim /etc/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Kube-Proxy Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target

[Service]
WorkingDirectory=/var/lib/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \
  --bind-address=192.168.185.131 \
  --hostname-override=192.168.185.131 \
  --kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig \
--masquerade-all \
  --feature-gates=SupportIPVSProxyMode=true \
  --proxy-mode=ipvs \
  --ipvs-min-sync-period=5s \
  --ipvs-sync-period=5s \
  --ipvs-scheduler=rr \
  --logtostderr=true \
  --v=2 \
  --logtostderr=false \
  --log-dir=/opt/kubernetes/log

Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

6、启动Kubernetes Proxy（这里我们主节点不启动，只启动所有的子节点）

[root@linux-node2 ~]# systemctl daemon-reload
[root@linux-node2 ~]# systemctl enable kube-proxy
[root@linux-node2 ~]# systemctl start kube-proxy
[root@linux-node2 scripts]# systemctl status kube-proxy

7、在主节点上查看所有子节点状态

root@linux-node1:~#  kubectl get node

都已 Ready ! Ok，搞定！

九、Flannel网络部署

Flannel是一个专为kubernetes定制的三层网络解决方案，主要用于解决容器的跨主机通信问题。详细想了解的话推荐一篇不错的文章给大家技术干货|深入理解flannel。

1.为Flannel生成证书，并分发

root@linux-node1:/usr/local/src/ssl# vim flanneld-csr.json
{
  "CN": "flanneld",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}

root@linux-node1:/usr/local/src/ssl# 
cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
    -ca-key=/opt/kubernetes/ssl/ca-key.pem \
    -config=/opt/kubernetes/ssl/ca-config.json \
-profile=kubernetes flanneld-csr.json | cfssljson -bare flanneld

root@linux-node1:/usr/local/src/ssl# cp flanneld*.pem /opt/kubernetes/ssl/

# 分发到其他4子节点
root@linux-node1:/usr/local/src/ssl# 
scp flanneld*.pem 192.168.185.132:/opt/kubernetes/ssl/

3、找到已下载好的Flannel软件包，分别拷到需要的位置

root@linux-node1:~# cd /usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# tar zxf flannel-v0.10.0-linux-amd64.tar.gz

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# cp flanneld mk-docker-opts.sh /opt/kubernetes/bin/

# 拷到其余4个子节点：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp flanneld mk-docker-opts.sh 192.168.185.132:/opt/kubernetes/bin/

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# cd kubernetes/cluster/centos/node/bin/

root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/cluster/centos/node/bin# cp remove-docker0.sh /opt/kubernetes/bin/

# 拷到其余4个子节点：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1/kubernetes/cluster/centos/node/bin# 
scp remove-docker0.sh 192.168.185.132:/opt/kubernetes/bin/

4、配置Flannel

[root@linux-node1 ~]# vim /opt/kubernetes/cfg/flannel
FLANNEL_ETCD="-etcd-endpoints=https://192.168.185.131:2379,https://192.168.185.132:2379,https://192.168.185.133:2379,https://192.168.185.134:2379,https://192.168.185.135:2379"
FLANNEL_ETCD_KEY="-etcd-prefix=/kubernetes/network"
FLANNEL_ETCD_CAFILE="--etcd-cafile=/opt/kubernetes/ssl/ca.pem"
FLANNEL_ETCD_CERTFILE="--etcd-certfile=/opt/kubernetes/ssl/flanneld.pem"
FLANNEL_ETCD_KEYFILE="--etcd-keyfile=/opt/kubernetes/ssl/flanneld-key.pem"

# 每个子节点都要拷过去
[root@linux-node1 ~]# scp /opt/kubernetes/cfg/flannel 192.168.185.132:/opt/kubernetes/cfg/

5、配置Flannel服务

[root@linux-node1 ~]# vim /etc/systemd/system/flannel.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network.target
Before=docker.service

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/flannel
ExecStartPre=/opt/kubernetes/bin/remove-docker0.sh
ExecStart=/opt/kubernetes/bin/flanneld ${FLANNEL_ETCD} ${FLANNEL_ETCD_KEY} ${FLANNEL_ETCD_CAFILE} ${FLANNEL_ETCD_CERTFILE} ${FLANNEL_ETCD_KEYFILE}
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -d /run/flannel/docker

Type=notify

[Install]
WantedBy=multi-user.target
RequiredBy=docker.service

# 每个子节点都要拷过去：
[root@linux-node1 ~]# scp /etc/systemd/system/flannel.service 192.168.185.132:/etc/systemd/system/

6、Flannel CNI集成

# 在每个节点上都要建立CNI文件夹
root@linux-node1: mkdir /opt/kubernetes/bin/cni

# 找到已下载好的CNI插件位置，解压和拷贝到需要的位置：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# tar zxf cni-plugins-amd64-v0.7.1.tgz -C /opt/kubernetes/bin/cni

# 每个子节点都要拷过去：
root@linux-node1:/usr/local/src/k8s-v1.10.1-manual/k8s-v1.10.1# scp -r /opt/kubernetes/bin/cni/* 192.168.185.132:/opt/kubernetes/bin/cni/

# 创建Etcd的key：
[root@linux-node1 ~]# /opt/kubernetes/bin/etcdctl --ca-file /opt/kubernetes/ssl/ca.pem --cert-file /opt/kubernetes/ssl/flanneld.pem --key-file /opt/kubernetes/ssl/flanneld-key.pem \
      --no-sync -C https://192.168.185.131:2379,https://192.168.185.132:2379,https://192.168.185.133:2379,https://192.168.185.134:2379,https://192.168.185.135:2379 \
mk /kubernetes/network/config '{ "Network": "10.2.0.0/16", "Backend": { "Type": "vxlan", "VNI": 1 }}' >/dev/null 2>&1

7、启动Flannel

[root@linux-node1 ~]# systemctl daemon-reload
[root@linux-node1 ~]# systemctl enable flannel
[root@linux-node1 ~]# chmod +x /opt/kubernetes/bin/*

[root@linux-node1 ~]# systemctl start flannel
[root@linux-node1 ~]# systemctl status flannel

8、配置Docker使用Flannel

找到你的docker.service文件去修改它，我的ubuntu系统中该文件是在/lib/systemd/system/下，如果是centos系统可能不一样，总之找到它。
然后修改，即添加下图红线中的部分代码。

root@linux-node1:/lib/systemd/system# vim docker.service

# 每个子节点都要拷过去：
root@linux-node1:/lib/systemd/system# scp docker.service 192.168.185.132:/lib/systemd/system/

9、重启Docker，在每个节点上都要重启

root@linux-node1:/lib/systemd/system# systemctl daemon-reload
root@linux-node1:/lib/systemd/system# systemctl restart docker

10、测试

在每个节点上都执行ifconfig,查看docker0和flannel.1是否在一个网段:

root@linux-node1:/lib/systemd/system# ifconfig

注意！！！到此为止，可以说是一个里程碑了，我们的K8s基本架构已经完成了，下一章我们将会在K8s集群中测试第一个小例子，之后几章还将增加其他东西。

还有需要注意的是可能你今天搭完K8s集群，然后开心地把虚拟机关了，集群的服务自然也就kill掉了。晚上喝了点酒看了场足球赛国足冲进世界杯了哈哈，第二天你再在虚拟机里打开所有节点后，不知道怎么启动集群了一脸懵逼，现在我告诉你，以后每次把所有节点都开机后只需做如下几件事来开启K8s集群服务

在所有子节点上重启kubelet和kube-proxy(前提是每台机器上的docker服务已启动，不过docker一般都是开机就自启了)：

# 在每个子节点上连续执行下面的命令即可
systemctl daemon-reload
systemctl enable kubelet
systemctl enable kube-proxy
systemctl start kubelet && systemctl start kube-proxy

然后你就可以在主节点上看到你整个K8s集群所有节点启动完毕了！

十、测试第一个kubernetes应用

到此为止，我们已经完成了一个最基础的k8s集群搭建完成，我们来通过简单的nginx应用部署来做个测试:

1、Deployment

# 编写nginx-deployment.yaml文件
# 由文件可以看到该deployment创建了3个装有nginx的pod
root@linux-node1:~# vim nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  lables:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80


# 创建
root@linux-node1:~# kubectl create -f nginx-deployment.yaml --validate=false

# 查看deployment
root@linux-node1:~# kubectl get deployment

# 查看pod
root@linux-node1:~# kubectl get pod -o wide

(注意：刚开始这里的status不一定显示running,因为pod中拉取镜像需要下载时间，这取决于你的网速，有时未必能拉取成功，耐心等待，只要最后running就可以了)

2、Service

# 编写nginx-service.yaml文件
# 因为我们要通过service来映射刚刚那个deployment，即访问nginx的pod
root@linux-node1:~# vim nginx-service.yaml
kind: Service
apiVersion: v1
metadata:
  name: nginx-service
spec: 
  selector: 
    app: nginx
  ports:
  - protocol: TCP
    port: 80
targetPort: 80

# 创建
root@linux-node1:~# kubectl create -f nginx-service.yaml 

# 查看
root@linux-node1:~# kubectl get service

红线处是这个服务的名字和虚拟访问地址。

3、测试访问nginx
因为主节点上并没有启动kube-proxy,所以你可以去任意一个子节点测试访问 nginx service，比如在node2上:

root@linux-node2:~# curl --head 10.1.196.117

Ok，搞定！

十一、部署CoreDNS

还记得，上一章我们测试第一个K8s应用时，我们创建了一个nginx-service服务：

它的Service Name就是：nginx-service， 访问地址是：10.1.196.117，我们当时在访问测试的时候是直接访问ip地址的，看上去挺麻烦且不容易记。

在Kubernetes集群中，推荐使用Service Name作为服务的访问地址。因此需要一个Kubernetes集群范围的DNS服务实现从Service Name到Cluster Ip的解析，这就是Kubernetes基于DNS的服务发现功能。Kubernetes推荐使用CoreDNS作为集群内的DNS服务，所以本章我们要来部署CoreDNS。

root@linux-node1:~# vim coredns.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: coredns
  namespace: kube-system
  labels:
      kubernetes.io/cluster-service: "true"
      addonmanager.kubernetes.io/mode: Reconcile
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
    addonmanager.kubernetes.io/mode: Reconcile
  name: system:coredns
rules:
- apiGroups:
  - ""
  resources:
  - endpoints
  - services
  - pods
  - namespaces
  verbs:
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
    addonmanager.kubernetes.io/mode: EnsureExists
  name: system:coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:coredns
subjects:
- kind: ServiceAccount
  name: coredns
  namespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: kube-system
  labels:
      addonmanager.kubernetes.io/mode: EnsureExists
data:
  Corefile: |
    .:53 {
        errors
        health
        kubernetes cluster.local. in-addr.arpa ip6.arpa {
            pods insecure
            upstream
            fallthrough in-addr.arpa ip6.arpa
        }
        prometheus :9153
        proxy . /etc/resolv.conf
        cache 30
    }
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: coredns
  namespace: kube-system
  labels:
    k8s-app: coredns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "CoreDNS"
spec:
  replicas: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  selector:
    matchLabels:
      k8s-app: coredns
  template:
    metadata:
      labels:
        k8s-app: coredns
    spec:
      serviceAccountName: coredns
      tolerations:
        - key: node-role.kubernetes.io/master
          effect: NoSchedule
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      containers:
      - name: coredns
        image: coredns/coredns:1.0.6
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        args: [ "-conf", "/etc/coredns/Corefile" ]
        volumeMounts:
        - name: config-volume
          mountPath: /etc/coredns
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
      dnsPolicy: Default
      volumes:
        - name: config-volume
          configMap:
            name: coredns
            items:
            - key: Corefile
              path: Corefile
---
apiVersion: v1
kind: Service
metadata:
  name: coredns
  namespace: kube-system
  labels:
    k8s-app: coredns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "CoreDNS"
spec:
  selector:
    k8s-app: coredns
  clusterIP: 10.1.0.2
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP

# 创建
root@linux-node1:~# kubectl create -f coredns.yaml  

# 查看（命令后面 “-n kube-system”意思是在系统命名空间下）
root@linux-node1:~# kubectl get pod -n kube-system

Ok，搞定！

十二、部署可视化界面：Dashboard

Kubernetes Dashboard就是k8s集群的webui，集合了所有命令行可以操作的所有命令。

1、先将我已经给你们下载好的包含所有相关安装Dashboard所需要的yaml文件所在的文件夹（链接:https://pan.baidu.com/s/1W-azrXILhI3toeFTgZ-Esw 密码:lp5q）上传到主节点后：

2、创建所有，等待其创建完毕Running就可以访问了

root@linux-node1:~/dashboard# kubectl create -f .

root@linux-node1:~/dashboard#  kubectl get pod -n kube-system

root@linux-node1:~/dashboard#  kubectl get service -n kube-system

这样的话在自己主机上就可以访问dashboard可视化界面（注意因为是要通过kube-proxy才能访问我们集群内的目标服务，我们master节点并没有启动kube-proxy，所以我们要通过“子节点ip+服务端口号”来访问，例如：https://192.168.185.132:24424）
首次登录会出现下面这个界面：

先选择令牌，下面的输入令牌要输入我们的token。
然后在我们的主节点上敲如下命令来获取你的token：

root@linux-node1:~/dashboard# kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')

将该token复制粘贴到网页中的“输入令牌”中，然后登录，就会出现我们的dashboard界面：

安装完毕，剩下就是你需要自己学习如何方便地使用DashBoard来管理K8s集群。
Ok，搞定！

十三、部署可视化监控：influxdb+grafana+heapster

1、把所有相关组件需要的yaml文件下载好上传到主节点
链接:https://pan.baidu.com/s/1K0OLCIl9WhUIvxhpq9oZ0g 密码:ua02

2、依次创建，等待pod创建完毕Running起来

root@linux-node1:~# kubectl create -f influxdb.yaml 

root@linux-node1:~# kubectl create -f grafana.yaml 

root@linux-node1:~# kubectl create -f  heapster-rbac.yaml 

root@linux-node1:~# kubectl create -f  heapster.yaml 

root@linux-node1:~# kubectl get pod -n kube-system

当显示都跑起来后，打开网址http://192.168.185.132:30108，登录用户名：admin，密码:admin

（具体怎么使用这个可视化监控界面可以参考网上其他资料，这里不一一赘述。）

注意：有可能创建过程很慢或失败，多半是因为镜像下载太慢造成的，如果遇到这种情况，依次打开上面的每个yaml文件，你会发现每个yaml文件中都有个image标签，后面跟着个下载镜像的地址：

红色部分就是镜像的下载地址，我是一个网易云仓库的下载地址的，你也可以参考网上给出的其他仓库下载地址替换掉红色部分后保存文件，然后重新创建就行了。当然还有一种方法供大家选择性参考，其实效率最快的应该是自己搭一个私有的镜像仓库专门供该K8s集群拉镜像，具体操作可以参考我的另一篇博客:《Ubuntu16.04使用Harbor构建Docker企业级私有仓库》

Ok，搞定！

总结

Ok !!! 到此为止我们所有步骤都完成了！！！

以上就是本博客《Ubuntu16.04手动搭建Kubernetes集群过程完整详细步骤（一步步入门K8s云平台架构）》的全部内容了。搭建过程中可能会遇到些小问题，不要紧张不要急，多查多看，一定要耐心操作一遍，相信你一定对K8s云平台会慢慢入门了，加油！

写完这篇也够长的，我要去喝啤酒看足球赛了，中国足球加油！C罗宇宙最帅！