Kubernetes入门（番外篇）K8s集群二进制搭建

Ⅰ.搭建前须知

1. 建议首先要搭建yum源用来安装docker，以及后续的各种安装包。
2. K8s集群需要加密访问，需要建个.kube目录保存授权信息。
3. K8s集群只有在部署网络插件后Node才能变为Ready。
4. kube-system是K8s项目预留的系统Pod的工作空间。
5. usr/lib/systemd/system/ 一般是系统的工作目录，所以我们要把各种二进制文件复制到这里来，然后就可以enable服务了
6. /var/lib/etcd 是工作目录(保存数据的地方)，二进制文件在这里运行。工作目录也有 /var/lib/kube-proxy之类的
7. /etc/kubernetes 是各个二进制文件运行所依赖的配置文件的存放处 其中各个二进制文件配置都有需要注意的地方
8. ~/.kube/config 是使用kubectl命令行工具必须的配置文件，
9. echo "export PATH=/test/kubernetes-bins:$PATH" >> /etc/profile 可以用这行命令设置环境变量

组件	链接
docker	https://download.docker.com/linux/centos/7/x86_64/stable/Packages/
k8s组件	https://github.com/kubernetes/kubernetes/releases
etcd	https://github.com/etcd-io/etcd/releases?after=v3.2.17
bridge-util软件	http://www.rpmfind.net/linux/rpm2html/search.php?query=bridge-utils(x86-64)
cfssl	https://github.com/cloudflare/cfssl 、https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
calico插件	https://github.com/projectcalico/calico/releases/
calico容器镜像	http://quay.io/calico/kube-controllers:v3.1.3
dockers-compose组件	https://github.com/docker/compose/releases
harbor组件	https://github.com/goharbor/harbor/releases

1.搭建本地yum源安装docker

1.使用yum安装httpd 、 createrepo
　　yum -y install httpd* httpd-devel createrepo

2.安装完成测试
　　service httpd restart ##启动httpd

　　测试 netstat -tlun 查看端口80是否存在，可以修改httpd.conf文件修改服务端口。

3.新建目录，并把需要的rpm包在网页上发布的目录放在/var/www/html/下面
　　然后进入这个/var/www/html/datat/这个目录下面 然后输入命令createrepo ./生成一个repodata的目录。（这一步是创建索引存储库）
如果以后这个/var/www/html/data/的目录下添加rpm包用命令createrepo --update ./（这里必须在/var/www/html/data/执行 因为是./代表当前目录）更新就可以了

4.本地新建repo文件，yum指定安装源进行安装。当然可以只把以上网址当做下载地址，下载下来本地安装。
　　yum -y install docker-ce --enablerepo=http

2.安装Docker

1.下载相关rpm，由于17.03.2-ce 默认前置selinux-17.03.2.ce，去相关网站（docker本源站、阿里镜像站）下载这两个包docker-ce-selinux-17.03.2.ce-1.el7.centos.noarch.rpm、docker-ce-17.03.2.ce-1.el7.centos.x86_64.rpm。

2.把文件上传到要安装的服务器，在上传的目录下执行yum localinstall命令安装

　　yum localinstall docker-ce-selinux-17.03.2.ce-1.el7.centos.noarch.rpm
　　yum localinstall docker-ce-17.03.2.ce-1.el7.centos.x86_64.rpm

3.开启docker服务
　　service docker start

4.查看docker信息，验证版本号为17.03.2-ce
　　docker info

3.下载K8s 1.10.11二进制组件

1.从K8s github上找到相关版本，进入下载相关二进制组件

2.进入 CHANGELOG-1.10.md 选择选择Service Binaries中的kubernetes-server-linux-amd64.tar.gz 该文件已经包含了 K8S所需要的全部组件，无需单独下载Client等组件。
　　但这里还是没有etcd的组件，需要在相关连接下载，这里使用的是etcd v3.2.16.当然事实上这些二进制组件都可以使用rpm文件进行安装。而kubeadm则更进一步，把这些二进制组件全部打包成镜像，到时候直接下载镜像并运行，来提供服务。

