kubernetes k8s（2）

一.二进制部署k8s

常见的K8S安装部署方式：

k8s部署二进制与高可用的区别

二.部署k8s

初始化操作：

每台node安装docker：

在 master01 节点上操作;

准备cfssl证书生成工具:：

执行脚本文件：

拉入etcd压缩包：

创建用于存放 etcd 配置文件，命令文件，证书的目录

执行etcd.sh脚本：

将目录所有文件复制到node节点上：

修改node节点的etcd文件：

启动etcd服务：

检查etcd群集状态：

查看etcd集群成员列表：

编辑安装 Master 组件，准备生成CA证书：

创建用于生成CA证书、相关组件的证书和私钥的目录：

创建kubernetes工作目录：

复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中

上传解压 kubernetes 压缩包：

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中：

解压master.zip：

启动 scheduler 服务：

启动 controller-manager 服务：

生成kubectl连接集群的kubeconfig文件:

过kubectl工具查看当前集群组件状态：

部署 Worker Node 组件：

创建kubernetes工作目录：

在 master01 节点上操作：

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中:

授权，执行脚本：

RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书：

master节点启动 kubelet 服务：

通过 CSR 请求：

在 node01 节点上操作：

启动proxy服务：

一.二进制部署k8s

常见的K8S安装部署方式：

Minikube是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习、预览K8S的一些特性使用。部署地址：https://kubernetes.io/docs/setup/minikube

Kubeadm也是一个工具，提供kubeadm init和kubeadm join，用于快速部署K8S集群，相对简单。 https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

二进制安装部署生产首选，从官方下载发行版的二进制包，手动部署每个组件和自签TLS证书，组成K8S集群，新手推荐。 https://github.com/kubernetes/kubernetes/releases

Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署Kubernetes集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

k8s部署二进制与高可用的区别

二进制部署部署难，管理方便，集群伸展性能好更稳定，集群规模到达一定的规模(几百个节点、上万个Pod)，二进制稳定性是要高于kubeadm部署遇到故障，宿主机起来了，进程也会起来。

kubeadm部署部署简单，管理难是以一种容器管理容器的方式允许的组件及服务，故障恢复时间比二进制慢遇到故障，启动宿主机，再启动进程，最后去启动容器，集群才能恢复，速度比二进制慢

二.部署k8s

k8s master节点：192.168.233.10，20

k8s node节点：192.168.233.30，40 （容器引擎为docker）

etcd集群：192.168.233.10,30,40

负载均衡nginx+keepalive01（master）： 192.168.233.50 负载均衡nginx+keepalive02（backup）：192.168.233.60

初始化操作：

关闭防火墙 systemctl stop firewalld systemctl disable firewalld

关闭selinux setenforce 0 sed -i 's/enforcing/disabled/' /etc/selinux/config

关闭swap swapoff -a sed -ri 's/.*swap.*/#&/' /etc/fstab

根据规划设置主机名 hostnamectl set-hostname master01 hostnamectl set-hostname node01 hostnamectl set-hostname node02

在master添加hosts cat >> /etc/hosts << EOF 192.168.233.10 master01 192.168.233.30 node01 192.168.233.40 node02 EOF

调整内核参数 cat > /etc/sysctl.d/k8s.conf << EOF #开启网桥模式，可将网桥的流量传递给iptables链 net.bridge.bridge-nf-call-ip6tables = 1 net.bridge.bridge-nf-call-iptables = 1 #关闭ipv6协议 net.ipv6.conf.all.disable_ipv6=1 net.ipv4.ip_forward=1 EOF

sysctl --system

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

每台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

切换到docker目录下，添加文件：

