私有云原生k8s部署
源码包下载
wget https://dl.k8s.io/v1.12.7/kubernetes-server-linux-amd64.tar.gz
安装路径规范
/opt/kubernetes/bin #二进制安装目录
/opt/kubernetes/cfg #配置文件目录
/opt/kubernetes/log #日志目录
/opt/kubernetes/ssl #证书目录
1.环境规划
组件版本：
Kubernetes 1.12.7
Docker 18.09.0-ce
Etcd 3.3.10
Flanneld 0.10.0
keepalived 1.2.20
haproxy 1.6.8
插件：
core-dns
dashboard
镜像仓库:
docker registry
harbor
主要配置策略：
kubernets master节点主要包含组件：
kube-apiserver：
使用 keepalived 和 haproxy 实现 3 节点高可用；
关闭非安全端口 8080 和匿名访问；
在安全端口 6443 接收 https 请求；
严格的认证和授权策略 (x509、token、RBAC)；
开启 bootstrap token 认证，支持 kubelet TLS bootstrapping；
使用 https 访问 kubelet、etcd，加密通信；
kube-controller-manager：
3 节点高可用；
关闭非安全端口，在安全端口 10252 接收 https 请求；
使用 kubeconfig 访问 apiserver 的安全端口；
自动 approve kubelet 证书签名请求 (CSR)，证书过期后自动轮转；
各 controller 使用自己的 ServiceAccount 访问 apiserver；
kube-scheduler：
3 节点高可用；
使用 kubeconfig 访问 apiserver 的安全端口；
# 说明：目前这三个组件需要部署在同一台机器上，kube-scheduler、kube-controller-manager 和 kube-apiserver 三者的功能紧密相关；
同时只能有一个kube-scheduler、kube-controller-manager进程处于工作状态，如果运行多个，则需要通过选举产生一个leader；
kubernets node节点包含的组件：
kubelet：
使用 kubeadm 动态创建 bootstrap token，而不是在 apiserver 中静态配置；
使用 TLS bootstrap 机制自动生成 client 和 server 证书，过期后自动轮转；
在 KubeletConfiguration 类型的 JSON 文件配置主要参数；
关闭只读端口，在安全端口 10250 接收 https 请求，对请求进行认证和授权，拒绝匿名访问和非授权访问；
使用 kubeconfig 访问 apiserver 的安全端口；
运行在每个 worker 节点上，接收 kube-apiserver 发送的请求，管理 Pod 容器，执行交互式命令，如 exec、run、logs等
kublet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况。
kube-proxy：
使用 kubeconfig 访问 apiserver 的安全端口；
在 KubeProxyConfiguration 类型的 JSON 文件配置主要参数；
使用 ipvs 代理模式；
运行在所有 worker 节点上，，它监听 apiserver 中 service 和 Endpoint 的变化情况，创建路由规则来进行服务负载均衡。
集群插件：
DNS：使用功能、性能更好的 coredns；
Dashboard：支持登录认证；
Metric：heapster、metrics-server，使用 https 访问 kubelet 安全端口；
Log：Elasticsearch、Fluend、Kibana；
Registry镜像库：docker-registry、harbor；
服务器分配：
角色 IP 组件
master01 192.168.200.101 kube-apiserver
kube-controller-manager
kube-scheduler
node01 kubelet
kube-proxy
docker
flannel
etcd
haproxy
keepalived
master02 192.168.200.102 kube-apiserver
kube-controller-manager
kube-scheduler
node02 kubelet
kube-proxy
docker
flannel
etcd
haproxy
keepalived
master03 192.168.200.103 kube-apiserver
kube-controller-manager
kube-scheduler
node03 kubelet
kube-proxy
docker
flannel
etcd
各组件使用证书如下
etcd：ca.pem、etcd-key.pem、etcd.pem；
准备工作：
#修改主机名/etc/hostname
#对应主机名为
192.168.200.101 k8s-master1
192.168.200.102 k8s-master2
192.168.200.103 k8s-master3
#本地host解析
cat /etc/hosts
192.168.200.101 etcd1
192.168.200.102 etcd2
192.168.200.103 etcd3
192.168.200.101 k8s-master1
192.168.200.102 k8s-master2
192.168.200.103 k8s-master3
192.168.200.101 k8s-node1
192.168.200.102 k8s-node2
192.168.200.103 k8s-node3
#主机之间互信(在k8s-master1生成密钥)
ssh-keygen -t rsa
ssh-copy-id k8s-master2
ssh-copy-id k8s-master3
#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -P FORWARD ACCEPT
#关闭SElinux
setenforce 0
grep SELINUX /etc/selinux/config
#关闭swap分区
swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
#加载内核模块
modprobe br_netfilter
modprobe ip_vs
#设置系统参数
#tcp_tw_recycle 和 Kubernetes 的NAT冲突，必须关闭 ，否则会导致服务不通；
#关闭不使用的IPV6协议栈，防止触发docker BUG；
cd /etc/sysctl.d/
cat > kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
vm.swappiness=0
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_watches=89100
fs.file-max=52706963
fs.nr_open=52706963
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max=2310720
EOF
sysctl -p /etc/sysctl.d/kubernetes.conf
#检查系统内核和模块适不适合运行docker（Linux系统）
curl https://raw.githubusercontent.com/docker/docker/master/contrib/check-config.sh > check-config.sh
sh check-config.sh
2.安装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 -y docker-ce
cat <<EOF > /etc/docker/daemon.json
{ "registry-mirrors": [ "https://registry.docker-cn.com"],"insecure-registries":["192.168.200.101:5000"] }
EOF
systemctl start docker
systemctl enable docker
3.自签TLS证书
kubernetes系统各组件需要使用TLS证书对通信进行加密，本文档使用CloudFlare的PKI工具集cfssl来生成Certificate Authority (CA)证书和秘钥文件，CA是自签名的证书，用来签名后续创建的其它TLS证书。
#下面步骤是在k8s-master1上操作的。证书只需要创建一次即可，以后在向集群中添加新节点时只要将/opt/kubernetes/ssl目录下的证书拷贝到新节点上即可
#安装CFSSL
curl -o /usr/local/bin/cfssl https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
curl -o /usr/local/bin/cfssljson https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
chmod +x /usr/local/bin/cfssl*
#创建CA配置目录
mkdir -p /opt/kubernetes/ssl
#创建CA证书临时目录
mkdir /root/ssl
cd /root/ssl
#TLS证书创建
#使用脚本生成：cat certificate.sh
#创建CA配置文件
cat > ca-config.json <<EOF
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
],
"expiry": "87600h"
}
}
}
}
EOF
#创建CA证书签名请求
cat > ca-csr.json <<EOF
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -initca ca-csr.json | cfssljson -bare ca
#=======================================================================================================================
#创建etcd证书签名请求文件
cat > etcd-csr.json <<EOF
{
"CN": "etcd",
"hosts": [
"127.0.0.1",
"192.168.200.101",
"192.168.200.102",
"192.168.200.103"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare etcd
#=======================================================================================================================
#创建flannel证书签名请求文件
cat > flanneld-csr.json <<EOF
{
"CN": "flanneld",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes flanneld-csr.json | cfssljson -bare flanneld
#=======================================================================================================================
#创建kubectl请求证书
cat > admin-csr.json <<EOF
{
"CN": "admin",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:masters",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
#=======================================================================================================================
#创建kube-apiserver的证书签名请求
cat > kubernetes-csr.json <<EOF
{
"CN": "kubernetes",
"hosts": [
"127.0.0.1",
"192.168.200.101",
"192.168.200.102",
"192.168.200.103",
"192.168.200.200",
"10.10.10.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": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
#=======================================================================================================================
#创建kube-controller-manager证书请求
cat > kube-controller-manager-csr.json << EOF
{
"CN": "system:kube-controller-manager",
"key": {
"algo": "rsa",
"size": 2048
},
"hosts": [
"127.0.0.1",
"192.168.200.101",
"192.168.200.102",
"192.168.200.103"
],
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:kube-controller-manager",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager
#=======================================================================================================================
#创建kube-scheduler证书请求
cat > kube-scheduler-csr.json << EOF
{
"CN": "system:kube-scheduler",
"hosts": [
"127.0.0.1",
"192.168.200.101",
"192.168.200.102",
"192.168.200.103"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:kube-scheduler",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler
#=======================================================================================================================
#创建kube-proxy证书
cat > kube-proxy-csr.json <<EOF
{
"CN": "system:kube-proxy",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "4Paradigm"
}
]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
脚本说明：
=======================================================================================================================
ca-config.json：
可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；
signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
server auth：表示 client 可以用该 CA 对 server 提供的证书进行验证；
client auth：表示 server 可以用该 CA 对 client 提供的证书进行验证；
ca-csr.json：
CN：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)，浏览器使用该字段验证网站是否合法；
O：Organization，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；
kube-apiserver 将提取的 User、Group 作为 RBAC 授权的用户标识；
etcd-csr.json：
hosts 字段指定授权使用该证书的 etcd 节点 IP 或域名列表，这里将 etcd 集群的三个节点 IP 都列在其中
flanneld-csr.json：
该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；
admin-csr.json：
kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错，只需要部署一次，然后拷贝到其他的master。
O为system:masters，kube-apiserver 收到该证书后将请求的 Group 设置为 system:masters；
预定义的 ClusterRoleBinding cluster-admin 将 Group system:masters 与 Role cluster-admin 绑定，该 Role 授予所有 API的权限；
该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；
kubernetes-csr.json：
hosts字段指定授权使用该证书的IP或域名列表，这里列出了 VIP 、apiserver节点IP、kubernetes服务IP和域名；
域名最后字符不能是 .(如不能为kubernetes.default.svc.cluster.local.)，否则解析时失败，提示：x509: cannot parse dnsName "kubernetes.default.svc.cluster.local."；
如果使用非cluster.local域名，如bqding.com，则需要修改域名列表中的最后两个域名为：kubernetes.default.svc.bqding、kubernetes.default.svc.bqding.com
kube-controller-manager-csr.json：
集群包含3个kube-controller-manager节点，启动后将通过竞争选举机制产生一个leader节点，其它节点为阻塞状态。当leader节点不可用后，剩余节点将再次进行选举产生新的leader节点，从而保证服务的可用性。
为保证通信安全，kube-controller-manager在如下两种情况下使用该证书：1.与kube-apiserver的安全端口通信时;2.在安全端口(https，10252)输出prometheus格式的metrics
hosts列表包含所有kube-controller-manager节点IP；
CN为system:kube-controller-manager、O为system:kube-controller-manager，kubernetes内置的ClusterRoleBindings system:kube-controller-manager 赋予 kube-controller-manager 工作所需的权限。
kube-scheduler-csr.json：
集群包含3个kube-scheduler节点，启动后将通过竞争选举机制产生一个leader节点，其它节点为阻塞状态。当leader节点不可用后，剩余节点将再次进行选举产生新的 leader 节点，从而保证服务的可用性。
为保证通信安全，kube-scheduler在如下两种情况下使用该证书：1.与 kube-apiserver 的安全端口通信;2.在安全端口(https，10251)输出 prometheus 格式的 metrics；
hosts 列表包含所有 kube-scheduler 节点 IP；
CN 为 system:kube-scheduler、O 为 system:kube-scheduler，kubernetes 内置的 ClusterRoleBindings system:kube-scheduler 将赋予 kube-scheduler 工作所需的权限。
kube-proxy-csr.json：
CN：指定该证书的 User 为 system:kube-proxy；
预定义的 RoleBinding system:node-proxier 将User system:kube-proxy 与 Role system:node-proxier 绑定，该 Role 授予了调用 kube-apiserver Proxy 相关 API 的权限；
该证书只会被 kube-proxy 当做 client 证书使用，所以 hosts 字段为空；
==========================================================================================================================
执行脚本
sh certificate.sh
脚本执行成功会在/root/ssl生成一批证书
admin.csr etcd-key.pem kube-proxy-key.pem
admin-csr.json etcd.pem kube-proxy.pem
admin-key.pem flanneld.csr kubernetes.csr
admin.pem flanneld-csr.json kubernetes-csr.json
ca-config.json flanneld-key.pem kubernetes-key.pem
ca.csr flanneld.pem kubernetes.pem
ca-csr.json kube-controller-manager.csr kube-scheduler.csr
ca-key.pem kube-controller-manager-csr.json kube-scheduler-csr.json
ca.pem kube-controller-manager-key.pem kube-scheduler-key.pem
certificate.sh kube-controller-manager.pem kube-scheduler.pem
etcd.csr kube-proxy.csr
etcd-csr.json kube-proxy-csr.json
分别把证书拷贝到对应组件的服务器上,各组件所需证书：
etcd ca.pem，ca-key.pem，etcd-key.pem，etcd.pem
flannel ca.pem，ca-key.pem，flanneld-key.pem，flanneld.pem
kube-apiserver ca.pem，ca-key.pem，kubernetes-key.pem，kubernetes.pem
kube-controller-manager ca.pem，ca-key.pem，kube-controller-manager-key.pem，kube-controller-manager.pem
kube-scheduler ca.pem，ca-key.pem，kube-scheduler-key.pem，kube-scheduler.pem
kubelet ca.pem，ca-key.pem
kube-proxy ca.pem，ca-key.pem，kube-proxy.pem，kube-proxy-key.pem
kubectl ca.pem，ca-key.pem，admin.pem，admin-key.pem
本文档3台服务器各组件都存在，所以需要所有证书
mv ./*.pem /opt/kubernetes/ssl/
salt-cp "192.168.200.102 192.168.200.103" /opt/kubernetes/ssl/* /opt/kubernetes/ssl/
4.部署etcd集群(192.168.200.101/102/103)
创建kubernets目录：
mkdir -p /opt/kubernetes/{bin,cfg,ssl}
上传etcd源码包etcd-v3.3.10-linux-amd64.tar.gz
tar xf etcd-v3.3.10-linux-amd64.tar.gz
cd etcd-v3.3.10-linux-amd64.tar.gz
移动etcd命令到kubernets工作目录bin下
cp etcd etcdctl /opt/kubernetes/bin/
使用脚本生成配置文件并启动：cat etcd.sh
#!/bin/bash
ETCD_NAME=${1:-"etcd01"}
ETCD_IP=${2:-"127.0.0.1"}
ETCD_CLUSTER=${3:-"etcd01=http://127.0.0.1:2379"}
cat <<EOF >/opt/kubernetes/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="${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=-/opt/kubernetes/cfg/etcd
ExecStart=/opt/kubernetes/bin/etcd \\
--name=\${ETCD_NAME} \\
--data-dir=\${ETCD_DATA_DIR} \\
--listen-peer-urls=\${ETCD_LISTEN_PEER_URLS} \\
--listen-client-urls=\${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \\
--advertise-client-urls=\${ETCD_ADVERTISE_CLIENT_URLS} \\
--initial-advertise-peer-urls=\${ETCD_INITIAL_ADVERTISE_PEER_URLS} \\
--initial-cluster=\${ETCD_INITIAL_CLUSTER} \\
--initial-cluster-token=\${ETCD_INITIAL_CLUSTER_TOKEN} \\
--initial-cluster-state=new \\
--cert-file=/opt/kubernetes/ssl/etcd.pem \\
--key-file=/opt/kubernetes/ssl/etcd-key.pem \\
--peer-cert-file=/opt/kubernetes/ssl/etcd.pem \\
--peer-key-file=/opt/kubernetes/ssl/etcd-key.pem \\
--trusted-ca-file=/opt/kubernetes/ssl/ca.pem \\
--peer-trusted-ca-file=/opt/kubernetes/ssl/ca.pem
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd
#分别在三台上启动etcd
chmod +x etcd.sh
./etcd.sh etcd01 192.168.200.101 etcd01=https://192.168.200.101:2380,etcd02=https://192.168.200.102:2380,etcd03=https://192.168.200.103:2380
./etcd.sh etcd02 192.168.200.102 etcd01=https://192.168.200.101:2380,etcd02=https://192.168.200.102:2380,etcd03=https://192.168.200.103:2380
./etcd.sh etcd03 192.168.200.103 etcd01=https://192.168.200.101:2380,etcd02=https://192.168.200.102:2380,etcd03=https://192.168.200.103:2380
#检测etcd集群状态
/opt/kubernetes/bin/etcdctl --ca-file=/opt/kubernetes/ssl/ca.pem --cert-file=/opt/kubernetes/ssl/etcd.pem --key-file=/opt/kubernetes/ssl/etcd-key.pem cluster-health
5.部署flanneld集群(192.168.200.101/102/103)
#说明
Overlay Network：覆盖网络，在基础网络上叠加的一种虚拟网络技术模式，该网络中的主机通过虚拟链路连接起来。
VXLAN ：将源数据包封装到UDP中，并使用基础网络的IP/MAC作为外层报文头进行封装，然后在以太网上传输，到达目的地后由隧道端点解封装并将数据发送给目标地址。
Flannel ：是Overlay网络的一种，也是将源数据包封装在另一种网络包里面进行路由转发和通信，目前已经支持UDP、VXLAN、AWS VPC和GCE路由等数据转发方式。
多主机容器网络通信其他主流方案：隧道方案（ Weave、OpenvSwitch ），路由方案（Calico）等。
#写入分配的子网段到 etcd ，供 flanneld 使用(只在一台上操作即可)
/opt/kubernetes/bin/etcdctl --ca-file=/opt/kubernetes/ssl/ca.pem --cert-file=/opt/kubernetes/ssl/etcd.pem --key-file=/opt/kubernetes/ssl/etcd-key.pem --endpoints="https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379" set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'
#解压二进制包
# wget https://github.com/coreos/flannel/releases/download/v0.10.0/flannel-v0.10.0-linux-amd64.tar.gz
tar xf flannel-v0.10.0-linux-amd64.tar.gz
mv flanneld mk-docker-opts.sh /opt/kubernetes/bin/
#配置 Flannel/systemd管理
#使用脚本配置cat flanneld.sh
#!/bin/bash
ETCD_ENDPOINTS=${1:-"http://127.0.0.1:2379"}
cat <<EOF >/opt/kubernetes/cfg/flanneld
FLANNEL_OPTIONS="--etcd-endpoints=${ETCD_ENDPOINTS} \
-etcd-cafile=/opt/kubernetes/ssl/ca.pem \
-etcd-certfile=/opt/kubernetes/ssl/flanneld.pem \
-etcd-keyfile=/opt/kubernetes/ssl/flanneld-key.pem"
EOF
cat <<EOF >/usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service
[Service]
Type=notify
EnvironmentFile=/opt/kubernetes/cfg/flanneld
ExecStart=/opt/kubernetes/bin/flanneld --ip-masq \$FLANNEL_OPTIONS
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
cat <<EOF >/usr/lib/systemd/system/docker.service
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd \$DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP \$MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable flanneld
systemctl restart flanneld
systemctl restart docker
#说明：
mk-docker-opts.sh 脚本将分配给flanneld的Pod子网网段信息写入到 /run/flannel/docker文件中，后续docker启动时使用这个文件中参数值设置 docker0网桥。
flanneld 使用系统缺省路由所在的接口和其它节点通信，对于有多个网络接口的机器（如，内网和公网），可以用-iface=enpxx 选项值指定通信接口。
/run/flannel/subnet.env 是flannel分配给docker的子网信息
#启动flannel(三台启动命令相同)
./flanneld.sh https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379
#验证网络
/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 --endpoints="https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379" ls /coreos.com/network/subnets
6、创建Node节点的配置文件
在master节点证书临时目录/root/ssl下使用以下脚本，创建node节点所需配置文件：
cat kubeconfig.sh
# 创建 TLS Bootstrapping Token
export BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
cat > token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF
#----------------------
# 创建kubelet bootstrapping kubeconfig
export KUBE_APISERVER="https://192.168.200.101:6443"
# 设置集群参数
kubectl config set-cluster kubernetes \
--certificate-authority=./ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=bootstrap.kubeconfig
# 设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap \
--token=${BOOTSTRAP_TOKEN} \
--kubeconfig=bootstrap.kubeconfig
# 设置上下文参数
kubectl config set-context default \
--cluster=kubernetes \
--user=kubelet-bootstrap \
--kubeconfig=bootstrap.kubeconfig
# 设置默认上下文
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
#----------------------
# 创建kube-proxy kubeconfig文件
kubectl config set-cluster kubernetes \
--certificate-authority=./ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig
kubectl config set-credentials kube-proxy \
--client-certificate=./kube-proxy.pem \
--client-key=./kube-proxy-key.pem \
--embed-certs=true \
--kubeconfig=kube-proxy.kubeconfig
kubectl config set-context default \
--cluster=kubernetes \
--user=kube-proxy \
--kubeconfig=kube-proxy.kubeconfig
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
注意：执行此脚本时必须存在kubectl命令，上传kubectl二进制文件到/usr/bin
chmod +x kubeconfig.sh
./kubeconfig.sh
生成node节点所需配置文件如下：
token.csv //kubelet与kube-api通信使用
bootstrap.kubeconfig //用来生成kubelet配置文件
kube-proxy.kubeconfig //kube-proxy配置文件
分发node配置文件至node节点：
salt-cp "192.168.200.101 192.168.200.102 192.168.200.103" ./*.kubeconfig /opt/kubernetes/cfg/
7.部署master组件
#下载k8s二进制包
https://github.com/kubernetes/kubernetes/
移动二进制文件到工作目录bin下：
salt-cp "192.168.200.101 192.168.200.102 192.168.200.103" kubectl kube-apiserver kube-controller-manager kube-scheduler /opt/kubernetes/bin/
移动token认证信息到配置目录下：
salt-cp "192.168.200.101 192.168.200.102 192.168.200.103" /root/ssl/token.csv /opt/kubernetes/cfg/
#使用以下脚本apiserver.sh、scheduler.sh、controller-manager.sh在三台master上分别部署kube-apiserver/kube-scheduler/kube-controller-manager：
#部署kube-apiserver：cat apiserver.sh
#!/bin/bash
MASTER_ADDRESS=${1:-"192.168.200.101"}
ETCD_SERVERS=${2:-"http://192.168.200.101:2379"}
cat <<EOF >/opt/kubernetes/cfg/kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \\
--v=4 \\
--etcd-servers=${ETCD_SERVERS} \\
--insecure-bind-address=127.0.0.1 \\
--bind-address=${MASTER_ADDRESS} \\
--insecure-port=8080 \\
--secure-port=6443 \\
--advertise-address=${MASTER_ADDRESS} \\
--allow-privileged=true \\
--service-cluster-ip-range=10.10.10.0/24 \\
--admission-control=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \\
--authorization-mode=RBAC,Node \\
--kubelet-https=true \\
--enable-bootstrap-token-auth \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--tls-cert-file=/opt/kubernetes/ssl/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"
EOF
cat <<EOF >/usr/lib/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver
# 配置文件参数说明：
--experimental-encryption-provider-config：启用加密特性；
--authorization-mode=Node,RBAC： 开启 Node 和 RBAC 授权模式，拒绝未授权的请求；
--enable-admission-plugins：启用 ServiceAccount 和 NodeRestriction；
--service-account-key-file：签名 ServiceAccount Token 的公钥文件，kube-controller-manager 的 --service-account-private-key-file：指定私钥文件，两者配对使用；
--tls-*-file：指定apiserver使用的证书、私钥和 CA 文件。
--client-ca-file：用于验证 client (kue-controller-manager、kube-scheduler、kubelet、kube-proxy 等)请求所带的证书；
--kubelet-client-certificate、--kubelet-client-key：如果指定，则使用https访问kubelet APIs；需要为证书对应的用户(上面kubernetes*.pem证书的用户为kubernetes) 用户定义 RBAC 规则，否则访问 kubelet API 时提示未授权；
--bind-address： 不能为 127.0.0.1，否则外界不能访问它的安全端口6443；
--insecure-port=0：关闭监听非安全端口(8080)；
--service-cluster-ip-range： 指定Service Cluster IP地址段；
--service-node-port-range： 指定NodePort的端口范围；
--runtime-config=api/all=true： 启用所有版本的 APIs，如 autoscaling/v2alpha1；
--enable-bootstrap-token-auth：启用 kubelet bootstrap 的 token 认证；
--apiserver-count=3：指定集群运行模式，多台 kube-apiserver 会通过 leader 选举产生一个工作节点，其它节点处于阻塞状态；
#部署kube-controller-manager
#查看controller-manager.sh：cat controller-manager.sh
#!/bin/bash
MASTER_ADDRESS=${1:-"127.0.0.1"}
cat <<EOF >/opt/kubernetes/cfg/kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect=true \\
--address=127.0.0.1 \\
--service-cluster-ip-range=10.10.10.0/24 \\
--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"
EOF
cat <<EOF >/usr/lib/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager
# 配置文件参数说明：
--address：指定监听的地址为127.0.0.1
--kubeconfig：指定 kubeconfig 文件路径，kube-controller-manager 使用它连接和验证 kube-apiserver；
--cluster-signing-*-file：签名 TLS Bootstrap 创建的证书；
--experimental-cluster-signing-duration：指定 TLS Bootstrap 证书的有效期；
--root-ca-file：放置到容器 ServiceAccount 中的 CA 证书，用来对 kube-apiserver 的证书进行校验；
--service-account-private-key-file：签名 ServiceAccount 中 Token 的私钥文件，必须和 kube-apiserver 的 --service-account-key-file 指定的公钥文件配对使用；
--service-cluster-ip-range ：指定 Service Cluster IP 网段，必须和 kube-apiserver 中的同名参数一致；
--leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；
--feature-gates=RotateKubeletServerCertificate=true：开启 kublet server 证书的自动更新特性；
--controllers=*,bootstrapsigner,tokencleaner：启用的控制器列表，tokencleaner 用于自动清理过期的 Bootstrap token；
--horizontal-pod-autoscaler-*：custom metrics 相关参数，支持 autoscaling/v2alpha1；
--tls-cert-file、--tls-private-key-file：使用 https 输出 metrics 时使用的 Server 证书和秘钥；
--use-service-account-credentials=true:
#部署kube-scheduler
#查看scheduler.sh：cat scheduler.sh
#!/bin/bash
MASTER_ADDRESS=${1:-"127.0.0.1"}
cat <<EOF >/opt/kubernetes/cfg/kube-scheduler
KUBE_SCHEDULER_OPTS="--logtostderr=true \\
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\
--leader-elect"
EOF
cat <<EOF >/usr/lib/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler
启动组件：
3台分别启动apiserver
./apiserver.sh 192.168.200.101 https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379
./scheduler.sh
./controller-manager.sh
./apiserver.sh 192.168.200.102 https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379
./scheduler.sh
./controller-manager.sh
./apiserver.sh 192.168.200.103 https://192.168.200.101:2379,https://192.168.200.102:2379,https://192.168.200.103:2379
./scheduler.sh
./controller-manager.sh
查看组件启动状态：
kubectl get cs
8.部署node组件
mv kubelet kube-proxy /opt/kubernetes/bin/
chmod +x /opt/kubernetes/bin/*
在node节点使用脚本启动kubelet：
cat kubelet.sh
#!/bin/bash
NODE_ADDRESS=${1:-"192.168.200.102"}
DNS_SERVER_IP=${2:-"10.10.10.2"}
cat <<EOF >/opt/kubernetes/cfg/kubelet
KUBELET_OPTS="--logtostderr=true \\
--v=4 \\
--address=${NODE_ADDRESS} \\
--hostname-override=${NODE_ADDRESS} \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--experimental-bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--cert-dir=/opt/kubernetes/ssl \\
--allow-privileged=true \\
--cluster-dns=${DNS_SERVER_IP} \\
--cluster-domain=cluster.local \\
--fail-swap-on=false \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF
cat <<EOF >/usr/lib/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet
启动前需要在master执行命令创建kubelet-bootstrap用户：
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
否则启动会报错：kubelet: error: failed to run Kubelet: cannot create certificate signing request: certificatesigningrequests.certificates.k8s.io is forbidden: User "kubelet-bootstrap" cannot create certificatesigningrequests.certificates.k8s.io at the cluster scope
原因是：kubelet-bootstrap并没有权限创建证书。所以要创建这个用户的权限并绑定到这个角色上。
在node01启动：
./kubelet.sh 192.168.200.101
在node02启动：
./kubelet.sh 192.168.200.102
在node03启动：
./kubelet.sh 192.168.200.103
在master节点查看认证状态：
kubectl get csr
显示为等待签名认证状态
NAME AGE REQUESTOR CONDITION
node-csr-QmkBSqwpZJnC5CJyowdOwYi_SvD2Q5h_e9l-axZRf3s 27s kubelet-bootstrap Pending
node-csr-piPDu1XYXFMdWSKyucooft7bc-L5dfvgCiKjigjXgKI 5m kubelet-bootstrap Pending
node-csr-uhPEX9cxes5aTt2Ajkjt2Imhl2KgeAh12iLCFjTAisM 21s kubelet-bootstrap Pending
master进行签名认证：
kubectl certificate approve node-csr-QmkBSqwpZJnC5CJyowdOwYi_SvD2Q5h_e9l-axZRf3s
kubectl certificate approve node-csr-piPDu1XYXFMdWSKyucooft7bc-L5dfvgCiKjigjXgKI
kubectl certificate approve node-csr-uhPEX9cxes5aTt2Ajkjt2Imhl2KgeAh12iLCFjTAisM
再次查看：
kubectl get csr
显示为签发状态
NAME AGE REQUESTOR CONDITION
node-csr-QmkBSqwpZJnC5CJyowdOwYi_SvD2Q5h_e9l-axZRf3s 5m kubelet-bootstrap Approved,Issued
node-csr-piPDu1XYXFMdWSKyucooft7bc-L5dfvgCiKjigjXgKI 10m kubelet-bootstrap Approved,Issued
node-csr-uhPEX9cxes5aTt2Ajkjt2Imhl2KgeAh12iLCFjTAisM 3m11s kubelet-bootstrap Approved,Issued
kubectl get node
显示node节点已准备就绪
NAME STATUS ROLES AGE VERSION
192.168.200.101 Ready <none> 1m v1.12.7
192.168.200.102 Ready <none> 1m v1.12.7
192.168.200.103 Ready <none> 2m v1.12.7
使用脚本在node节点启动kube-proxy
cat proxy.sh
#!/bin/bash
NODE_ADDRESS=${1:-"192.168.200.101"}
cat <<EOF >/opt/kubernetes/cfg/kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=${NODE_ADDRESS} \
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF
cat <<EOF >/usr/lib/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Proxy
After=network.target
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy
启动kube-proxy:
在node1启动：
./proxy.sh 192.168.200.101
在nodo2启动：
./proxy.sh 192.168.200.102
在nodo3启动：
./proxy.sh 192.168.200.103
9.使用salt安装keepalived、haproxy
salt-ha.tar.gz文件目录结构如下：
└── haproxy //执行目录
├── change_haproxy.sh //执行命令脚本
├── files //keepalived、haproxy配置文件目录
├── haproxy.init //haproxy启动脚本
├── haproxy-outside.cfg //haproxy配置文件
├── haproxy.service //添加haproxy系统服务文件
├── keepalived.init //keepalived启动脚本
├── keepalived.sysconfig //keepalived配置文件
├── limits.conf //系统参数配置文件
├── master-keepalived.conf //keepalived主master配置文件
├── notify.sh //keepalived检测haproxy存活脚本
├── rsyslog //keepalived日志配置
├── rsyslog.conf //keepalived日志配置
├── slave-keepalived.conf //keepalived备backup配置文件
└── sysctl.conf //系统参数配置文件
├── haproxy-outside-install.sls //安装haproxy的sls文件(会调用 keepalived-install.sls 、pkg.sls文件，安装keepalived)
├── keepalived-install.sls //安装keepalived的sls文件
├── pkg.sls //安装依赖包的sls文件
└── soft //源码包存放目录
├── haproxy-1.8.19.tar.gz
└── keepalived-2.0.4.tar.gz
注意：在keepalived-install.sls中修改主从的主机名、VIP，并确定ROUTEID没有冲突。在haproxy-outside.cfg中修改端口、后端ip
sh change_haproxy.sh
10.修改node节点的组件kubelet、kube-proxy配置文件指向VIP地址:端口
首先配置Kubectl管理工具,kubectl 是 kubernetes 集群的命令行管理工具，用于远程管理集群服务，kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错。 ~/.kube/config只需要部署一次，然后拷贝到其他的master
#上面已经创建了kubectl的证书(admin.pem/admin-key.pem) ,并且已经把kubectl二进制包拷贝到了/usr/local/bin下
#执行以下命令创建~/.kube/config文件：
# 设置集群项中名为kubernetes的apiserver地址与根证书
kubectl config set-cluster kubernetes --server=https://192.168.200.200:8443 --certificate-authority=/opt/kubernetes/ssl/ca.pem
# 设置用户项中cluster-admin用户证书认证字段
kubectl config set-credentials cluster-admin --certificate-authority=/opt/kubernetes/ssl/ca.pem --client-key=/opt/kubernetes/ssl/admin-key.pem --client-certificate=/opt/kubernetes/ssl/admin.pem
# 设置环境项中名为default的默认集群和用户
kubectl config set-context default --cluster=kubernetes --user=cluster-admin
# 设置默认环境项为default
kubectl config use-context default
注意：server地址为集群的VIP地址
修改/opt/kubernetes/cfg/目录下的：bootstrap.kubeconfig、kubelet.kubeconfig、kube-proxy.kubeconfig
server: https://192.168.200.200:8443
11.部署Web UI (Dashboard)
使用kubernets模板文件dashboard-rbac.yaml、dashboard-deployment.yaml、dashboard-service.yaml：
# kubectl create -f dashboard-rbac.yaml
# kubectl create -f dashboard-deployment.yaml
# kubectl create -f dashboard-service.yamlk8s高可用集群部署
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章