kubernetes-16-二进制包安装Kubernetes集群

参考二进制包安装Kubernetes集群环境完整版
参考Kubernetes 1.14 二进制集群安装
介绍如何使用二进制部署Kubernetes集群的所有部署，而不是使用自动化部署(kubeadm)集群。

1 k8s集群架构与组件

1.1 组件介绍

(1)Master组件
(1-1)kube-apiserver Kubernetes API
集群的统一入口，各组件协调者，以 RESTful API提供接口服务，所有对象资源的增删改查和监听操作都交给APIServer处理后再提交给Etcd存储。

(1)使用节点本地Nginx 4层透明代理实现高可用 (也可以使用haproxy，只是起到代理apiserver的作用)。
(2)关闭非安全端口8080和匿名访问。
(3)使用安全端口6443接受https请求。
(4)严格的认知和授权策略 (x509、token、rbac)。
(5)开启bootstrap token认证，支持kubelet TLS bootstrapping。
(6)使用https访问kubelet、etcd。

(1-2)kube-controller-manager
处理集群中常规后台任务，一个资源对应一个控制器，而 ControllerManager就是负责管理这些控制器的。

(1)3节点高可用(在k8s中，有些组件需要选举，所以使用奇数为集群高可用方案)。
(2)关闭非安全端口，使用10252接受https请求。
(3)使用kubeconfig访问apiserver的安全端口。
(4)使用approve kubelet证书签名请求(CSR)，证书过期后自动轮转。
(5)各controller使用自己的ServiceAccount访问apiserver。

(1-3)kube-scheduler
根据调度算法为新创建的Pod选择一个Node节点，可以任意部署,可以部署在同一个节点上,也可以部署在不同的节点上。

(1)3节点高可用。
(2)使用kubeconfig访问apiserver安全端口。

(1-4)etcd 分布式键值存储系统。
用于保存集群状态数据，比如Pod、 Service等对象信息。

(2)Node组件
(2-1)kubelet
kubelet 是Master在Node节点上的Agent，管理本机运行容器 的生命周期，比如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作。
kubelet将每个Pod转换成一组容器。

(1)使用kubeadm动态创建bootstrap token。
(2)使用TLS bootstrap机制自动生成client和server证书，过期后自动轮转。
(3)在kubeletConfiguration类型的JSON文件配置主要参数。
(4)关闭只读端口，在安全端口10250接受https请求，对请求进行认真和授权，拒绝匿名访问和非授权访问。
(5)使用kubeconfig访问apiserver的安全端口。

(2-2)kube-proxy
在Node节点上实现Pod网络代理，维护网络规则和四层负载均衡工作。 docker或rocket 容器引擎，运行容器。

(1)使用kubeconfig访问apiserver的安全端口。
(2)在KubeProxyConfiguration类型JSON文件配置为主要参数。
(3)使用ipvs代理模式。

(3)集群插件

(1)DNS 使用功能、性能更好的coredns。
(2)网络 使用Flanneld 作为集群网络插件。

1.2 服务器预处理

(1)在所有机器上添加hosts解析
192.168.0.155 myuse1
192.168.0.156 myuse2

操作系统【centos7】
kubernetes【1.12】
docker【18.06.3】
Etcd 【3.2.12】
Flanneld【 0.11.0】

(2)角色分配

(1)角色k8s-master
192.168.0.155 myuse1
组件kube-apiserver
组件kube-controller-manager
组件kube-scheduler
组件etcd

(2)角色k8s-node1
192.168.0.156 myuse2
组件kubelet
组件kube-proxy
组件docker
组件flannel
组件etcd

两个节点myuse1和myuse2均操作。

(1)关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config 
setenforce 0
(2)关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
(3)关闭swap
swapoff -a
(4)同步时间
yum install -y ntpdate && ntpdate time.w# indows.com

1.3 证书签名请求文件CSR简介