3.规划不同节点需要安装的文件

节点IP地址	角色	安装组件名称
47.111.145.31	Master（管理节点）	docker、etcd、kube-apiserver、kube-controller-manager、kube-scheduler、kubectl
47.110.11.33	Node1（计算节点）	docker 、kubelet、kube-proxy 、kubectl
114.55.175.117	Node2（计算节点）	docker 、kubelet、kube-proxy 、kubectl

　　PS：以上是K8s集群的必要组件，或者说是最小化组件，必须有这些才能完成K8s集群的基本工作。后面还会在各个节点上装calico（提供网络功能，网络插件用yaml文件起一个pod即可）、装kube-dns（为集群提供dns功能）、以及最关键的kubernetes-with-ca组件（使用cfssl改造以上所有组件）

4.接下来思路是
1）把每个组件依次复制到/usr/bin目录文件下（当然也可在任意路径设置绝对路径，这里没有使用这种方法）。
2）创建systemd服务文件即.service。
3）创建service 中对应的配置参数文件。（以上两步共会创建近10个文件，可以提前写好直接上传到对应路径.当然你也可以不写参数文件，在service中把全部参数写好）
4）设置开机自启。
5）最后启动该组件。（执行相关命令即可）
6）授权改造。

组件名	二进制文件位置	service位置	conf位置
pem	/usr/bin
etcd	/usr/bin	/etc/systemd/system/etcd.service	/etc/etcd/etcd.conf
kube-apiserver	/usr/bin	/usr/lib/systemd/system/kube-apiserver.service	/etc/kubernetes/apiserver
kube-controller-manager	/usr/bin	/usr/lib/systemd/system/kube-controller-manager.service	/etc/kubernetes/controller-manager
kube-sheduler	/usr/bin	/usr/lib/systemd/system/kube-scheduler.service	/etc/kubernetes/scheduler
kubectl	/usr/bin	/usr/lib/systemd/system/kubelet.service	/etc/kubernetes/kubelet、/var/lib/kubelet/kubeconfig
kube-proxy	/usr/bin	usr/lib/systemd/system/kube-proxy.service	/etc/kubernetes/proxy

4.节点设置

1.关闭、禁用防火墙(让所有机器之间都可以通过任意端口建立连接)
　　$ systemctl stop firewalld
　　$ systemctl disable firewalld

2.禁用SELINUX
　　$ setenforce 0
　　$ cat /etc/selinux/config
　　SELINUX=disabled

　　安装bridge-util软件，加载bridge模块，加载br_netfilter模块
　　yum localinstall -y bridge-utils-1.5-9.el7.x86_64.rpm
　　modprobe bridge
　　modprobe br_netfilter

3.设置系统参数 - 允许路由转发，不对bridge的数据进行处理
　　#写入配置文件
　　$ cat < /etc/sysctl.d/k8s.conf
　　net.ipv4.ip_forward = 1
　　net.bridge.bridge-nf-call-ip6tables = 1
　　net.bridge.bridge-nf-call-iptables = 1
　　EOF

#生效配置文件
　　$ sysctl --system

4.关闭交换
　　$swapoff -a

5.配置host文件
　　查看各个主机hostname

　　设置主机名

　　hostnamectl set-hostname master
　　hostnamectl set-hostname node1
　　hostnamectl set-hostname node2

　　#配置host，使每个Node都可以通过名字解析到ip地址
　　$ vi /etc/hosts
　　#加入如下片段(ip地址和servername替换成自己的)
　　47.111.145.31 master
　　47.110.11.33 node1
　　114.55.175.117 node2

5.认证授权机制基础

　　其实没有认证授权机制，K8s集群也能跑，也能运行。但是正是为了防止有人入侵你的集群，root一台机器黑了整个集群，需要引入了业界成熟的认证授权方案。
　　kubernetes提供了多种认证方式，比如客户端证书、静态token、静态密码文件、ServiceAccountTokens等等。如果同时使用一种或多种认证方式。只要通过任何一个都被认作是认证通过。常见的认证方式有：客户端证书认证、引导Token、Service Account Tokens 认证。而自K8s 1.6引入了角色访问控制机制（RBAC），我们也使用这种方法。

