Kubernetes单Master集群二进制搭建

#Master节点操作 (192.168.222.10)
hostnamectl set-hostname master01
#Master节点操作(192.168.222.100) 
hostnamectl set-hostname node01
#Master节点操作 (192.168.222.20)
hostnamectl set-hostname node02

#在master添加hosts
cat >> /etc/hosts << EOF
192.168.222.10 master01
192.168.222.100 node01
192.168.222.20 node02
EOF

cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF

sysctl --system

#时间同步
yum install ntpdate -y
ntpdate time.windows.com

二、Etcd集群部署

1、准备签发证书环境

在master01 节点上操作

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo

chmod +x /usr/local/bin/cfssl*

2、生成CA证书、etcd服务器证书以及私钥

在master01 节点上操作

mkdir /opt/k8s
cd /opt/k8s/
//上传etcd-cert.sh 和etcd.sh 到/opt/k8s/目录中
chmod +x etcd-cert.sh
//创建用于生成CA证书、etcd服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh
#生成CA证书、etcd服务器证书以及私钥

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；
#后续在签名证书时会使用某个 profile；此实例只有一个 www 模板。
#expiry：指定了证书的有效期，87600h 为10年，如果用默认值一年的话，证书到期后集群会立即宕掉
#signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
#key encipherment：表示使用非对称密钥加密，如 RSA 加密；
#server auth：表示client可以用该 CA 对 server 提供的证书进行验证；
#client auth：表示server可以用该 CA 对 client 提供的证书进行验证；
#注意标点符号，最后一个字段一般是没有逗号的。


#-----------------------
#生成CA证书和私钥（根证书和私钥）
#特别说明： cfssl和openssl有一些区别，openssl需要先生成私钥，然后用私钥生成请求文件，最后生成签名的证书和私钥等，但是cfssl可以直接得到请求文件。
cat > ca-csr.json <<EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

#CN：Common Name，浏览器使用该字段验证网站或机构是否合法，一般写的是域名 
#key：指定了加密算法，一般使用rsa（size：2048）
#C：Country，国家
#ST：State，州，省
#L：Locality，地区,城市
#O: Organization Name，组织名称，公司名称
#OU: Organization Unit Name，组织单位名称，公司部门

cfssl gencert -initca ca-csr.json | cfssljson -bare ca

#生成的文件：
#ca-key.pem：根证书私钥
#ca.pem：根证书
#ca.csr：根证书签发请求文件

#cfssl gencert -initca <CSRJSON>：使用 CSRJSON 文件生成生成新的证书和私钥。如果不添加管道符号，会直接把所有证书内容输出到屏幕。
#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。


#-----------------------
#生成 etcd 服务器证书和私钥
cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.222.10",
    "192.168.222.100",
    "192.168.222.20"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

#hosts：将所有 etcd 集群节点添加到 host 列表，需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段，新增 etcd 服务器需要重新签发证书。

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

#生成的文件：
#server.csr：服务器的证书请求文件
#server-key.pem：服务器的私钥
#server.pem：服务器的数字签名证书

#-config：引用证书生成策略文件 ca-config.json
#-profile：指定证书生成策略文件中的的使用场景，比如 ca-config.json 中的 www

3、安装Etcd

//上传etcd-v3.4.9-linux-amd64.tar.gz到/opt/k8s/目录中，解压etcd 压缩包
cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation etcd  etcdctl  README-etcdctl.md README.md READMEv2-etcdctl.md

4、在Master01节点启动Etcd集群节点01

//创建用于存放etcd配置文件，命令文件，证书的目录
mkdir -p /opt/etcd/{cfg,bin,ssl}
cd /opt/k8s/etcd-v3.4.9-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
chmod +x etcd.sh
//另外打开一一个窗口查看etcd进程是否正常
ps -ef | grep etcd

5、将证书，命令文件，服务启动脚本拷贝到另外两个etcd集群节点

在master01 节点上操作

//把etcd相关证书文件和命令文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ root@192.168.222.100:/opt/
scp -r /opt/etcd/ root@192.168.222.20:/opt/

//启动脚本拷贝其他节点
scp /usr/lib/systemd/system/etcd.service root@192.168.222.100:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.222.20:/usr/lib/systemd/system/

6、在其他节点修改etcd配置文件

在node01 节点上操作

vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.222.100:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.222.100.55:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.222.100:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.222.100:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.195.149:2380,etcd02=https://192.168.195.150:2380,etcd03=https://192.168.195.151:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
//启动
systemctl start etcd
systemctl status etcd

在node02 节点上操作

vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.222.20:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.222.20:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.222.20:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.222.20:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.195.149:2380,etcd02=https://192.168.195.150:2380,etcd03=https://192.168.195.151:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
//启动
systemctl start etcd
systemctl status etcd

三、部署docker引擎

在node01节点和node02节点上操作

//所有node节点部署docker引擎
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum install -y docker-ce 
systemctl start docker.service
systemctl enable docker.service

四、Flannel网络配置

1、在master01 节点上操作

