公有云版k8s的架构是怎样的

由此图可以看出：搞云计算，网络占一半！
网工的职业路线尽头是云计算和物联网。

公有云中创建k8s实例的过程如下

1. 创建vpc和交换机。阿里云的vswitch交换机最多支持子网掩码16，既一台虚拟交换机最多能承受65535个ip的流量。
2. 创建k8s集群，创建过程中需要规定两个负载均衡器（一个用于访问集群，一个用于ingress），Service的二级域名，容器运行时，集群是否需要公网ip，工作负载的子网网段等信息。
3. 创建过程需要20分钟，创建好后即可开箱使用

二进制法创建k8s的一般过程

kubeadm创建的高可用集群，如果后期不维护，CA证书一年就过期，集群就会瘫痪。有的人通过修改kubeadm并重新编译实现100年寿命的k8s集群创建。kubeadm全部基于容器构建k8s，master节点宕机恢复速度不如二进制安装法。且容器化部署的k8s，由于虚拟化的损耗和docker较低的资源利用率，其支持的worker数量远远不及二进制安装。
所以生产环境就用二进制部署就可以了，你也可以配合ansible做到自动化部署和升级。
本文模拟公有云ACK实例架构，手动部署k8s二进制软件包，部署流程如下。

Kubernetes的重要性

本人担任过中国某大型连锁咖啡品牌的运维负责人，做过50万人同时在线的秒杀活动，下面分享一下淘宝级秒杀类互动的运维经验。

1. 首先超过1000并发量的网站就必须上微服务架构了。生产环境必须用上MQ和Redis缓存。调度微服务，长久之计还是要使用k8s。
2. 合理评估秒杀活动的最高峰值，然后采购超大MQ，MQ的TPS> 2 x 最高峰同时在线人数。这样做可以保证消息传输。如果TPS峰值超过100万，则放弃使用RabbitMQ，转而采用RocketMQ、Kafka或者Pulser。
3. 后端服务器的CPU核心数和内存的比例保持在1:4或者1:8 ， 即所有服务器使用阿里云通用型或者内存型。因为后端服务算力不够的话顶多会卡顿，内存不够的话，k8s会把pod全部杀掉，服务就停了。
4. 后端服务器的总CPU核心数=TPS峰值/100。比如为了应对这次秒杀活动，我们采购了20万TPS的RabbitMQ，则后端服务器至少需要2000个core，相当于8c32GB的阿里云G7服务器需要250台。
5. 如果你们的生产环境MQ使用的是RabbitMQ，则由于MQ的fanout广播交换机最多支持255个后端容器，所以你的所有容器数量之和必须小于255。在做秒杀活动时，请调大每个容器的CPU和内存。Qos变成guaranteed模式，即k8s中pod的limit和required的值完全相同。
6. 尽量使用Serverless版本的k8s做秒杀活动，这样你无需维护服务器，worker数量无穷大。
7. 不要以纯容器运行时的方式部署生产环境！！如果你的生产环境没有使用k8s，而是以纯docker或docker-compose或docker-swarm的方式运行生产，则你的资源利用率只有k8s的60%左右。比如一台8核32GB的服务器上运行多个容器，由于docker是最小化按需分配资源的，即使服务器性能有冗余，你的服务用起来还是卡卡的。docker无法有效应对激增的流量。k8s的pod能将性能完全赋予容器，资源利用率很高。所以如果你们的生产环境不用k8s的话，采购服务器的时候请在第4条的基础上乘以1.5，否则后端还是吃不消。

check nodes

这一步是准备linux并检查linux配置基线满足部署k8s的条件。需要的linux比较多，请土豪入场，一般玩家请退场。负载均衡不要求很高的算力，主要是数量多。因为一台linux最多65535个端口，所以最多创建65535个backend网络连接，如果想要一个百万并发的负载均衡器，就至少需要16个Linux组成LVS。所以阿里云对大型ALB和SLB的介绍就是16台ecs拼成。本文的大均衡器用四台，并发量25万以上。

主机名	IP地址	用途	算力规划
k8s-haproxy01	192.168.1.11	k8s集群小负载均衡器	1C2GB
k8s-haproxy02	192.168.1.12	k8s集群小负载均衡器	1C2GB
master01	192.168.1.13	k8s master主节点	2C4GB
master02	192.168.1.14	k8s master主节点	2C4GB
master03	192.168.1.15	k8s master主节点	2C4GB
loadbalance01	192.168.1.16	应用服务大负载均衡器	2C4GB
loadbalance02	192.168.1.17	应用服务大负载均衡器	2C4GB
loadbalance03	192.168.1.18	应用服务大负载均衡器	2C4GB
loadbalance04	192.168.1.19	应用服务大负载均衡器	2C4GB
worker01	192.168.1.20	k8s工作负载节点	8C32GB
worker02	192.168.1.21	k8s工作负载节点	8C32GB