什么是CSR以及CSR的作用和生成
CSR是Certificate Signing Request的英文缩写，即证书签名请求文件，是证书申请者在申请数字证书时由CSP(加密服务提供者)在生成私钥的同时也生成证书请求文件，证书申请者只要把CSR文件提交给证书颁发机构后，证书颁发机构使用其根证书私钥签名就生成了证书公钥文件，也就是颁发给用户的证书。

CSR在线生成工具

1.4 CloudFlare的PKI工具cfssl简介

参考PKI和CA介绍
参考Kubernetes证书相关(CFSSL)

(1)公钥基础设施（Public Key Infrastructure，简称PKI）是目前网络安全建设的基础与核心，是电子商务安全实施的基本保障。

(2)CFSSL是CloudFlare开源的一款PKI/TLS工具。 CFSSL 包含一个命令行工具 和一个用于签名，验证并且捆绑TLS证书的 HTTP API 服务。 使用Go语言编写。

Cloudflare是一家美国的跨国科技企业，总部位于旧金山，在英国伦敦亦设有办事处。Cloudflare以向客户提供网站安全管理、性能优化及相关的技术支持为主要业务。

传输层安全性协议（英语：Transport Layer Security，缩写作TLS），及其前身安全套接层（Secure Sockets Layer，缩写作SSL）是一种安全协议，目的是为互联网通信提供安全及数据完整性保障。

1.5 k8s集群相关证书类型简介

参考CA认证原理及CFSSL证书生成工具的使用
(1)client certificate
用于服务端认证客户端,例如etcdctl、etcd proxy、fleetctl、docker客户端。
(2)server certificate
服务端使用，客户端以此验证服务端身份,例如docker服务端、kube-apiserver。
(3)peer certificate
双向证书，用于etcd集群成员间通信。

根据认证对象可以将证书分成三类：
服务器证书server cert
客户端证书client cert
对等证书peer cert(表示既是server cert又是client cert)

在kubernetes 集群中需要的证书种类如下：
(1)etcd 节点需要标识自己服务的server cert，也需要client cert与etcd集群其他节点交互，当然可以分别指定2个证书，也可以使用一个对等证书。
(2)master 节点需要标识 apiserver服务的server cert，也需要client cert连接etcd集群，这里也使用一个对等证书。
(3)kubectl calico kube-proxy 只需要client cert，因此证书请求中 hosts 字段可以为空。
(4)kubelet证书比较特殊，不是手动生成，它由node节点TLS BootStrap向apiserver请求，由master节点的controller-manager 自动签发，包含一个client cert 和一个server cert。

CA认证，即电子认证服务 ，是指为电子签名相关各方提供真实性、可靠性验证的活动。
证书颁发机构（CA, Certificate Authority）即颁发数字证书的机构。是负责发放和管理数字证书的权威机构，并作为电子商务交易中受信任的第三方，承担公钥体系中公钥的合法性检验的责任。

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

1.5.1 创建认证中心CA简介

1.5.1.1 创建CA配置文件ca-config.json简介

配置证书生成策略，规定CA可以颁发种哪类型的证书。
文件ca-config.json

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

expiry满期，10年。
profiles概述。
encipherment编码加密。
(1)ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；此实例只有一个kubernetes模板。

(2)signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；

(3)server auth：表示client可以用该 CA 对server提供的证书进行验证；
(4)client auth：表示server可以用该CA对client提供的证书进行验证；

1.5.1.2 创建CA证书签名请求ca-csr.json简介

文件ca-csr.json

{
"CN": "kubernetes",
"key": {
    "algo": "rsa",
    "size": 2048
},
"names": [
    {
        "C": "CN",
        "L": "BeiJing",
        "O": "Ctyun",
        "ST": "BeiJing",            
        "OU": "ops"
    }    ]
}

algo,algorithm算法

(1)“CN”：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)。
(2)C=country城市名
(3)L=localityName地址
(4)O：Organization组织名，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)
(5)ST=stateName州名
(6)OU=organizationUnit组织部门名

1.5.1.3 生成CA和私钥cfssl gencert简介