export ETCDCTL_API=2
cd /opt/etcd/ssl
/opt/etcd/bin/etcdctl \
--ca-file=ca.pem \
--cert-file=server.pem \
--key-file=server-key.pem \
--endpoints="https://192.168.222.10:2379,https://192.168.222.100:2379,https://192.168.222.20:2379" \
set /coreos.com/network/config '{"Network": "172.17.0.0/16","Backend": {"Type": "vxlan"}}'

2、安装并启动Flannel服务

在所有node 节点上操作

//上传flannel.sh和flannel-v0.10.0-1inux-amd64.tar.gz到/opt 目录中，解压flannel 压缩包
cd /opt
tar zxvf flannel-v0.10.0-linux-amd64.tar.gz
flanneld 				#flanneld为主要的执行文件
mk-docker-opts.sh		#mk-docker-opts.sh脚本用于生成Docker启动参数
README.md
//创建kubernetes工作目录
mkdir -p /opt/kubernetes/{cfg,bin,ssl}
mv mk-docker-opts.sh flanneld /opt/kubernetes/bin/
//启动flanneld服务，开启flannel网络功能
cd /opt
chmod +x flannel.sh
./flannel.sh https://192.168.222.10:2379,https://192.168.222.100:2379,https://192.168.222.20:2379

//flannel启动后会生成一个docker网络相关信息配置文件/run/flannel/subnet.env，包含了docker要使用flannel通讯的相关参数
cat /run/flannel/subnet.env
DOCKER_OPT_BIP="--bip=172.17.26.1/24"
DOCKER_OPT_IPMASQ="--ip-masq= false"
DOCKER_OPT_MTU="--mtu=1450"
DOCKER NETWORK OPTIONS="--bip=172.17.26. 1/24 --ip-masq-false--mtu=1450"

3、配置Docker连接Flannel

在所有node 节点上操作

vim /usr/lib/systemd/system/docker.service

[Service]
....
#for containers run by docker
EnvironmentFile=/run/flannel/subnet.env   #添加此行
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS -H fd:// --containerd=/run/containerd/containerd.sock
....

//重启docker服务
systemctl daemon-reload
systemctl restart docker
//查看flannel网络
ifconfig

//测试ping通对方docker0网卡证明flannel起到路由作用
node1:ping 172.17.4.1
node2:ping 172.17.61.1

4、在两个Node节点内创建Docker容器，进行测试

在所有node 节点上操作

docker run -it centos:7 /bin/bash
yum install net-tools -y
ifconfig

五、部署master组件

1、上传安装包及证书生成脚本

//上传master.zip 和k8s-cert.sh 到/opt/k8s目录中，解压master.zip压缩包
cd /opt/k8s/
unzip master.zip
apiserver.sh
scheduler.sh
controller-manager.sh
chmod +x *.sh

2、创建Kubernetes工作目录，生成证书

//创建kubernetes工作目录
mkdir -p /opt/kubernetes/{cfg,bin,ssl}
//创建用于生成CA证书、相关组件的证书和私钥的目录
mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
./k8s-cert.sh				#生成CA证书、相关组件的证书和私钥

ls *pem
admin-key.pem apiserver-key.pem
ca-key.pem kube-proxy-key.pem
admin.pem
apiserver.pem
ca.pem
kube-proxy.pem
//controller-manager和kube-scheduler设置为只调用当前机器的apiserver, 使用127.0.0.1:8080 通信，因此不需要签发证书
//复制CA证书、apiserver相关证书和私钥到kubernetes 工作目录的ssl子 目录中
cp ca*pem apiserver*pem /opt/kubernetes/ssl/

3、解压安装包并创建Token认证文件

//上传kubernetes-server-linux-amd64.tar.gz到/opt/k8s/目录中，解压kubernetes压缩包
cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz
//复制master组件的关键命令文件到kubernetes 工作目录的bin子目录中
cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/

//创建bootstrap token认证文件，apiserver启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用RBAC
给他授权
cd /opt/k8s/
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
head -c 16 /dev/urandom | od -An -t x | tr -d ' '
a2c66a6067ea66da3e368ae58106b47f     			#复制生成的随机数
#编辑token.csv文件，按照Token序列号,用户名,UID,用户组的格式生成
vim /opt/kubernetes/cfg/token.csv
a2c66a6067ea66da3e368ae58106b47f,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
cat /opt/kubernetes/cfg/token.csv

4、开启Apiserver服务

//二进制文件、token、证书都准备好后，开启apiserver服务
cd /opt/k8s/
./apiserver.sh 192.168.222.10 https://192.168.222.10:2379,https://192.168.222.100:2379,https://192.168.222.20:2379

//检查进程是否启动成功
ps aux | grep kube-apiserver
// k8s通过kube-apiserver这个进程提供服务，该进程运行在单个master节点上。默认有两个端口6443和8080
//安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
netstat -natp |grep 6443
//本地端口8080用于接收HTTP请求，非认证或授权的HTTP请求通过该端口访问APIServer
netstat -natp | grep 8080
//查看版本信息(必须保证apiserver启动正常，不然无法查询到server的版本信息)
kubectl version