不要觉得master用2核4GB很小，其实阿里云ACK托管版也就用了3台2c4GB的ECS服务器部署的，一年1万元的费用。worker节点越大越好！

每台服务器执行基线配置

本文服务器系统选择Ubuntu Server 22.04（jammy），所有linux能访问外网（如果没有外网，需要在内网部署chrony时间同步服务器），每台服务器执行以下操作

# root密码一致
sudo passwd root

# 配置静态ip，如果你的机器是cloud init出来的就不用改了
vi /etc/netplan/00-network-manager.yaml
# 修改完后，重启网络
netplan apply

# 安装vim和ssh
apt update
apt -y install vim openssh-server openssh-client

# 允许ssh通过密码访问root
vim /etc/ssh/sshd_config
# 修改两行
PermitRootLogin yes
PasswordAuthentication yes
# 修改后重启ssh
systemctl restart ssh
systemctl enable ssh

# 同步时间
timedatectl set-timezone Asia/Shanghai

# 关闭防火墙
ufw disable

# 关闭swap
swapoff -a
vim /etc/fstab
去掉带swap的一行

# 本机网桥流量导入iptables表中过滤
cat >> /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
# 配置生效
sysctl --system

# hosts文件不用配置，不用vim /etc/hosts/
# 以后添加机器难道还要修改hosts不成？网上的各种教程都让你配hosts，用脚指头想想OK？

CA root

什么是CA证书？
总所周知，我们的网络想要使用HTTPS加密的话，需要申请SSL证书，只有拥有CA证书的对象才能给我们颁发SSL证书。CA证书只是一个个体认证，就像身份证一样，CA可以证明个人、企业、组织机构等对象的身份。CA证书的法律效力也是不同的，自己给自己签名的CA证书几乎没有法律效力，一般生产环境的SSL证书都是找国际上知名的拥有CA认证的企业颁发。CA证书里有用的信息就是“你是谁”和证书有效期（类比一下身份证）。
etcd存储和Kubernetes各节点通信都需要身份认证的，所以第一步创建一个自签名的CA根证书，根证书的有效期就是k8s集群的寿命。kubeadm自动创建的集群CA证书只有一年有效期。本文将创建100年有效期的CA根证书。
随便找一台节点，执行以下命令生成证书：

# 创建key
openssl genrsa -out ca.key 2048

# 创建crt ,其中/CN=<你是谁>，36500天就是100年。
openssl req -x509 -new -nodes -key ca.key -subj "/CN=xiaoming" -days 36500 -out ca.crt

把生成的ca.key和ca.crt放到3台master节点上。以下命令在3台master上都执行。

mkdir -p /etc/kubernetes/pki/
cp ca.key /etc/kubernetes/pki/
cp ca.crt /etc/kubernetes/pki/
chmod -R +r /etc/kubernetes/pki/

执行完成后，在每台master节点上的/etc/kubernetes/pki/目录下能看到两个可读的CA文件。

etcd HA cluster

etcd是k8s基础数据库，所有master组件都与etcd连接。从github下载最新的etcd二进制包。本文所有的二进制包都从GitHub上下载最新的，避免各包之间版本不兼容。本文etcd版本：v3.5.6 ，下载地址如下
https://github.com/etcd-io/etcd/releases/download/v3.5.6/etcd-v3.5.6-linux-amd64.tar.gz
先将这个包放到3台master节点的/root目录下暂存。

根据CA根证书创建etcd的专有CA证书

由于etcd的CA证书需要兼容所有master节点的IP，所以在创建etcd的CA证书之前需要编写一个x509 v3配置文件，将所有master节点的IP填入配置文件，再根据这个配置文件创建etcd的CA证书。
在master1节点上进行以下操作：

1. 编写一个x509 v3配置文件，其中的IP修改成自己得台master节点IP，其他配置不变。

vim /root/etcd_ssl.cnf
--------------------------------------------
[ req ]
req_extensions = v3_req
distinguished_name = req_distinguished_name

[ req_distinguished_name ]

