一、准备

环境准备

节点名称	地址	组件
Master01	192.168.10.15/24	kube-apiserver kube-controller-manager kube-scheduler etcd
node01	192.168.10.16/24	kubelet kube-proxy docker flannel etcd
node02	192.168.10.17/24	kubelet kube-proxy docker flannel etcd

systemctl stop firewalld
systemctl disable firewalld
setenforce 0

hostnamectl set-hostname master01
su

二、部署etcd集群

• etcd是coreos团队于2013年6月发起的开源项目，它的目标是构建一个高可用的分布式键值（key-value)数据库，etcd内部采用raft协议作为一致性算法,etcd是go语言编写的。
• etcd 作为服务发现系统,有以下的特点:
  • 简单:安装配置简单，而且提供了HTTPAPI进行交互，使用也很简单
  • 安全:支持ssL证书验证
  • 快速:单实例支持每秒2k+读操作
  • 可靠:采用raft算法，实现分布式系统数据的可用性和一致性
• etcd 目前默认使用2379端口提供HTTP
• API服务，2380端口和peer通信(这两个端口已经被IANA(互联网数字分配机构)官方预留给etcd)。即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。
• etcd 在生产环境中一般推荐集群方式部署。由于etcd 的leader选举机制，要求至少为3台或以上的奇数台。

准备签发证书环境

• CFSSL是 Cloudlare公司开源的一款、 PKI/TLS 工具。CPSSL包含一个命令行工具和一个用于签名、验证和捆绑"TLS 证书的 HTTP API 服务。使用Go语言编写。
• CFSSI使用配置文件生成证书，因此自签之前，需要生成它识别的json 格式的配置文件，CFSSL提供了方便的命令行生成配置文件。CFSSL用来为etcd提供TLs 证书，它支持签三种类型的证书:
  • 1、client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如 kube-apiserver访问etcd;
  • 2、server 证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如 etcd对外提供服务;
  • 3、peer 证书，相互之间连接时使用的证书，如 etcd 节点之间进行验证和通信。

这里全部都使用同一套证书认证。

1、master节点

#创建/k8s目录
mkdir k8s
cd k8s