5、启动Scheduler服务

//启动scheduler服务
cd /opt/k8s/
./scheduler.sh 127.0.0.1
ps aux | grep scheduler

6、启动controller-manager服务

//启动controller-manager服务
cd /opt/k8s/
./controller-manager.sh 127.0.0.1
ps aux | grep kube-controller-manager

7、查看Master节点状态

//查看master 节点状态.
kubectl get componentstatuses
#也可以kubectl get cs

六、部署Node 组件

1、将kubelet和kube-proxy拷贝到node01节点

在Master01节点上操作

//把kubelet、kube-proxy 拷贝到node节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.222.100:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.222.20:/opt/kubernetes/bin/

2、上传Node压缩包

在Node01节点上操作

//上传node.zip 到/opt日录中，解压node.zip压缩包，获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip

3、创建生成Kubelet的配置文件和目录

在Master01节点上操作

//创建用于生成kubelet的配置文件的目录
mkdir /opt/k8s/kubeconfig
//上传kubeconfig.sh文件到/opt/k8s/kubeconfig日录中
#kubeconfig.sh文件包含集群参数(CA证书、API Server地址)，客户端参数(上面生成的证书和私钥)，集群context上下文参数(集群名称、用户名)。Kubenetes 组件(如kubelet、kube-proxy)通过启动时指定不同的kubeconfig文件可以切换到不同的集群，连接到apiserver。
cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh

//生成kubelet的配置文件
cd /opt/k8s/kubeconfig
./kubeconfig.sh 192.168.222.10 /opt/k8s/k8s-cert/
ls
//把配置文件bootstrap.kubeconfig、kube-proxy.kubeconfig拷贝到node节点
cd /opt/k8s/kubeconfig
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.222.100:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.222.20:/opt/kubernetes/cfg/
//RBAC授权，将预设用户kubelet-bootstrap 与内置的ClusterRole system: node -bootstrapper绑定到一起， 使其能够发起CSR请求
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

//查看角色:
kubectl get clusterroles | grep system:node-bootstrapper
//查看已授权的角色:
kubectl get clusterrolebinding

4、启动Kubelet服务

在Node01节点上操作

//使用kubelet.sh脚本启动kubelet服务
cd /opt/
chmod +x kubelet.sh
./kubelet.sh 192.168.222.100
//检查kubelet服务启动
ps aux | grep kubelet
//此时还没有生成证书
ls /opt/kubernetes/ssl/

5、检查kubelet发起的CSR请求

在Master01节点上操作

//检查到node01节点的kubelet发起的CSR 请求，Pending表示等待集群给该节点签发证书
kubectl get csr
//通过CSR请求
kubectl certificate approve +集群NAME
//再次查看CSR请求状态，Approved, Issued 表示已授权CSR 请求并签发证书
kubectl get csr

6、查看集群节点状态

在Master01节点上操作

//查看群集节点状态，成功加入node01节点
kubectl get nodes

7、加载ipvs模块，启动kube-proxy服务

在Node01节点上操作

//自动生成了证书和kubelet.kubeconfig 文件
ls /opt/kubernetes/cfg/kubelet.kubeconfig
ls /opt/kubernetes/ssl/

//加载ipvs模块
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/nu1l 2>&1 && /sbin/modprobe $i; done

//使用proxy.sh脚本启动proxy服务
cd /opt/
chmod +x proxy.sh
./proxy.sh 192.168.121.55
systemctl status kube-proxy.service

七、Node02节点部署

1、Node02节点部署

在Node01节点上操作

//把现成的/opt/kubernetes目录复制到node节点进行修改即可
scp -r /opt/kubernetes/ root@192.168.222.20:/opt/
//把kubelet，kube-proxy的service文件拷贝到node2中
scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.121.66:/usr/lib/systemd/system/

2、修改相关配置文件

//首先删除复制过来的证书，等会node02会自行申请证书
cd /opt/kubernetes/ssl/
rm -rf *

修改配置文件kubelet kubelet.config kube-proxy（三个配置文件）

cd /opt/kubernetes/cfg/
vim kubelet
...
--v=4 \
--hostname-override=192.168.222.20 \   #第3行，修改为当前节点IP
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
...

3、启动服务

//启动服务
systemctl start kubelet.service 
systemctl enable kubelet.service 

systemctl start kube-proxy.service 
systemctl enable kube-proxy.service

4、授权加入集群

在Master01节点上操作

//在master上操作查看请求
kubectl get csr
//授权许可加入群集
kubectl certificate approve +节点NAME

5、查看集群节点信息

//查看群集中的节点
kubectl get node

qq_52825616

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Kubernetes单Master集群二进制搭建

IP地址192.168.222.10服务kube-apiserverkube-controller-manager。IP地址192.168.222.20服务kubeletkube-proxydockerflannel。在node01节点和node02节点上操作。在master01节点上操作。在master01节点上操作。在master01节点上操作。在Master01节点上操作。在Master01节点上操作。在Master01节点上操作。在Master01节点上操作。...
复制链接

扫一扫