[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature,keyEncipherment
subjectAltName = @alt_names

[ alt_names ]
IP.1 = 192.168.1.13
IP.2 = 192.168.1.14
IP.3 = 192.168.1.15

2. 创建etcd server的CA证书

# 创建key文件
openssl genrsa -out etcd_server.key 2048

# 根据key文件和x509配置文件，生成一个csr中间文件。
openssl req -new -key etcd_server.key -config /root/etcd_ssl.cnf -subj "/CN=etcd-server" -out etcd_server.csr

# 根据csr中间文件和CA根证书生成crt文件
openssl x509 -req -in etcd_server.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /root/etcd_ssl.cnf -out etcd_server.crt

3. 创建etcd client的CA证书

# 创建key文件
openssl genrsa -out etcd_client.key 2048

# 根据key文件和x509配置文件，生成一个csr中间文件。
openssl req -new -key etcd_client.key -config /root/etcd_ssl.cnf -subj "/CN=etcd-client" -out etcd_client.csr

# 根据csr中间文件和CA根证书生成crt文件
openssl x509 -req -in etcd_client.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /root/etcd_ssl.cnf -out etcd_client.crt

执行命令的最终效果：

4. 复制这些CA证书。
将master1节点上刚生成的etcd_server.key 、etcd_server.crt、etcd_client.key、etcd_client.crt这4个文件放到所有master节点的/etc/etcd/pki/目录下。

mkdir -p /etc/etcd/pki/
cp etcd_server.key /etc/etcd/pki/
cp etcd_server.crt /etc/etcd/pki/
cp etcd_client.key /etc/etcd/pki/
cp etcd_client.crt /etc/etcd/pki/
chmod -R +r /etc/etcd/pki/

将etcd注册成为systemd服务

每台master节点上执行以下步骤：

1. 解压

cd /root
tar -zxf etcd-v3.5.6-linux-amd64.tar.gz

解压后你能得到3个有执行权限的二进制命令和几个无用的README文件。
2. 复制

# 将etcd、etcdctl、etcdutl这3个二进制可执行文件复制到/usr/bin下
cd /root/etcd-v3.5.6-linux-amd64/
cp etcd /usr/bin/
cp etcdctl /usr/bin/
cp etcdutl /usr/bin/

3. 将/usr/bin/etcd命令注册成systemd服务（这样以后能用systemctl管理etcd了）
   写一个service文件：

vim /usr/lib/systemd/system/etcd.service
-------------------------------------------------------------
[Unit]
Description=etcd key-value store
Documentation=https://github.com/etcd-io/etcd
After=network.target

[Service]
EnvironmentFile=/etc/etcd/etcd.conf
ExecStart=/usr/bin/etcd
Restart=always

[Install]
WantedBy=multi-user.target

配置各master节点的etcd.conf

上一步中EnvironmentFile就是etcd的配置文件。每台master上的etcd.conf文件的配置格式都是一样的，可以用统一的模板去渲染和分发。各位读者中有熟悉ansible的，可以用ansible的template模块渲染出jinja2模板并分发给所有master。不会ansible的同学也不用担心，本文也给出了手动配置方案。

ansible配置各个master节点的etcd.conf

etcd.conf的jinja2模板：
vim /root/etcd.conf.j2

ETCD_NAME=etcd{{n}}
ETCD_DATA_DIR=/etc/etcd/data
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_CLIENT_CERT_AUTH=true
ETCD_LISTEN_CLIENT_URLS=https://{{ansible_ipv4_address}}:2379
ETCD_ADVERTISE_CLIENT_URLS=https://{{ansible_ipv4_address}}:2379
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_PEER_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_LISTEN_PEER_URLS=https://{{ansible_ipv4_address}}:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://{{ansible_ipv4_address}}:2380
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
ETCD_INITIAL_CLUSTER="etcd1=https://192.168.1.13:2380,etcd2=https://192.168.1.14:2380,etcd3=https://192.168.1.15:2380"
ETCD_INITIAL_CLUSTER_STATE=new

最后使用AD-hoc命令渲染分发模板，由于每台机器n不同，只能一台一台发。

ansible master01 -m template -a "src=/root/etcd.conf.j2 dest=/etc/etcd/etcd.conf mode=0644" -e n=1 -i /root/hosts
ansible master02 -m template -a "src=/root/etcd.conf.j2 dest=/etc/etcd/etcd.conf mode=0644" -e n=2 -i /root/hosts
ansible master03 -m template -a "src=/root/etcd.conf.j2 dest=/etc/etcd/etcd.conf mode=0644" -e n=3 -i /root/hosts

可以看出，每台机器配置变化的地方就是ETCD_NAME和URLS变量，另外ETCD_INITIAL_CLUSTER变量的值需要根据各位读者自己实际IP进行修改。

手动配置各个master节点的etcd.conf

master1上执行：
vim /etc/etcd/etcd.conf

ETCD_NAME=etcd1
ETCD_DATA_DIR=/etc/etcd/data
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_CLIENT_CERT_AUTH=true
ETCD_LISTEN_CLIENT_URLS=https://192.168.1.13:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.1.13:2379
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_PEER_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_LISTEN_PEER_URLS=https://192.168.1.13:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.1.13:2380
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
ETCD_INITIAL_CLUSTER="etcd1=https://192.168.1.13:2380,etcd2=https://192.168.1.14:2380,etcd3=https://192.168.1.15:2380"
ETCD_INITIAL_CLUSTER_STATE=new

master2上执行：
vim /etc/etcd/etcd.conf

ETCD_NAME=etcd2
ETCD_DATA_DIR=/etc/etcd/data
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_CLIENT_CERT_AUTH=true
ETCD_LISTEN_CLIENT_URLS=https://192.168.1.14:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.1.14:2379
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_PEER_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_LISTEN_PEER_URLS=https://192.168.1.14:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.1.14:2380
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
ETCD_INITIAL_CLUSTER="etcd1=https://192.168.1.13:2380,etcd2=https://192.168.1.14:2380,etcd3=https://192.168.1.15:2380"
ETCD_INITIAL_CLUSTER_STATE=new

master3上执行：
vim /etc/etcd/etcd.conf

ETCD_NAME=etcd3
ETCD_DATA_DIR=/etc/etcd/data
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_CLIENT_CERT_AUTH=true
ETCD_LISTEN_CLIENT_URLS=https://192.168.1.15:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.1.15:2379
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_PEER_TRUSTED_CA_FILE=/etc/kubernetes/pki/ca.crt
ETCD_LISTEN_PEER_URLS=https://192.168.1.15:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.1.15:2380
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
ETCD_INITIAL_CLUSTER="etcd1=https://192.168.1.13:2380,etcd2=https://192.168.1.14:2380,etcd3=https://192.168.1.15:2380"
ETCD_INITIAL_CLUSTER_STATE=new

启动etcd集群

CA、软件包、配置文件都搞定了以后，就可以启动了。
每台master节点上执行：

systemctl restart etcd && systemctl enable etcd

测试etcd集群是否可用，我们使用etcdctl命令，命令中的ip修改成自己实际的的：

etcdctl --cacert=/etc/kubernetes/pki/ca.crt --cert=/etc/etcd/pki/etcd_client.crt --key=/etc/etcd/pki/etcd_client.key --endpoints=https://192.168.1.13:2379,https://192.168.1.14:2379,https://192.168.1.15:2379 endpoint health

# 正常返回如下：
https://192.168.1.13:2379 is healthy: successfully committed proposal: took = 16.070854ms
https://192.168.1.15:2379 is healthy: successfully committed proposal: took = 17.297059ms
https://192.168.1.14:2379 is healthy: successfully committed proposal: took = 18.475506ms

截图庆祝：

deploy kube-apiserver

下载kubernetes全部二进制软件包

浏览器访问https://github.com/kubernetes/kubernetes/releases，点击你想要版本的CHANGELOG链接。截至目前的k8s最高版本是1.26，所以点击1.26的CHANGELOG，下载server binaries和node binaries。server包中有所有master组件，node包中有所有worker组件。

下载链接：
https://dl.k8s.io/v1.26.0/kubernetes-server-linux-amd64.tar.gz
https://dl.k8s.io/v1.26.0/kubernetes-node-linux-amd64.tar.gz
将server包放到所有master节点的/root下暂存。
将node包放到所有worker节点上暂存。
每台master节点上执行解压操作：

cd /root
tar -zxf kubernetes-server-linux-amd64.tar.gz

# 查看所有二进制包
ls /root/kubernetes/server/bin
apiextensions-apiserver  kube-apiserver             kube-apiserver.tar       kube-controller-manager.docker_tag  kube-log-runner  kube-proxy.docker_tag  kube-scheduler             kube-scheduler.tar  kubectl          kubelet
kube-aggregator          kube-apiserver.docker_tag  kube-controller-manager  kube-controller-manager.tar         kube-proxy       kube-proxy.tar         kube-scheduler.docker_tag  kubeadm             kubectl-convert  mounter

文件扩展名是.docker_tag表示组件的容器镜像tag，扩展名是.tar的表示镜像文件，如果二进制主程序文件损坏，你可以解压镜像文件获得正确的程序。不带扩展名的文件就是各个组件的主程序。
在安装etcd部分，各位已经体验过CA证书的创建、systemd服务注册、配置文件的分发、服务启动。所以接下来的所有组件安装都和etcd安装过程类似，本文不赘述了，越往后安装越轻松。

为kube-apiserver创建CA证书

在master01上完成CA证书的创建，创建完成后将CA证书分发到其他master节点上。

1. 编写x509 v3配置文件
   vim /root/master_ssl.cnf

[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name
[req_distinguished_name]

[v3_req]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster.local
DNS.5 = master01
DNS.6 = master02
DNS.7 = master03
IP.1 = 169.169.0.1
IP.2 = 192.168.1.100
IP.3 = 192.168.1.13
IP.4 = 192.168.1.14
IP.5 = 192.168.1.15

说明： DNS.1-4是Service Cluster IP 的各级域名，如果不了解Cluster IP的同学以后回过头再看，先写上。在阿里云上创建ACK的时候，这个域名可以自己网页上自定义的，网页上改动后这里的DNS配置就会跟着改变，进而影响Cluster IP的域名。DNS.5-7是master主机的主机名，如果你有不止3台master节点，那就接着往后延伸DNS.8。
IP.1是Cluster IP地址段的网关地址，默认地址段是169.169.0.0/16，公有云ACK在创建时也可以修改这个地址段。IP.2是k8s master的小负载均衡器的IP地址，有经验的k8s老手将它称之为VIP。IP.3-5是所有master节点的IP，如果你有不止3台master，则继续向下延伸。
2. 创建CA证书

openssl genrsa -out apiserver.key 2048

# 根据key文件和x509配置文件，生成一个csr中间文件。
openssl req -new -key apiserver.key -config /root/master_ssl.cnf -subj "/CN=kube-apiserver" -out apiserver.csr

# 根据csr中间文件和CA根证书生成crt文件
openssl x509 -req -in apiserver.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /root/master_ssl.cnf -out apiserver.crt

最后将CA证书分发到每台master节点上的/etc/kubernetes/pki/

cp apiserver.key /etc/kubernetes/pki/
cp apiserver.crt /etc/kubernetes/pki/

将kube-apiserver注册成systemd服务

以下操作在每台master上都执行

1. 复制二进制文件

cp /root/kubernetes/server/bin/kube-apiserver /usr/bin/

2. 编写service文件
   vim /usr/lib/systemd/system/kube-apiserver.service

[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/etc/kubernetes/apiserver.conf
ExecStart=/usr/bin/kube-apiserver $KUBE_API_ARGS
Restart=always

[Install]
WantedBy=multi-user.target

编写配置文件，记得修改并检查IP

以下操作在每台master上都执行
vim /etc/kubernetes/apiserver.conf

KUBE_API_ARGS="--insecure-port=0 \
--secure-port=6443 \
--tls-cert-file=/etc/kubernetes/pki/apiserver.crt \
--tls-private-key-file=/etc/kubernetes/pki/apiserver.key \
--client-ca-file=/etc/kubernetes/pki/ca.crt \
--apiserver-count=3 \
--endpoint-reconciler-type=master-count \
--etcd-servers=https://192.168.1.13:2379,https://192.168.1.14:2379,https://192.168.1.15:2379 \
--etcd-cafile=/etc/kubernetes/pki/ca.crt \
--etcd-certfile=/etc/etcd/pki/etcd_client.crt \
--etcd-keyfile=/etc/etcd/pki/etcd_client.key \
--service-cluster-ip-range=169.169.0.0/16 \
--service-node-port-range=30000-32767 \
--allow-privileged=true \
--logtostderr=false \ 
--log-dir=/var/log/kubernetes
--v=0"

启动apiserver

以下操作在每台master上都执行

systemctl start kube-apiserver && systemctl enable kube-apiserver

apiserver是否启动成功的检查步骤就是下面的client CA and kubeconfig。

client CA and kubeconfig

deploy kube-controller-manager

deploy kube-scheduler

haproxy and keepalived

docker installation

deploy kubelet

deploy kubeproxy

calico CNI

coreDNS

load balance

ingress

check k8s