　　cfssl是非常好用的CA工具，我们用它来生成证书和秘钥文件

组件	要安装的证书
etcd	ca.pem 、server.pem 、server-key.pem
kube-apiserver	ca.pem 、server.pem 、server-key.pem
kubelet	ca.pem 、ca-key.pem
kube-proxy	ca.pem 、kube-proxy.pem 、kube-proxy-key.pem
kubectl	ca.pem 、admin.pem 、admin-key.pem

　　设置好json文件，为所有节点创建公钥私钥，最后只需要pem文件，pem文件拷到三台机子上即可。
　　下载证书，上传到usr/local/bin 文件夹 执行chmod +x *

　　只要pem文件生成的是对的，最后只要在各个service里更新--cacert、--cert、--key即可。

Ⅱ.Master节点部署

　　启动etcd、kube-apiserver、kube-controller-manger、kube-scheduler、kubectl

　　上传kubernetes-server-linux-amd64.tar.gz，进行解压。
　　 tar -zxvf kubernetes-server-linux-amd64.tar.gz

　　对不同的进行打包复制、复制到相应位置。
　　cp /kubernetes-server-linux-amd64.tar.gz /k8s

chmod +x 修改可执行权限 至关重要！！

1.装etcd

（1） ectd数据库安装 下载解压后将etcd、etcdctl二进制文件复制到/usr/bin目录
　　cp /k8s/etcd-v3.2.16-linux-amd64/etcd* /usr/bin

　　cp /k8s/etcd-v3.2.16-linux-amd64/etcd /usr/bin
　　cp /k8s/etcd-v3.2.16-linux-amd64/etcdctl /usr/bin

（2）设置 etcd.service服务文件 在/etc/systemd/system/目录里创建etcd.service，其内容如下

$ cat /etc/systemd/system/etcd.service
[Unit]
Description=etcd.service
[Service]
Type=notify
TimeoutStartSec=0
Restart=always
WorkingDirectory=/var/lib/etcd
EnvironmentFile=-/etc/etcd/etcd.conf
ExecStart=/usr/bin/etcd
[Install]
WantedBy=multi-user.target
EOF

　　其中WorkingDirectory为etcd数据库目录，需要在etcd安装前创建

（3）创建配置/etc/etcd/etcd.conf文件

$ cat /etc/etcd/etcd.conf
ETCD_NAME=ETCD Server
ETCD_DATA_DIR="/var/lib/etcd/"
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://masterIP地址:2379"
EOF

（4）配置开机启动

$systemctl daemon-reload
$systemctl enable etcd.service
$systemctl start etcd.service

（5）检验etcd是否安装成功
　　$ etcdctl cluster-health

2.装kube-apiserver服务

（1）复制二进制文件到/usr/bin目录 将kube-apiserver、kube-controller-manager、kube-scheduler 三个可执行文件复制到/usr/bin目录
　　cp /k8s/kubernetes/server/bin/kube* /usr/bin

　　cp /k8s/kubernetes/server/bin/kube-apiserver /usr/bin
　　cp /k8s/kubernetes/server/bin/kube-controller-manager /usr/bin
　　cp /k8s/kubernetes/server/bin/kube-scheduler /usr/bin

（2）新建并编辑/kube-apiserver.service 文件
　　$cat /usr/lib/systemd/system/kube-apiserver.service

[Unit]
Description=Kubernetes API Server
After=etcd.service
Wants=etcd.service

[Service]
EnvironmentFile=/etc/kubernetes/apiserver
ExecStart=/usr/bin/kube-apiserver  \
        $KUBE_ETCD_SERVERS \
        $KUBE_API_ADDRESS \
        $KUBE_API_PORT \
        $KUBE_SERVICE_ADDRESSES \
        $KUBE_ADMISSION_CONTROL \
        $KUBE_API_LOG \
        $KUBE_API_ARGS 
Restart=on-failure
Type=notify
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