生成CA所必需的文件ca-key.pem（私钥）和ca.pem（证书），还会生成ca.csr（证书签名请求），用于交叉签名或重新签名。

初始化创建CA认证中心，将会生成：
ca-key.pem私钥
ca.pem公钥

#cfssl gencert -initca ca-csr.json | cfssljson -bare ca
#ls
通过ca-config.json和ca-csr.json。
生成ca.csr和ca-key.pem和ca.pem。

PEM(Privacy Enhanced Mail)，通常用于数字证书认证机构（Certificate Authorities，CA），扩展名为.pem, .crt, .cer, 和 .key。内容为Base64编码的ASCII码文件，有类似"-----BEGIN CERTIFICATE-----" 和 "-----END CERTIFICATE-----"的头尾标记。

1.5.2 创建kubernetes证书kubernetes-csr.json简介

#cat kubernetes-csr.json

{
    "CN": "kubernetes",
    "hosts": [
      "127.0.0.1",
      "10.192.44.129",
      "10.192.44.128",
      "10.192.44.126",
      "10.192.44.127",
      "10.254.0.1",
      "*.kubernetes.master",
      "localhost",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "JiangSu",
            "L": "NanJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}

(1)这个证书目前kubernetes.master 域名以便内部私有 DNS 解析使用(可删除)； kubernetes 这几个不能删掉；因为当集群创建好后，default namespace 下会创建一个叫 kubenretes 的 svc，有一些组件会直接连接这个 svc 来跟 api 通讯的，证书如果不包含可能会出现无法连接的情况；其他几个 kubernetes 开头的域名作用相同。
(2)hosts包含的是授权范围，不在此范围的的节点或者服务使用此证书就会报证书不匹配错误。
(3)10.254.0.1是指kube-apiserver 指定的 service-cluster-ip-range 网段的第一个IP。

#生成kubernetes证书和私钥
#cfssl gencert \
-ca=ca.pem \
-ca-key=ca-key.pem \
-config=ca-config.json \
-profile=kubernetes \
kubernetes-csr.json | cfssljson -bare kubernetes 

gencert: 生成新的key(密钥)和签名证书
-ca：指明ca的证书
-ca-key：指明ca的私钥文件
-config：指明请求证书的json文件
-profile：与-config中的profile对应，是指根据config中的profile段来生成证书的相关信息,指定特定的使用场景，比如ca-config.json中的kubernetes区域。

cfssljson程序，从cfssl和multirootca程序获取JSON输出，并将证书，密钥，CSR和bundle写入磁盘。

1.5.3 创建admin证书admin-csr.json简介

#cat admin-csr.json #证书请求文件

{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "JiangSu",
      "L": "NanJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}

#生成admin证书和私钥
#cfssl gencert \
-ca=ca.pem \
-ca-key=ca-key.pem \
-config=ca-config.json \
-profile=kubernetes \
admin-csr.json | cfssljson -bare admin

这个admin 证书，是将来生成管理员用的kube config 配置文件用的，现在我们一般建议使用RBAC 来对kubernetes 进行角色权限控制， kubernetes 将证书中的CN 字段 作为User， O 字段作为 Group。

2 部署Etcd集群

2.1 生成自签证书

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

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/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

或者使用下面的脚本下载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.1.1 文件ca-config.json和ca-csr.json生成CA认证中心

(1)文件ca-config.json
#cat ca-config.json

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

可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；此实例只有一个www模板。
(2)文件ca-csr.json
#cat ca-csr.json

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

其中"CN"：Common Name，从证书中提取该字段作为请求的用户名 (User Name)。
其中C=country城市名
其中L=localityName地址
其中ST=stateName州名

(3)生成CA和私钥

#cfssl gencert -initca ca-csr.json | cfssljson -bare ca
#ls
通过ca-config.json和ca-csr.json。
生成ca.csr和ca-key.pem和ca.pem。

在生成私钥的同时也生成证书请求文件。

#cat ca.csr证书请求文件
-----BEGIN CERTIFICATE REQUEST-----
-----END CERTIFICATE REQUEST-----
#cat ca.pem认证中心公钥
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
#cat ca-key.pem认证中心私钥
-----BEGIN RSA PRIVATE KEY-----
-----END RSA PRIVATE KEY-----

2.1.2 创建server证书server-csr.json

(1)文件server-csr.json
#cat server-csr.json

{
    "CN": "etcd",
    "hosts": [
    "192.168.0.155",
    "192.168.0.156"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}

hosts包含的是授权范围，不在此范围的的节点或者服务使用此证书就会报证书不匹配错误。
(2)生成证书

#颁发证书
cfssl gencert \
-ca=ca.pem \
-ca-key=ca-key.pem \
-config=ca-config.json \
-profile=www \
server-csr.json | cfssljson -bare server
生成server-key.pem和server.pem

2.2 部署Etcd集群

以下部署步骤在规划的两个etcd节点操作一样，唯一不同的是etcd配置文件中的服务器IP要写当前的。
(1)下载解压安装

# wget https://github.com/coreos/etcd/releases/download/v3.2.12/                                      etcd-v3.2.12-linux-amd64.tar.gz
# mkdir -p /opt/etcd/{bin,cfg,ssl} 
# tar zxvf etcd-v3.2.12-linux-amd64.tar.gz
# mv etcd-v3.2.12-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
# 把刚才生成的证书拷贝到配置文件中的位置
#cp ca*pem server*pem /opt/etcd/ssl

2.2.1 配置文件 /opt/etcd/cfg/etcd

创建etcd配置文件：
#cat /opt/etcd/cfg/etcd
(1)myuse1中的配置/opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.0.155:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.155:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.155:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.155:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.155:2380,etcd02=https://192.168.0.156:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

(2)myuse2中的配置/opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.0.156:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.0.156:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.156:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.0.156:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.0.155:2380,etcd02=https://192.168.0.156: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表示加入已有集群。

2.2.2 设置开机自启动Etcd

systemd管理etcd：
#cat /usr/lib/systemd/system/etcd.service
(1)myuse1中的配置文件 /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=etcd01 \
--data-dir=/var/lib/etcd/default.etcd \
--listen-peer-urls=https://192.168.0.155:2380 \
--listen-client-urls=https://192.168.0.155:2379,http://127.0.0.1:2379 \
--advertise-client-urls=https://192.168.0.155:2379 \
--initial-advertise-peer-urls=https://192.168.0.155:2380 \
--initial-cluster=etcd01=https://192.168.0.155:2380,etcd02=https://192.168.0.156:2380 \
--initial-cluster-token=etcd-cluster \
--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

(2)myuse2中的配置文件 /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=etcd02 \
--data-dir=/var/lib/etcd/default.etcd \
--listen-peer-urls=https://192.168.0.156:2380 \
--listen-client-urls=https://192.168.0.156:2379,http://127.0.0.1:2379 \
--advertise-client-urls=https://192.168.0.156:2379 \
--initial-advertise-peer-urls=https://192.168.0.156:2380 \
--initial-cluster=etcd01=https://192.168.0.155:2380,etcd02=https://192.168.0.156:2380 \
--initial-cluster-token=etcd-cluster \
--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

启动并设置开启启动：
#systemctl daemon-reload
#systemctl start etcd
#systemctl enable etcd

2.2.3 测试应用Etcd

(1)检查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://192.168.0.155:2379,https://192.168.0.156:2379" \
cluster-health

其中–ca-file 服务端使用HTTPS时，使用CA文件进行验证。
其中–cert-file HTTPS下客户端使用的SSL证书文件。
其中–key-file HTTPS下客户端使用的SSL密钥文件。
其中–endpoints=[127.0.0.1:2379] gRPC endpoints。
gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。

如果输出上面信息，就说明集群部署成功。
(2)查看Etcd版本

2.2.4 自动化脚本

#!/bin/bash
# example: ./etcd.sh etcd01 192.168.1.10 etcd02=https://192.168.1.11:2380,etcd03=https://192.168.1.12:2380

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

systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

3 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

#docker version【18.06.3】
#docker --version【18.06.3】

4 部署Flannel网络

4.1 添加网络

Falnnel要用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://192.168.0.155:2379,https://192.168.0.156:2379" \
set /coreos.com/network/config  \
'{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

VXLAN(Virtual eXtensible Local Area Network，虚拟扩展局域网),一种网络虚拟化技术。
使用get命令查看

/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://192.168.0.155:2379,https://192.168.0.156:2379" \
get /coreos.com/network/config 

4.2 在node上部署flannel

以下部署步骤在规划的每个node节点都操作。
(1)下载解压安装

# mkdir -p /opt/kubernetes/{bin,cfg,ssl}
# wget https://github.com/coreos/flannel/releases/download/v0.10.0/flannel-v0.10.0-linux-amd64.tar.gz
# tar xzvf flannel-v0.10.0-linux-amd64.tar.gz
# mv flanneld mk-docker-opts.sh /opt/kubernetes/bin

(2)配置Flannel
#cat /opt/kubernetes/cfg/flanneld

FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.0.155:2379,https://192.168.0.156:2379 -etcd-cafile=/opt/etcd/ssl/ca.pem -etcd-certfile=/opt/etcd/ssl/server.pem -etcd-keyfile=/opt/etcd/ssl/server-key.pem"

4.2.1 设置开机自启动flannel

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

4.2.2 设置开机自启动docker指定子网段

配置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

4.2.3 重启flannel和docker服务

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

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

5 部署Master组件

在部署Kubernetes之前一定要确保etcd、flannel、docker是正常工作的。
kube-apiserver
kube-controller-manager
kube-scheduler

5.1 生成证书

5.1.1 文件ca-config.json和ca-csr.json生成CA认证中心

(1)文件ca-config.json
#cat ca-config.json

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

(2)文件ca-csr.json
#cat ca-csr.json

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

(3)生成CA和私钥

#cfssl gencert -initca ca-csr.json | cfssljson -bare ca
#ls
通过ca-config.json和ca-csr.json。
生成ca.csr和ca-key.pem和ca.pem。

在生成私钥的同时也生成证书请求文件。

5.1.2 创建kubernetes证书server-csr.json

#cat server-csr.json

{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.0.155",
      "192.168.0.156",
      "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"
        }
    ]
}

颁发kubernetes证书

#cfssl gencert \
-ca=ca.pem \
-ca-key=ca-key.pem \
-config=ca-config.json -\
profile=kubernetes \
server-csr.json | cfssljson -bare server
#生成server.csr和server-key.pem和server.pem

5.1.3 创建kube-proxy证书kube-proxy-csr.json

生成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
#生成kube-proxy.csr和kube-proxy-key.pem和kube-proxy.pem

5.1.4 创建admin证书admin-csr.json

参考Kubernetes 1.14 二进制集群安装
kubectl与apiserver https通信，apiserver对提供的证书进行认证和授权。kubectl作为集群的管理工具，需要被授予最高权限，这里创建具有最高权限的admin证书

(1)创建证书签名请求admin-csr.json
#cat admin-csr.json

{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "4Paradigm"
    }
  ]
}