#创建证书制作的脚本
vim etcd-cert.sh 
cat > ca-config.json <<EOF			#CA证书配置文件
{
  "signing": {					#键名称
    "default": {
      "expiry": "87600h"			#证书有效期（10年）
    },
    "profiles": {				#简介
      "www": {					#名称
         "expiry": "87600h",
         "usages": [				#使用方法
            "signing",				#键
            "key encipherment",			#密钥验证（密钥验证要设置在CA证书中）
            "server auth",			#服务器端验证
            "client auth"			#客户端验证
        ]
      }
    }
  }
}
EOF
cat > ca-csr.json <<EOF				#CA签名
{
    "CN": "etcd CA",				#CA签名为etcd指定（三个节点均需要）
    "key": {
        "algo": "rsa",				#使用rsa非对称密钥的形式
        "size": 2048				#密钥长度为2048
    },
    "names": [					#在证书中定义信息（标准格式）
        {
            "C": "CN",				#名称
            "L": "Beijing",		
            "ST": "Beijing"		
        }
    ]
}
EOF
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
cat > server-csr.json <<EOF			#服务器端的签名
{
    "CN": "etcd",
    "hosts": [					#定义三个节点的IP地址
    "192.168.10.15",
    "192.168.10.16",
    "192.168.10.17"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server     #cfssl 为证书制作工具

#创建启动脚本
cat etcd.sh 
#!/bin/bash
#以下为使用格式：etcd名称 当前etcd的IP地址+完整的集群名称和地址
# 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						#位置变量1：etcd节点名称
ETCD_IP=$2						#位置变量2：节点地址
ETCD_CLUSTER=$3						#位置变量3：集群
WORK_DIR=/opt/etcd					#指定工作目录
cat <<EOF >$WORK_DIR/cfg/etcd				#在指定工作目录创建ETCD的配置文件
#[Member]
ETCD_NAME="${ETCD_NAME}"				#etcd名称
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"		#etcd IP地址：2380端口。用于集群之间通讯
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"	#etcd IP地址：2379端口，用于开放给外部客户端通讯
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"	#对外提供的url使用https的协议进行访问
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"		#多路访问
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"		#tokens 令牌环名称：etcd-cluster
ETCD_INITIAL_CLUSTER_STATE="new"			#状态，重新创建
EOF
cat <<EOF >/usr/lib/systemd/system/etcd.service		#定义ectd的启动脚本
[Unit]								#基本项			
Description=Etcd Server					#类似为 etcd 服务
After=network.target					#vu癌症
After=network-online.target
Wants=network-online.target
[Service]						#服务项
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd	#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

#创建证书目录，复制k8s目录下的证书创建脚本
mkdir etcd-cert
cd etcd-cert/
mv ../etcd-cert.sh ./

#从官网源中下载制作证书的工具
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

#执行证书制作脚本(etcd-cert目录下)
chmod +x /usr/local/bin/cfssl
chmod +x /usr/local/bin/cfssl-certinfo
chmod +x /usr/local/bin/cfssljson
bash etcd-cert.sh

#ETCD 部署
(下载并将软件包放在k8s目录下:etcd-v3.3.10-linux-amd64.tar.gz、flannel-v0.10.0-linux-amd64.tar.gz、kubernetes-server-linux-amd64.tar.gz)

#解压etcd-v3.3.10-linux-amd64.tar.gz
cd /etcd
tar zxvf etcd-v3.3.10-linux-amd64.tar.gz

#创建ETCD工作目录(cfg：配置文件目录、bin：命令文件目录、ssl：证书文件目录)
mkdir /opt/etcd/{cfg,bin,ssl} -p

#拷贝命令文件
mv etcd-v3.3.10-linux-amd64/etcd etcd-v3.3.10-linux-amd64/etcdctl /opt/etcd/bin

#拷贝证书文件
cp etcd-cert/*.pem /opt/etcd/ssl

#进入卡住状态等待其他节点加入
bash etcd.sh etcd01 192.168.10.15 etcd02=https://192.168.10.16:2380,etcd03=https://192.168.10.17:2380

#另起终端，查看产生的配置文件
#查看etcd 状态/进程
ps -ef | grep etcd

#将证书和启动脚本推送/复制到两台node节点中
scp -r /opt/etcd/ root@192.168.10.16:/opt
scp -r /opt/etcd/ root@192.168.10.17:/opt
scp -r /usr/lib/systemd/system/etcd.service root@192.168.10.16:/usr/lib/systemd/system/
scp -r /usr/lib/systemd/system/etcd.service root@192.168.10.17:/usr/lib/systemd/system/

2、node节点

#查看、修改配置文件
ls /usr/lib/systemd/system/ | grep etcd
vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"					#需修改节点名称
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.10.16:2380"	#将url：2380端口的IP地址改为16（本地节点IP）
ETCD_LISTEN_CLIENT_URLS="https://192.168.10.16:2379"		#将url：2379端口的IP地址改为16（本地节点IP）
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.10.16:2380"	
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.10.16:2379"
#以上两条选项的地址也改为本地IP
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.10.15:2380,etcd02=https://192.168.10.16:2380,etcd03=https://192.168.10.17:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
#同理修改node2节点配置文件

#启动服务(先在master节点使用命令，开启等待节点加入,其他两个node节点启动etcd 服务)
[root@k8s-master ~/k8s]# bash etcd.sh etcd01 192.168.10.15 etcd02=https://192.168.10.16:2380,etcd03=https://192.168.10.17:2380
[root@k8s-node01 /opt/etcd/cfg]# systemctl start etcd 
[root@k8s-node02 /opt/etcd/cfg]# systemctl start etcd 

#检查集群状态(master上执行)
[root@k8s-master ~/k8s]# cd etcd-cert/
[root@k8s-master ~/k8s/etcd-cert]# /opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://192.168.10.15:2379,https://192.168.10.16:2379,https://192.168.10.17:2379" cluster-health

三、Flannel网络部署

• 首先两个node节点需要先安装docker引擎

#写入分配的子网段到ETCD中，供flannel使用(master主机)
/opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://192.168.10.15:2379,https://192.168.10.16:2379,https://192.168.10.17:2379" set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'
#命令简介--------------------------------------------------
#使用etcdctl命令，借助ca证书，目标断点为三个ETCD节点IP，端口为2379
#set /coreos.com/network/config 设置网段信息
#"Network": "172.17.0.0/16" 此网段必须是集合网段（B类地址），而Pod分配的资源必须在此网段中的子网段（C类地址）
#"Backend": {"Type": "vxlan"}} 外部通讯的类型是VXLAN
----------------------------------------------------------

#查看写入的信息(master主机)
/opt/etcd/bin/etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://192.168.10.15:2379,https://192.168.10.16:2379,https://192.168.10.17:2379" get /coreos.com/network/config

#上传flannel软件包到所有的 node 节点并解压(所有node节点)
tar zxvf flannel-v0.10.0-linux-amd64.tar.gz 

#创建k8s工作目录(所有node节点)
mkdir /opt/kubernetes/{cfg,bin,ssl} -p
mv mk-docker-opts.sh flanneld /opt/kubernetes/bin/

#创建启动脚本（两个node节点)
vim flannel.sh
#!/bin/bash
ETCD_ENDPOINTS=${1:-"http://127.0.0.1:2379"}
cat <<EOF >/opt/kubernetes/cfg/flanneld 		#创建配置文件
FLANNEL_OPTIONS="--etcd-endpoints=${ETCD_ENDPOINTS} \	#flannel在使用的时候需要参照CA证书
-etcd-cafile=/opt/etcd/ssl/ca.pem \
-etcd-certfile=/opt/etcd/ssl/server.pem \
-etcd-keyfile=/opt/etcd/ssl/server-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	#Docker使用的网络是flannel提供的
Restart=on-failure
[Install]
WantedBy=multi-user.target				#多用户模式
EOF
systemctl daemon-reload
systemctl enable flanneld
systemctl restart flanneld

#开启flannel网络功能（两个node节点）
bash flannel.sh https://192.168.10.15:2379,https://192.168.10.16:2379,https://192.168.10.17:2379

#配置 docker 连接 flannel(两个node节点)
vim /usr/lib/systemd/system/docker.service
-----12行添加
EnvironmentFile=/run/flannel/subnet.env 
-----13行修改(添加参数$DOCKER_NETWORK_OPTIONS)
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS -H fd:// --containerd=/run/containerd/containerd.sock

#查看flannel分配的子网段
cat /run/flannel/subnet.env 

#重载进程、重启docker
systemctl daemon-reload 
systemctl restart docker

测试一下
ping -I 172.17.3.1 172.17.82.1

四、单master节点部署

bootstrap

• kubelet 采用TLS Bootstrapping 机制，自动完成到kube-apiserver 的注册，在node节点量较大或者后期自动扩容时非常有用。Master apiserver 启用TLS 认证后，node节点 kubelet组件想要加入集群，必须使用ca签发的有效证书才能与 apiserver通信，当node节点很多时，签署证书是一件很繁琐的事情。因此Kubernetes引入了TIS bootstraping 机制来自动颁发客户端证书，kubelet会以一个低权限用户自动向 apiserver申请证书，kubelet 的证书由 apiserver动态签署。
• kubelet首次启动通过加载bootstrap.kubeconfig 中的用户Token和 apiserver CA 证书发起首次 CSR 请求，这个Token
• 被预先内置在 apiserver 节点的 token.csv中，其身份为 kubelet-bootstrap用户和 system: kubelet-bootstrap 用户组:想要首次CSR 请求能成功（即不会被 apiserver 401拒绝)，则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap用户和
• system:node-bootstrapper 内置、ClusterRole绑定（通过 kubectl get clusterroles可查询)，使其能够发起CSR认证请求。
• TLS bootstrapping时的证书实际是由 kube-controller-manager组件来签署的，也就是说证书有效期是 kube-controller-manager组件控制的;kube-controller-manager组件提供了一个–experimental-cluster-signing-duration

参数来设置签署的证书有效时间:默认为 8760h0om0s，将其改为87600h0mOs，即 10°年后再进行"TLS bootstrapping 签署证书即可。
也就是说kubelet首次访问 API Server 时，是使用token做认证，通过后，Controller Manager 会为 kubelet
生成一个证书，以后的访问都是用证书做认证了。

1、部署master组件

#创建k8s工作目录和apiserver的证书目录
cd ~/k8s
mkdir /opt/kubernetes/{cfg,bin,ssl} -p
mkdir k8s-cert

#生成证书
cd k8s-cert
vim k8s-cert.sh
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.10.15",			#master1节点
      "192.168.10.145",			#master2节点(为之后做多节点做准备)
      "192.168.10.200",			#VIP飘逸地址
      "192.168.10.146",			#nginx1负载均衡地址(主)
      "192.168.10.147",			#nginx2负载均衡地址（备）
      "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"
        }
    ]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
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

#直接执行脚本生成K8S的证书
bash k8s-cert.sh

#此时查看本地目录的证书文件，应该有8个
ls *.pem

#把ca server端的证书复制到k8s工作目录
cp ca*.pem server*.pem /opt/kubernetes/ssl
ls /opt/kubernetes/ssl/

#解压kubernetes压缩包
cd ../
tar zxvf kubernetes-server-linux-amd64.tar.gz

#复制关键命令到k8s的工作目录中
cd kubernetes/server/bin
cp kube-controller-manager kubectl kube-apiserver kube-scheduler /opt/kubernetes/bin

#使用head -c 16 /dev/urandom | od -An -t x | tr -d ’ '，随机生成序列号 生成随机序列号
head -c 16 /dev/urandom | od -An -t x | tr -d ' '

#创建token（令牌）文件
cd /opt/kubernetes/cfg
vim token.csv
上一步随机序列号,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
------------------------------
此角色的定位和作用如下：
① 创建位置：在master节点创建bootstrap角色
② 管理node节点的kubelet
③ kubelet-bootstrap 管理、授权system：kubelet-bootstrap
④ 而system：kubelet-bootstrap 则管理node节点的kubelet
⑤ token就是授权给system：kubelet-bootstrap角色，如果此角色没有token的授权，则不能管理node下的kubelet
------------------------------

#二进制文件，token，证书准备齐全后，开启apiserver
上传master.zip
cd /root/k8s
unzip master.zip 
chmod +x controller-manager.sh

apiserver.sh 脚本简介-------------------------------------
#!/bin/bash

MASTER_ADDRESS=$1					#本地地址
ETCD_SERVERS=$2						#群集

cat <<EOF >/opt/kubernetes/cfg/kube-apiserver		#生成配置文件到k8s工作目录

KUBE_APISERVER_OPTS="--logtostderr=true \\			#从ETCD读取、存入数据
--v=4 \\
--etcd-servers=${ETCD_SERVERS} \\
--bind-address=${MASTER_ADDRESS} \\					#绑定地址
--secure-port=6443 \\
--advertise-address=${MASTER_ADDRESS} \\			#master本地地址
--allow-privileged=true \\							#允许授权
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\				#plugin插件，包括命名空间中的插件、server端的授权
--authorization-mode=RBAC,Node \\					#使用RBAC模式验证node端
--kubelet-https=true \\								#允许对方使用https协议进行访问
--enable-bootstrap-token-auth \\					#开启bootstrap令牌授权
--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"
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
---------------------------------------------------------

#开启apiserver
bash apiserver.sh 192.168.10.15 https://192.168.10.15:2379,https://192.168.10.16:2379,https://192.168.10.17:2379

#查看api进程验证启动状态
ps aux | grep kube

#查看配置文件是否正常
cat /opt/kubernetes/cfg/kube-apiserver

#查看进行端口是否开启
netstat -natp | grep 6443

#查看scheduler启动脚本
vim scheduler.sh 
#!/bin/bash
MASTER_ADDRESS=$1
cat <<EOF >/opt/kubernetes/cfg/kube-scheduler
KUBE_SCHEDULER_OPTS="--logtostderr=true \\  #定义日志记录
--v=4 \\
--master=${MASTER_ADDRESS}:8080 \\			#定义master地址，指向8080端口
--leader-elect"						#定位为leader
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

#启动scheduler服务
./scheduler.sh 127.0.0.1

#查看进程
ps aux | grep sch

#查看服务
systemctl status kube-scheduler.service

#启动controller-manager服务
./controller-manager.sh 

#查看服务
systemctl status kube-controller-manager.service 

#最后查看master节点状态
/opt/kubernetes/bin/kubectl get cs

#把master节点的kubelet、kube-proxy拷贝到node节点
cd kubernetes/server/bin/
scp kubelet kube-proxy root@192.168.10.16:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.10.17:/opt/kubernetes/bin/

#进行kube配置
cd ~/k8s
mkdir kubeconfig
cd kubeconfig
（上传kubeconfig.sh脚本）
mv kubeconfig.sh kubeconfig
vim kubeconfig
BOOTSTRAP_TOKEN=b0bff10cbd37dae1351103ad3458685
cat > token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF
APISERVER=$1
SSL_DIR=$2
# 创建kubelet bootstrapping kubeconfig 
export KUBE_APISERVER="https://$APISERVER:6443"
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig
# 设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap \
  --token=664f2017059d58e78f6cce2e47ef383b \		#仅修改此处令牌序列号，从/opt/kubernetes/cfg/token.csv中获取
  --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=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig
kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/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

#设置环境变量
export PATH=$PATH:/opt/kubernetes/bin/

#使用kubectl命令
kubectl get cs

#执行kubeconfig脚本
bash kubeconfig 192.168.10.15 /root/k8s/k8s-cert/

#拷贝生成的两个配置文件拷贝到node节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.10.16:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.10.17:/opt/kubernetes/cfg/

#创建bootstrap角色赋予权限用于连接apiserver请求签名
（只有bootstrap授权之后，node节点才算完整的添加到群集、可以被master节点所管理）
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

2、node节点部署

①、node1节点

#上传node压缩包并解压
unzip node.zip

#执行kubelet脚本，用于请求连接master主机
bash kubelet.sh 192.168.184.141

##查看kubelet进程
ps aux | grep kubelet

#查看服务状态
systemctl status kubelet.service

#在master上检查node1节点的请求（master上操作）
kubectl get csr

#颁发证书（master上操作）
kubectl certificate approve 节点1的名称

#再次查看csr（master上操作）
kubectl get csr

#查看集群节点（master上操作）
kubectl get node

#在node1节点启动proxy代理服务
bash proxy.sh 192.168.10.16
systemctl status kube-proxy.service 

②、node2节点

#把node1节点的/opt/kubernetes 目录复制到node2节点中（node1上操作）
scp -r /opt/kubernetes/ root@192.168.10.17:/opt

#拷贝启动脚本 （node1上操作）
scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.10.17:/usr/lib/systemd/system/

#删除所有证书文件
cd /opt/kubernetes/ssl/
rm -rf *

#修改kubelet配置文件IP地址
cd ../cfg
vim kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.10.17 \	#修改为node2节点本地地址
--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"

#修改kubelet.conf配置文件
vim kubelet.config 
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.10.17				#修改为本地地址
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- 10.0.0.2						#DNS解析地址，需要记下来
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true

#修改kube-proxy 配置文件
vim kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.10.17 \		#修改为本地地址
--cluster-cidr=10.0.0.0/24 \
--proxy-mode=ipvs \
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

#启动服务
systemctl start kubelet
systemctl enable kubelet
systemctl start kube-proxy
systemctl enable kube-proxy

#master节点授权（master上操作）
kubectl get csr
kubectl certificate approve 节点2的名称
kubectl get csr

#master查看集群状态（master上操作）
kubectl get node