(3)新建参数配置文件/etc/kubernetes/apiserver
　　$cat /etc/kubernetes/apiserver

KUBE_API_ADDRESS="--insecure-bind-address=0.0.0.0"
KUBE_API_PORT="--insecure-port=8080"
KUBE_ETCD_SERVERS="--etcd-servers=http://masterIP地址:2379"
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=169.169.0.0/16"
KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota"
KUBE_API_LOG="--logtostderr=false --log-dir=/home/k8s-t/log/kubernets --v=2"
KUBE_API_ARGS=" "

3.kube-controller-manger部署

（1）配置kube-controller-manager systemd 文件服务 命令内容如下：
　　$cat /usr/lib/systemd/system/kube-controller-manager.service

[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
[Service]
ExecStart=/usr/bin/kube-controller-manager \
  --address=127.0.0.1 \
  --master=http://127.0.0.1:8080 \
  --allocate-node-cidrs=true \
  --service-cluster-ip-range=169.169.0.0/16 \
  --cluster-cidr=172.20.0.0/16 \
  --cluster-name=kubernetes \
  --leader-elect=true \
  --cluster-signing-cert-file= \
  --cluster-signing-key-file= \
  --v=2
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target

4.kube-scheduler组件部署

（1）配置kube-scheduler systemd服务文件
　　$cat /usr/lib/systemd/system/kube-scheduler.service

[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]
ExecStart=/usr/bin/kube-scheduler \
  --address=127.0.0.1 \
  --master=http://127.0.0.1:8080 \
  --leader-elect=true \
  --v=2
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target

5.将各组件加入开机自启

（1）命令如下：

systemctl daemon-reload
systemctl enable kube-apiserver.service
systemctl start kube-apiserver.service
systemctl enable kube-controller-manager.service
systemctl start kube-controller-manager.service
systemctl enable kube-scheduler.service
systemctl start kube-scheduler.service

（2）Master一键重启服务：
　　for i in etcd kube-apiserver kube-controller-manager kube-scheduler docker;do systemctl restart $i;done

（3）验证服务
　　journalctl -f -u kube-scheduler

　　systemctl status kube-controller-manager该命令可查看各个组件是否正常运行
　　systemctl daemon-reload && systemctl restart kubelet 可以在运行失败后修改文件重新启动

netstat -tunlp 查看端口号

可以看到etcd、kube-apiservice、kube-controll、kube-schedule已经启动并提供服务。

6.Calico部署

（1）解压压缩包复制calico、calicoctl、calico-ipam到usr/bin：

（1）配置kube-calico.service文件服务 命令内容如下：(注意提前下载并在本地load好calico的镜像docker load -i calico.tar，并创建相关目录)
注意如果etcd没使用加密的情况下etcd的地址要使用http。否则会报错，因为默认是https。

[Unit]
Description=calico node
After=docker.service
Requires=docker.service

[Service]
User=root
PermissionsStartOnly=true
ExecStart=/usr/bin/docker run --net=host --privileged --name=calico-node \
  -e ETCD_ENDPOINTS=http://47.111.145.31:2379 \
  -e CALICO_LIBNETWORK_ENABLED=true \
  -e CALICO_NETWORKING_BACKEND=bird \
  -e CALICO_DISABLE_FILE_LOGGING=true \
  -e CALICO_IPV4POOL_CIDR=172.20.0.0/16 \
  -e CALICO_IPV4POOL_IPIP=off \
  -e FELIX_DEFAULTENDPOINTTOHOSTACTION=ACCEPT \
  -e FELIX_IPV6SUPPORT=false \
  -e FELIX_LOGSEVERITYSCREEN=info \
  -e FELIX_IPINIPMTU=1440 \
  -e FELIX_HEALTHENABLED=true \
  -e IP=47.111.145.31 \
  -v /var/run/calico:/var/run/calico \
  -v /lib/modules:/lib/modules \
  -v /run/docker/plugins:/run/docker/plugins \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /var/log/calico:/var/log/calico \
   calico-node:v2.6.2
ExecStop=/usr/bin/docker rm -f calico-node
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

（3）启动相关服务，命令内容如下：

systemctl daemon-reload
systemctl enable kube-calico.service
systemctl start kube-calico.service
systemctl status kube-calico.service
journalctl -f -u kube-calico
calicoctl node status

Ⅲ.Node节点部署

1.安装kube-proxy服务

（1）添加/usr/lib/systemd/system/kube-proxy.service文件，内容如下：

[Unit]
Description=Kubernetes Kube-Proxy Server
After=network.target
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/proxy
ExecStart=/usr/bin/kube-proxy \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_PROXY_ARGS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

（2）创建/etc/kubernetes目录

　　$mkdir -p /etc/kubernetes

(3）添加/etc/kubernetes/proxy配置文件 vim /etc/kubernetes/proxy，内容如下：

　　KUBE_PROXY_ARGS=""

（4）添加/etc/kubernetes/config文件 192.168.1.10是本地局域网

KUBE_LOGTOSTDERR="--logtostderr=true"

KUBE_LOG_LEVEL="--v=0"

KUBE_ALLOW_PRIV="--allow_privileged=false"

KUBE_MASTER="--master=http://192.168.1.10:8080"

（5）启动kube-proxy服务

$systemctl daemon-reload
$systemctl enable kube-proxy.service
$systemctl start kube-proxy.service
$journalctl -f -u kube-proxy
$systemctl status kube-proxy

（6）查看kube-proxy启动状态
　　$netstat -lntp | grep kube-proxy

2. 安装kubelet服务

（1） 创建/usr/lib/systemd/system/kubelet.service文件

[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service

[Service]
WorkingDirectory=/var/lib/kubelet
EnvironmentFile=-/etc/kubernetes/kubelet
ExecStart=/usr/bin/kubelet $KUBELET_ARGS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target

（2） 创建kubelet所需文件路径

　　mkdir -p /var/lib/kubelet

（3） 创建kubelet配置文件

　　vim /etc/kubernetes/kubelet,内容如下：

KUBELET_HOSTNAME="--hostname-override=47.111.145.31"
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=ist0ne/pause-amd64:latest"
KUBELET_ARGS="--enable-server=true --enable-debugging-handlers=true --fail-swap-on=false --kubeconfig=/var/lib/kubelet/kubeconfig"

（4） 添加/var/lib/kubelet/kubeconfig文件

　　然后还要添加一个配置文件，因为从1.9.0开始在kubelet里不再使用KUBELET_API_SERVER来跟API通信，而是通过别一个yaml的配置来实现。

　　vim /var/lib/kubelet/kubeconfig ，内容如下：

apiVersion: v1
clusters:
- cluster:
    insecure-skip-tls-verify: true
    server: http://47.111.145.31:8080
  name: kubernetes
contexts:
- context:
    cluster: kubernetes
    user: ""
  name: system:node:kube-master
current-context: system:node:kube-master
kind: Config
preferences: {}
users: []

5）启动kubelet

　　关闭swap分区：swapoff -a (不然kubelet启动报错)

systemctl daemon-reload
systemctl enable kubelet.service
systemctl start kubelet.service
systemctl status kubelet

（6）查看kubelet文件状态

　　$ netstat -lntp | grep kubelet

(7)获取节点：

　　kubectl get nodes

Ⅳ.网络插件、安全插件的安装

1.Harbor

下载docker-compose，下载Harbor对应版本，使用解压出的.sh脚本进行安装。

2.Dashboard

　　与网络插件同理，下载yaml文件，kubectl apply启动，可能需要提前下载相关镜像。

Ⅴ.FAQ

如果你在搭建中遇到了一些错误，可以来这里看看有没有解答.

1.为什么我服务（.service文件）启动失败了？
如图：

关于服务启动失败有很多不同的原因，下面列出几个遇到过的：
code=exited,status=1/failure
这个问题是整个服务就没有起来
~原因一：配置文件格式错误，比如.service中文件格式出错
~原因二：.service文件没有可执行权限，ls -l查看权限，没有执行权限则chmod +x即可。