(2)颁发证书

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

(3)创建kubeconfig文件
kubeconfig为kubectl的配置文件，包含访问apiserver的所有信息，如apiserver地址、CA证书和自身使用的证书

KUBE_APISERVER="https://192.168.0.155:6443"
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kubectl.kubeconfig
#设置客户端认证参数
kubectl config set-credentials admin \
  --client-certificate=admin.pem \
  --client-key=admin-key.pem \
  --embed-certs=true \
  --kubeconfig=kubectl.kubeconfig
# 设置上下文参数
kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin \
  --kubeconfig=kubectl.kubeconfig
# 设置默认上下文
kubectl config use-context kubernetes --kubeconfig=kubectl.kubeconfig

(4)分发kubeconfig文件
分发到所有使用kubectl命令的节点
mkdir -p ~/.kube
#cp kubectl.kubeconfig ~/.kube/config

(5)复制证书到/opt/kubernetes/ssl/里

# mkdir -p /opt/kubernetes/{bin,cfg,ssl}
# cp ca.pem ca-key.pem server.pem server-key.pem /opt/kubernetes/ssl/

5.2 部署apiserver组件

(1)解压下载安装
二进制下载链接
下载这个包（kubernetes-server-linux-amd64.tar.gz）就够了，包含了所需的所有组件。