{

"registry-mirrors": ["https://6ijb8ubo.mirror.aliyuncs.com"],

"exec-opts": ["native.cgroupdriver=systemd"],

"log-driver":"json-file",

"log-opts":{

"max-size":"500m","max-file":"3"

}

安装设置为开机自动启动：

yum install -y docker-ce docker-ce-cli containerd.io systemctl start docker.service systemctl enable docker.service

在 master01 节点上操作;

准备cfssl证书生成工具:：

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/*

创建工作目录：

添加脚本文件：

#!/bin/bash

#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书

cat > ca-config.json <

{

"signing": {

"default": {

"expiry": "87600h"

"profiles": {

"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证书和私钥（根证书和私钥）

cat > ca-csr.json <

{

"CN": "etcd",

"key": {

"algo": "rsa",

"size": 2048

{

"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：根证书签发请求文件

#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。

#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。

#-----------------------

{

"CN": "etcd",

"hosts": [

"192.168.233.10",

"192.168.233.30",

"192.168.233.40"

"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

#!/bin/bash

#example: ./etcd.sh etcd01 192.168.233.10 etcd02=https://192.168.233.30:2380,etcd03=https://192.168.233.40:2380

#创建etcd配置文件/opt/etcd/cfg/etcd

ETCD_NAME=$1

ETCD_IP=$2

ETCD_CLUSTER=$3

WORK_DIR=/opt/etcd

#[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

#Member:成员配置

#ETCD_NAME：节点名称，集群中唯一。成员名字，集群中必须具备唯一性，如etcd01

#Clustering：集群配置

#ETCD_INITIAL_CLUSTER_TOKEN：集群Token。用于区分不同集群。本地如有多个集群要设为不同

#ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群。

#创建etcd.service服务管理文件

cat > /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 \

--cert-file=${WORK_DIR}/ssl/server.pem \

--key-file=${WORK_DIR}/ssl/server-key.pem \

--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \

--peer-cert-file=${WORK_DIR}/ssl/server.pem \

--peer-key-file=${WORK_DIR}/ssl/server-key.pem \

--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \

--logger=zap \

--enable-v2

Restart=on-failure

LimitNOFILE=65536

[Install]

WantedBy=multi-user.target

EOF

#--enable-v2：开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信

#--logger=zap：使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的

#--peer开头的配置项用于指定集群内部TLS相关证书（peer 证书），这里全部都使用同一套证书认证

#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书（server 证书），这里全部都使用同一套证书认证

systemctl daemon-reload

systemctl enable etcd

systemctl restart etcd

执行脚本文件：

./etcd-cert.sh

移动文件：

mkdir etcd-cert

mv ca* server* etcd-cert

拉入etcd压缩包：

解压：

tar zxvf etcd-v3.4.26-linux-amd64.tar.gz

创建用于存放 etcd 配置文件，命令文件，证书的目录

mkdir -p /opt/etcd/{cfg,bin,ssl}

.切换到k8s中将命令移动到bin下：

mv etcd etcdctl /opt/etcd/bin/

复制etcd-cert下的.pem结尾文件到ssl目录下：

cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

执行etcd.sh脚本：

./etcd.sh etcd01 192.168.233.10 etcd02=https://192.168.233.30:2380,etcd03=https://192.168.233.40:2380

查看端口：

将目录所有文件复制到node节点上：

scp -r /opt/etcd/ root@192.168.233.30:/opt/ scp -r /opt/etcd/ root@192.168.233.40:/opt/

scp /usr/lib/systemd/system/etcd.service root@192.168.233.30:/usr/lib/systemd/system/ scp /usr/lib/systemd/system/etcd.service root@192.168.233.40:/usr/lib/systemd/system/

修改node节点的etcd文件：

vim /opt/etcd/cfg/etcd

启动etcd服务：

systemctl start etcd systemctl enable etcd systemctl status etcd

检查etcd群集状态：

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379" endpoint health --write-out=table

查看etcd集群成员列表：

安装 Master 组件，准备生成CA证书：

#!/bin/bash

#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书

cat > ca-config.json <

{

"signing": {

"default": {

"expiry": "87600h"

"profiles": {

"kubernetes": {

"expiry": "87600h",

"usages": [

"signing",

"key encipherment",

"server auth",

"client auth"

]

}

EOF

#生成CA证书和私钥（根证书和私钥）

cat > ca-csr.json <

{

"CN": "kubernetes",

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "Beijing",

"ST": "Beijing",

"O": "k8s",

"OU": "System"

}

]

}

EOF

#!/bin/bash

#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书

cat > ca-config.json <

{

"signing": {

"default": {

"expiry": "87600h"

"profiles": {

"kubernetes": {

"expiry": "87600h",

"usages": [

"signing",

"key encipherment",

"server auth",

"client auth"

]

}

EOF

#生成CA证书和私钥（根证书和私钥）

cat > ca-csr.json <

{

"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 -

#-----------------------

#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）

#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入

cat > apiserver-csr.json <

{

"CN": "kubernetes",

"hosts": [

"10.0.0.1",

"127.0.0.1",

"192.168.233.10",

"192.168.233.20",

"192.168.233.100",

"192.168.233.50",

"192.168.233.60",

"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

#-----------------------

#生成 kubectl 连接集群的证书和私钥（kubectl 和 apiserver 通信使用）

cat > admin-csr.json <

{

"CN": "admin",

"hosts": [],

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "BeiJing",

"ST": "BeiJing",

"O": "system:masters",

"OU": "System"

}

]

}

EOF

#-----------------------

#生成 kube-proxy 的证书和私钥（kube-proxy 和 apiserver 通信使用）

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"

}

]

}

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证书、相关组件的证书和私钥的目录：

移动脚本文件到目录中;

执行文件：

创建kubernetes工作目录：

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中

cp ca*pem apiserver*pem /opt/kubernetes/ssl/

上传解压 kubernetes 压缩包：

tar xf kubernetes-server-linux-amd64.tar.gz

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中：

cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/

ln -s /opt/kubernetes/bin/* /usr/local/bin/

获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格：

head -c 16 /dev/urandom | od -An -t x | tr -d ' '

生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组的格式生成：

#!/bin/bash #获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格 BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ') #生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组的格式生成 cat > /opt/kubernetes/cfg/token.csv <

解压master.zip：

授权：

二进制文件、token、证书都准备好后，开启 apiserver 服务

./apiserver.sh 192.168.233.10 https://192.168.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379

安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

netstat -natp | grep 6443

启动 scheduler 服务：

#!/bin/bash

##创建 kube-scheduler 启动参数配置文件

MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-scheduler <

KUBE_SCHEDULER_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--leader-elect=true \\

--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\

--bind-address=$MASTER_ADDRESS"

EOF

#-?kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群

#--leader-elect=true：当该组件启动多个时，自动启动 leader 选举

#k8s 中 Controller-Manager 和 Scheduler 的选主逻辑：k8s 中的 etcd 是整个集群所有状态信息的存储，涉及>数据的读写和多个 etcd 之间数据的同步，对数据的一致性要求严格，所以使用较复杂的 raft 算法来选择用于提>交数据的主节点。而 apiserver 作为集群入口，本身是无状态的 web 服务器，多个 apiserver 服务之间直接负载

请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件，比如 controller-manager 内置>的 k8s 各种资源对象的控制器实时的 watch apiserver 获取对象最新的变化事件做期望状态和实际状态调整，scheduler watch 未绑定节点的 pod 做节点选择，显然多个这些任务同时工作是完全没有必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可，而无需考虑它们之间的数据一致和同步。

##生成kube-scheduler证书

#创建证书请求文件

cat > kube-scheduler-csr.json << EOF

{

"CN": "system:kube-scheduler",

"hosts": [],

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "BeiJing",

"ST": "BeiJing",

"O": "system:masters",

"OU": "System"

}

]

}

EOF

#生成证书和私钥

#生成kubeconfig配置文件

KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"

KUBE_APISERVER="https://192.168.233.10:6443"

#配置kubernetes集群参数

kubectl config set-cluster kubernetes \

--certificate-authority=/opt/kubernetes/ssl/ca.pem \

--embed-certs=true \

--server=${KUBE_APISERVER} \

--kubeconfig=${KUBE_CONFIG}

#配置客户端认证参数

kubectl config set-credentials kube-scheduler \

--client-certificate=./kube-scheduler.pem \

--client-key=./kube-scheduler-key.pem \

--embed-certs=true \

--kubeconfig=${KUBE_CONFIG}

#设置上下文参数

kubectl config set-context default \

--cluster=kubernetes \

--user=kube-scheduler \

--kubeconfig=${KUBE_CONFIG}

#设置默认上下文

kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

##创建 kube-scheduler.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kube-scheduler

systemctl restart kube-scheduler

启动脚本：

启动 controller-manager 服务：

#!/bin/bash

##创建 kube-controller-manager 启动参数配置文件

MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-controller-manager <

KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--leader-elect=true \\

--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\

--bind-address=$MASTER_ADDRESS \\

--allocate-node-cidrs=true \\

--cluster-cidr=10.244.0.0/16 \\

--service-cluster-ip-range=10.0.0.0/24 \\

--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 \\

--cluster-signing-duration=87600h0m0s"

EOF

#––leader-elect：当该组件启动多个时，自动选举（HA）

#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群

##生成kube-controller-manager证书

#创建证书请求文件

cat > kube-controller-manager-csr.json << EOF

{

"CN": "system:kube-controller-manager",

"hosts": [],

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "BeiJing",

"ST": "BeiJing",

"O": "system:masters",

"OU": "System"

}

]

}

EOF

#生成证书和私钥

#生成kubeconfig配置文件

KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"

KUBE_APISERVER="https://192.168.233.10:6443"

#配置kubernetes集群参数

kubectl config set-cluster kubernetes \

--certificate-authority=/opt/kubernetes/ssl/ca.pem \

--embed-certs=true \

--server=${KUBE_APISERVER} \

--kubeconfig=${KUBE_CONFIG}

#配置客户端认证参数

kubectl config set-credentials kube-controller-manager \

--client-certificate=./kube-controller-manager.pem \

--client-key=./kube-controller-manager-key.pem \

--embed-certs=true \

--kubeconfig=${KUBE_CONFIG}

#设置上下文参数

kubectl config set-context default \

--cluster=kubernetes \

--user=kube-controller-manager \

--kubeconfig=${KUBE_CONFIG}

#设置默认上下文

kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

##创建 kube-controller-manager.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kube-controller-manager

systemctl restart kube-controller-manager

执行脚本：

./controller-manager.sh 192.168.233.10

生成kubectl连接集群的kubeconfig文件:

#!/bin/bash

mkdir /root/.kube

KUBE_CONFIG="/root/.kube/config"

KUBE_APISERVER="https://192.168.233.10:6443"

#切换到k8s证书目录操作

cd /opt/k8s/k8s-cert/

--certificate-authority=/opt/kubernetes/ssl/ca.pem \

--embed-certs=true \

--client-certificate=./admin.pem \

--client-key=./admin-key.pem \

kubectl config set-context default \

--kubeconfig=${KUBE_CONFIG}

#设置默认环境上下文

kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

#生成的 kubeconfig 被保存到 /root/.kube/config 文件

#########################################################

#集群参数

#本段设置了所需要访问的集群的信息。使用set-cluster设置了需要访问的集群，如上为kubernetes，这只是个名>称，实际为--server指向的apiserver；--certificate-authority设置了该集群的公钥；--embed-certs为true表示

将--certificate-authority证书写入到kubeconfig中；--server则表示该集群的kube-apiserver地址

#用户参数

#本段主要设置用户的相关信息，主要是用户证书。如上的用户名为admin，证书为：/opt/kubernetes/ssl/admin.pem，私钥为：/opt/kubernetes/ssl/admin-key.pem。注意客户端的证书首先要经过集群CA的签署，否则不会被集群

认可。此处使用的是ca认证方式，也可以使用token认证，如kubelet的 TLS Boostrap 机制下的 bootstrapping 使

用的就是token认证方式。上述kubectl使用的是ca认证，不需要token字段

#上下文参数

#集群参数和用户参数可以同时设置多对，在上下文参数中将集群参数和用户参数关联起来。上面的上下文名称为default，集群为kubenetes，用户为admin，表示使用admin的用户凭证来访问kubenetes集群的default命名空间，也>可以增加--namspace来指定访问的命名空间。

#最后使用 kubectl config use-context default 来使用名为 default 的环境项来作为配置。如果配置了多个环

境项，可以通过切换不同的环境项名字来访问到不同的集群环境。

#########################################################

执行脚本：

查看文件：

过kubectl工具查看当前集群组件状态：

kubectl get cs

查看版本信息：

kubectl version

绑定默认cluster-admin管理员集群角色，授权kubectl访问集群：

kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

部署 Worker Node 组件：

在所有 node 节点上操作30,40：

创建kubernetes工作目录：

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包：

#!/bin/bash

NODE_ADDRESS=$1

DNS_SERVER_IP=${2:-"10.0.0.2"}

cat >/opt/kubernetes/cfg/kubelet <

KUBELET_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--hostname-override=node01 \\

--network-plugin=cni \\

--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.2"

EOF

#--network-plugin：启用CNI

#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件

#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置

#--cert-dir：指定master颁发的kubelet证书生成目录

#----------------------

cat >/opt/kubernetes/cfg/kubelet.config <

kind: KubeletConfiguration

apiVersion: kubelet.config.k8s.io/v1beta1

address: ${NODE_ADDRESS}

port: 10250

readOnlyPort: 10255

cgroupDriver: systemd

clusterDNS:

- ${DNS_SERVER_IP}

clusterDomain: cluster.local

failSwapOn: false

authentication:

anonymous:

enabled: true

EOF

#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。

#----------------------

#创建 kubelet.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kubelet

systemctl restart kubelet

#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件

cat >/opt/kubernetes/cfg/kube-proxy <

KUBE_PROXY_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--hostname-override=${NODE_ADDRESS} \\

--cluster-cidr=10.244.0.0/16 \\

--proxy-mode=ipvs \\

--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

EOF

#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件

#rr: round-robin，轮询。

#lc: least connection，最小连接数。

#dh: destination hashing，目的地址哈希。

#sh: source hashing ,原地址哈希。

#sed: shortest expected delay，最短期望延时。

#nq: never queue ，永不排队。

#----------------------

#创建 kube-proxy.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kube-proxy

systemctl restart kube-proxy

#!/bin/bash

NODE_ADDRESS=$1

#创建 kubelet 启动参数配置文件

cat >/opt/kubernetes/cfg/kubelet <

KUBELET_OPTS="--logtostderr=false \\

--hostname-override=node02 \\

--network-plugin=cni \\

--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.2"

EOF

#--network-plugin：启用CNI

#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件

#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置

#--cert-dir：指定master颁发的kubelet证书生成目录

#----------------------

cat >/opt/kubernetes/cfg/kubelet.config <

kind: KubeletConfiguration

apiVersion: kubelet.config.k8s.io/v1beta1

address: ${NODE_ADDRESS}

port: 10250

readOnlyPort: 10255

cgroupDriver: systemd

clusterDNS:

- ${DNS_SERVER_IP}

clusterDomain: cluster.local

failSwapOn: false

authentication:

anonymous:

enabled: true

EOF

#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。

#----------------------

#创建 kubelet.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kubelet

systemctl restart kubelet

#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件

cat >/opt/kubernetes/cfg/kube-proxy <

KUBE_PROXY_OPTS="--logtostderr=false \\

--v=2 \\

--log-dir=/opt/kubernetes/logs \\

--hostname-override=${NODE_ADDRESS} \\

--cluster-cidr=10.244.0.0/16 \\

--proxy-mode=ipvs \\

--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

EOF

#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件

#rr: round-robin，轮询。

#lc: least connection，最小连接数。

#dh: destination hashing，目的地址哈希。

#sh: source hashing ,原地址哈希。

#sed: shortest expected delay，最短期望延时。

#nq: never queue ，永不排队。

#----------------------

#创建 kube-proxy.service 服务管理文件

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

EOF

systemctl daemon-reload

systemctl enable kube-proxy

systemctl restart kube-proxy

授权：

在 master01 节点上操作：

把 kubelet、kube-proxy 拷贝到 node 节点;

cd /opt/k8s/kubernetes/server/bin

scp kubelet kube-proxy root@192.168.233.30:/opt/kubernetes/bin/ scp kubelet kube-proxy root@192.168.233.40:/opt/kubernetes/bin/

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中:

#!/bin/bash

#example: kubeconfig 192.168.233.10 /opt/k8s/k8s-cert/

#创建bootstrap.kubeconfig文件

BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)

APISERVER=$1

SSL_DIR=$2

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

#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中

# 设置客户端认证参数，kubelet 使用 bootstrap token 认证

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

# 使用上下文参数生成 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

# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证

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

# 使用上下文参数生成 kube-proxy.kubeconfig 文件

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

授权，执行脚本：

chmod +x kubeconfig.sh

./kubeconfig.sh 192.168.233.10 /opt/k8s/k8s-cert/

把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点：

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.233.30:/opt/kubernetes/cfg/ scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.233.40:/opt/kubernetes/cfg/

查看一下：

RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书：

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

master节点启动 kubelet 服务：

在 master01 节点上操作，通过 CSR 请求：

通过 CSR 请求：

kubectl certificate approve node-csr-vH5p3H5QliAUh9WjCnwXPDb84pFhcj-FrHiTIRDeeU8

Approved,Issued 表示已授权 CSR 请求并签发证书：

查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady：

kubectl get node

在 node01 节点上操作：

加载 ip_vs 模块：

ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/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/null 2>&1 && /sbin/modprobe $i;done

启动proxy服务：

./proxy.sh 192.168.233.30

master节点：

node02上启动kubelet：

master节点通过 CSR 请求：

node02上启动proxy：

文章链接

评论可见，请评论后查看内容，谢谢！！！评论后请刷新页面。

夸智网

kubernetes k8s（2）

网络协议网络 WebSocket相关问题

kubernetes 容器 k8s中的整体架构，pod含义，服务类型，网络通讯等

发表评论取消回复

夸智网

kubernetes k8s（2）

网络协议 网络 WebSocket相关问题

kubernetes 容器 k8s中的整体架构 ，pod含义，服务类型，网络通讯等

相关文章

发表评论取消回复

网络协议网络 WebSocket相关问题

kubernetes 容器 k8s中的整体架构，pod含义，服务类型，网络通讯等