# wget https://storage.googleapis.com/kubernetes-release/release/v1.12.10/kubernetes-server-linux-amd64.tar.gz
# mkdir -p /opt/kubernetes/{bin,cfg,ssl} 
# tar zxvf kubernetes-server-linux-amd64.tar.gz
# cd kubernetes/server/bin
# cp kube-apiserver kube-scheduler kube-controller-manager kubectl /opt/kubernetes/bin

5.2.1 创建token文件

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

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

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

5.2.2 创建apiserver配置文件

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

KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.0.155:2379,https://192.168.0.156:2379 \
--bind-address=192.168.0.155 \
--secure-port=6443 \
--advertise-address=192.168.0.155 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/opt/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/opt/kubernetes/ssl/server.pem  \
--tls-private-key-file=/opt/kubernetes/ssl/server-key.pem \
--client-ca-file=/opt/kubernetes/ssl/ca.pem \
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \
--etcd-cafile=/opt/etcd/ssl/ca.pem \
--etcd-certfile=/opt/etcd/ssl/server.pem \
--etcd-keyfile=/opt/etcd/ssl/server-key.pem"

配置好前面生成的证书，确保能连接etcd。
参数说明：
–logtostderr——启用日志
–v——日志等级
–etcd-servers——etcd集群地址
–bind-address——监听地址
–secure-port——https安全端口
–advertise-address——集群通告地址
–allow-privileged——启用授权
–service-cluster-ip-range——Service虚拟IP地址段
–enable-admission-plugins——准入控制模块
–authorization-mode——认证授权，启用RBAC授权和节点自管理
–enable-bootstrap-token-auth——启用TLS bootstrap功能
–token-auth-file——token文件
–service-node-port-range——Service Node类型默认分配端口范围

5.2.3 设置开机自启动kube-apiserver

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

5.3 部署scheduler组件

5.3.1 创建schduler配置文件

#cat /opt/kubernetes/cfg/kube-scheduler

KUBE_SCHEDULER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect"

参数说明：
–logtostderr——启用日志
–v——日志等级
–master——连接本地apiserver
–leader-elect——当该组件启动多个时，自动选举（HA）

5.3.2 设置开机自启动kube-scheduler

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

5.4 部署controller-manager组件

5.4.1 创建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"

5.4.2 开机自启动

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

5.5 查看当前集群组件状态

所有组件都已经启动成功，通过kubectl工具查看当前集群组件状态：
#/opt/kubernetes/bin/kubectl get cs

如上输出说明组件都正常。
#cp /opt/kubernetes/bin/kubectl /usr/bin/
#kubectl get cs

6 部署Node组件

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

参考TLS bootstrapping介绍

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

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

6.2 创建kubeconfig文件

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

6.2.1 创建bootstrap.kubeconfig文件

#(1)创建kubelet bootstrapping kubeconfig

BOOTSTRAP_TOKEN=674c457d4dcf2eefe4920d7dbb6b0ddc
KUBE_APISERVER="https://192.168.0.155:6443"

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

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

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

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

6.2.2 创建kube-proxy.kubeconfig文件

#(1)创建kube-proxy kubeconfig文件

BOOTSTRAP_TOKEN=674c457d4dcf2eefe4920d7dbb6b0ddc
KUBE_APISERVER="https://192.168.0.155:6443"
#(2)设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig
#(3)设置客户端认证参数
kubectl config set-credentials kube-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.kubeconfig
#(4)设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig
#(5)设置默认上下文
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

#ls
bootstrap.kubeconfig kube-proxy.kubeconfig
将这两个文件拷贝到Node节点/opt/kubernetes/cfg目录下。
#scp bootstrap.kubeconfig root@myuse2:/opt/kubernetes/cfg/
#scp kube-proxy.kubeconfig root@myuse2:/opt/kubernetes/cfg/

6.3 部署kubelet组件

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

6.3.1 创建kubelet配置文件

#cat /opt/kubernetes/cfg/kubelet

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

#docker pull registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0

参数说明：
–logtostderr——启用日志
–v——日志等级
–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.0.156
port: 10250
readOnlyPort: 10255
cgroupDriver: systemd
clusterDNS: ["10.0.0.2"]
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true 

6.3.2 设置开机自启动kubelet

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

6.3.3 在Master审批Node加入集群

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

在Master节点查看请求签名的Node：
#kubectl get csr

#kubectl certificate approve XXXXID
#kubectl get node

6.4 部署kube-proxy组件

6.4.1 创建kube-proxy配置文件

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

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

6.4.2 设置开机自启动kube-proxy

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

其余Node节点的部署方式一样。

7 运行测试示例

7.1 示例nginx

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

#kubectl run nginx --image=nginx --replicas=3
#kubectl expose deployment nginx --port=88 --target-port=80 --type=NodePort
#kubectl get pods
#kubectl get svc

访问集群中部署的Nginx，打开浏览器输入：http://192.168.0.156:33458

7.2 安装kubernetes-dashboard

加载镜像
#docker load -i k8s.gcr.io_kubernetes-dashboard-amd64_v1.8.3.tar
#kubectl apply -f kubernetes-dashboard.yaml部署
#kubectl describe secret -n kube-system kubernetes-dashboard获取登录token
#kubectl get svc --all-namespaces查看可访问的服务端口

访问https://192.168.0.156:32000

7.3 安装coredns

#docker pull coredns/coredns:1.2.2
文件coredns.yaml

# Warning: This is a file generated from the base underscore template file: coredns.yaml.base

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
        loop
        reload
        loadbalance
    }
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: coredns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "CoreDNS"
spec:
  # replicas: not specified here:
  # 1. In order to make Addon Manager do not reconcile this replicas parameter.
  # 2. Default is 1.
  # 3. Will be tuned in real time if DNS horizontal auto-scaling is turned on.
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  selector:
    matchLabels:
      k8s-app: kube-dns
  template:
    metadata:
      labels:
        k8s-app: kube-dns
      annotations:
        seccomp.security.alpha.kubernetes.io/pod: 'docker/default'
    spec:
      serviceAccountName: coredns
      tolerations:
        - key: node-role.kubernetes.io/master
          effect: NoSchedule
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      containers:
      - name: coredns
        image: coredns/coredns:1.2.2
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        args: [ "-conf", "/etc/coredns/Corefile" ]
        volumeMounts:
        - name: config-volume
          mountPath: /etc/coredns
          readOnly: true
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
      dnsPolicy: Default
      volumes:
        - name: config-volume
          configMap:
            name: coredns
            items:
            - key: Corefile
              path: Corefile
---
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  annotations:
    prometheus.io/port: "9153"
    prometheus.io/scrape: "true"
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "CoreDNS"
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: 10.0.0.2 
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP

#kubectl apply -f coredns.yaml

8 异常解决

(1)#/opt/kubernetes/bin/kubectl get cs
Unable to connect to the server: dial tcp: lookup localhost on 8.8.8.8:53: no such host
#vi /etc/resolv.conf

# Generated by NetworkManager
#nameserver 8.8.8.8
nameserver 114.114.114.114
search local

(2) failed to run Kubelet: failed to create kubelet: misconfiguration: kubelet cgroup driver: “cgroupfs” is different from docker cgroup driver: “systemd”
其中/opt/kubernetes/cfg/kubelet.config配置文件如下：

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