二进制安装部署kubernetes集群---超详细教程

前言：本篇博客是博主踩过无数坑，反复查阅资料，一步步搭建完成后整理的个人心得，分享给大家~~~

本文所需的安装包，都上传在我的网盘中，需要的可以打赏博主一杯咖啡钱，然后私密博主，博主会很快答复呦~

00.组件版本和配置策略

00-01.组件版本

• Kubernetes 1.10.4
• Docker 18.03.1-ce
• Etcd 3.3.7
• Flanneld 0.10.0
• 插件：
  • Coredns
  • Dashboard
  • Heapster (influxdb、grafana)
  • Metrics-Server
  • EFK (elasticsearch、fluentd、kibana)
• 镜像仓库：
  • docker registry
  • harbor

00-02.主要配置策略

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 的安全端口；

kubelet：

• 使用 kubeadm 动态创建 bootstrap token，而不是在 apiserver 中静态配置；
• 使用 TLS bootstrap 机制自动生成 client 和 server 证书，过期后自动轮转；
• 在 KubeletConfiguration 类型的 JSON 文件配置主要参数；
• 关闭只读端口，在安全端口 10250 接收 https 请求，对请求进行认证和授权，拒绝匿名访问和非授权访问；
• 使用 kubeconfig 访问 apiserver 的安全端口；

kube-proxy：

• 使用 kubeconfig 访问 apiserver 的安全端口；
• 在 KubeProxyConfiguration 类型的 JSON 文件配置主要参数；
• 使用 ipvs 代理模式；

集群插件：

• DNS：使用功能、性能更好的 coredns；
• Dashboard：支持登录认证；
• Metric：heapster、metrics-server，使用 https 访问 kubelet 安全端口；
• Log：Elasticsearch、Fluend、Kibana；
• Registry 镜像库：docker-registry、harbor；

01.系统初始化

01-01.集群机器

• kube-master：192.168.10.108
• kube-node1：192.168.10.109
• kube-node2：192.168.10.110

本文档中的 etcd 集群、master 节点、worker 节点均使用这三台机器。

在每个服务器上都要执行以下全部操作,如果没有特殊指明，本文档的所有操作均在kube-master 节点上执行

01-02.主机名

1、设置永久主机名称，然后重新登录

$ sudo hostnamectl set-hostname kube-master

$ sudo hostnamectl set-hostname kube-node1

$ sudo hostnamectl set-hostname kube-node2

2、修改 /etc/hostname 文件，添加主机名和 IP 的对应关系：

$ vim /etc/hosts

192.168.10.108 kube-master

192.168.10.109 kube-node1

192.168.10.110 kube-node2

01-03.添加 k8s 和 docker 账户

1、在每台机器上添加 k8s 账户

$ sudo useradd -m k8s

$ sudo sh -c \'echo along |passwd k8s --stdin\' #为k8s 账户设置密码

2、修改visudo权限

$ sudo visudo #去掉%wheel ALL=(ALL) NOPASSWD: ALL这行的注释

$ sudo grep \'%wheel.*NOPASSWD: ALL\' /etc/sudoers

%wheel ALL=(ALL) NOPASSWD: ALL

3、将k8s用户归到wheel组

$ gpasswd -a k8s wheel

Adding user k8s to group wheel

$ id k8s

uid=1000(k8s) gid=1000(k8s) groups=1000(k8s),10(wheel)

4、在每台机器上添加 docker 账户，将 k8s 账户添加到 docker 组中，同时配置 dockerd 参数（注：安装完docker才有）：

$ sudo useradd -m docker

$ sudo gpasswd -a k8s docker

$ sudo mkdir -p /opt/docker/

$ vim /opt/docker/daemon.json   #可以后续部署docker时在操作

{

　　\"registry-mirrors\": [\"https://hub-mirror.c.163.com\", \"https://docker.mirrors.ustc.edu.cn\"],

　　\"max-concurrent-downloads\": 20

}

01-04.无密码 ssh 登录其它节点

1、生成秘钥对

[root@kube-master ~]# ssh-keygen #连续回车即可

2、将自己的公钥发给其他服务器

[root@kube-master ~]# ssh-copy-id root@kube-master

[root@kube-master ~]# ssh-copy-id root@kube-node1

[root@kube-master ~]# ssh-copy-id root@kube-node2

[root@kube-master ~]# ssh-copy-id k8s@kube-master

[root@kube-master ~]# ssh-copy-id k8s@kube-node1

[root@kube-master ~]# ssh-copy-id k8s@kube-node2

01-05.将可执行文件路径 /opt/k8s/bin 添加到 PATH 变量

在每台机器上添加环境变量：

$ sudo sh -c \"echo \'PATH=/opt/k8s/bin:$PATH:$HOME/bin:$JAVA_HOME/bin\' >> /etc/profile.d/k8s.sh\"

$ source /etc/profile.d/k8s.sh

01-06.安装依赖包

在每台机器上安装依赖包：

CentOS:

$ sudo yum install -y epel-release

$ sudo yum install -y conntrack ipvsadm ipset jq sysstat curl iptables libseccomp

Ubuntu:

$ sudo apt-get install -y conntrack ipvsadm ipset jq sysstat curl iptables libseccomp

注：ipvs 依赖 ipset；

01-07.关闭防火墙

在每台机器上关闭防火墙：

① 关闭服务，并设为开机不自启

$ sudo systemctl stop firewalld

$ sudo systemctl disable firewalld

② 清空防火墙规则

$ sudo iptables -F && sudo iptables -X && sudo iptables -F -t nat && sudo iptables -X -t nat

$ sudo iptables -P FORWARD ACCEPT

01-08.关闭 swap 分区

1、如果开启了 swap 分区，kubelet 会启动失败(可以通过将参数 --fail-swap-on 设置为false 来忽略 swap on)，故需要在每台机器上关闭 swap 分区：

$ sudo swapoff -a

2、为了防止开机自动挂载 swap 分区，可以注释 /etc/fstab 中相应的条目：

$ sudo sed -i \'/ swap / s/^\\(.*\\)$/#\\1/g\' /etc/fstab

01-09.关闭 SELinux

1、关闭 SELinux，否则后续 K8S 挂载目录时可能报错 Permission denied ：

$ sudo setenforce 0

2、修改配置文件，永久生效；

$ grep SELINUX /etc/selinux/config

SELINUX=disabled

01-10.关闭 dnsmasq (可选)

linux 系统开启了 dnsmasq 后(如 GUI 环境)，将系统 DNS Server 设置为 127.0.0.1，这会导致 docker 容器无法解析域名，需要关闭它：

$ sudo service dnsmasq stop

$ sudo systemctl disable dnsmasq

01-11.加载内核模块

$ sudo modprobe br_netfilter

$ sudo modprobe ip_vs

01-12.设置系统参数

$ 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

$ sudo cp kubernetes.conf /etc/sysctl.d/kubernetes.conf

$ sudo sysctl -p /etc/sysctl.d/kubernetes.conf

$ sudo mount -t cgroup -o cpu,cpuacct none /sys/fs/cgroup/cpu,cpuacct

注：

• tcp_tw_recycle 和 Kubernetes 的 NAT 冲突，必须关闭 ，否则会导致服务不通；
• 关闭不使用的 IPV6 协议栈，防止触发 docker BUG；

01-13.设置系统时区

1、调整系统 TimeZone

$ sudo timedatectl set-timezone Asia/Shanghai

2、将当前的 UTC 时间写入硬件时钟

$ sudo timedatectl set-local-rtc 0

3、重启依赖于系统时间的服务

$ sudo systemctl restart rsyslog

$ sudo systemctl restart crond

01-14.更新系统时间

$ yum -y install ntpdate

$ sudo ntpdate cn.pool.ntp.org

01-15.创建目录

在每台机器上创建目录：

$ sudo mkdir -p /opt/k8s/bin

$ sudo mkdir -p /opt/k8s/cert

$ sudo mkdir -p /opt/etcd/cert

$ sudo mkdir -p /opt/lib/etcd

$ sudo mkdir -p /opt/k8s/

$ chown -R k8s /opt/*

01-16.检查系统内核和模块是否适合运行 docker (仅适用于linux 系统)

$ curl https://raw.githubusercontent.com/docker/docker/master/contrib/check-config.sh > check-config.sh

$ chmod +x check-config.sh

$ bash ./check-config.sh

02.创建 CA 证书和秘钥

• 为确保安全， kubernetes 系统各组件需要使用 x509 证书对通信进行加密和认证。
• CA (Certificate Authority) 是自签名的根证书，用来签名后续创建的其它证书。

本文档使用 CloudFlare 的 PKI 工具集 cfssl 创建所有证书。

02-01.安装 cfssl 工具集

mkdir -p /opt/k8s/cert && sudo chown -R k8s /opt/k8s && cd /opt/k8s

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64

mv cfssl_linux-amd64 /opt/k8s/bin/cfssl

wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64

mv cfssljson_linux-amd64 /opt/k8s/bin/cfssljson

wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

mv cfssl-certinfo_linux-amd64 /opt/k8s/bin/cfssl-certinfo

chmod +x /opt/k8s/bin/*

02-02.创建根证书 (CA)

CA 证书是集群所有节点共享的，只需要创建一个 CA 证书，后续创建的所有证书都由它签名。

02-02-01 创建配置文件

CA 配置文件用于配置根证书的使用场景 (profile) 和具体参数 (usage，过期时间、服务端认证、客户端认证、加密等)，后续在签名其它证书时需要指定特定场景。

[root@kube-master ~]# cd /opt/k8s/cert

[root@kube-master cert]# vim ca-config.json

{
    \"signing\": {
        \"default\": {
            \"expiry\": \"87600h\"
        },
        \"profiles\": {
            \"kubernetes\": {
                \"usages\": [
                    \"signing\",
                    \"key encipherment\",
                    \"server auth\",
                    \"client auth\"
                ],
                \"expiry\": \"87600h\"
            }
        }
    }
}

注：

① signing ：表示该证书可用于签名其它证书，生成的 ca.pem 证书中CA=TRUE ；

② server auth ：表示 client 可以用该该证书对 server 提供的证书进行验证；

③ client auth ：表示 server 可以用该该证书对 client 提供的证书进行验证；

02-02-02 创建证书签名请求文件

[root@kube-master cert]# vim ca-csr.json

{
    \"CN\": \"kubernetes\",
    \"key\": {
        \"algo\": \"rsa\",
        \"size\": 2048
    },
    \"names\": [
        {
            \"C\": \"CN\",
            \"ST\": \"BeiJing\",
            \"L\": \"BeiJing\",
            \"O\": \"k8s\",
            \"OU\": \"4Paradigm\"
        }
    ]
}

注：

① CN： Common Name ，kube-apiserver 从证书中提取该字段作为请求的用户名(User Name)，浏览器使用该字段验证网站是否合法；

② O： Organization ，kube-apiserver 从证书中提取该字段作为请求用户所属的组(Group)；

③ kube-apiserver 将提取的 User、Group 作为 RBAC 授权的用户标识；

02-02-03 生成 CA 证书和私钥

[root@kube-master cert]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca

[root@kube-master cert]# ls

ca-config.json ca.csr ca-csr.json ca-key.pem ca.pem

02-02-04 分发证书文件

将生成的 CA 证书、秘钥文件、配置文件拷贝到所有节点的/opt/k8s/cert 目录下：

[root@kube-master ~]# vim /opt/k8s/ /scp_k8scert.sh

NODE_IPS=(\"192.168.10.108\" \"192.168.10.109\" \"192.168.10.110\")
for node_ip in ${NODE_IPS[@]};do
    echo \">>> ${node_ip}\"
    ssh root@${node_ip} \"mkdir -p /opt/k8s/cert && chown -R k8s /opt/k8s\"
    scp /opt/k8s/cert/ca*.pem /opt/k8s/cert/ca-config.json k8s@${node_ip}:/opt/k8s/cert
done

[root@kube-master ~]# chmod +x /opt/k8s/ /scp_k8scert.sh && /opt/k8s/ /scp_k8scert.sh

03.部署 kubectl 命令行工具

　　kubectl 是 kubernetes 集群的命令行管理工具，本文档介绍安装和配置它的步骤。

　　kubectl 默认从 ~/.kube/config 文件读取 kube-apiserver 地址、证书、用户名等信息，如果没有配置，执行 kubectl 命令时可能会出错：

$ kubectl get pods

The connection to the server localhost:8080 was refused - did you specify the right host or port?

本文档只需要部署一次，生成的 kubeconfig 文件与机器无关。

03-01.下载kubectl 二进制文件

下载和解压

kubectl二进制文件需要科学上网下载，我已经下载到我的网盘，有需要的小伙伴联系我~

[root@kube-master ~]# wget https://dl.k8s.io/v1.10.4/kubernetes-client-linux-amd64.tar.gz

[root@kube-master ~]# tar -xzvf kubernetes-client-linux-amd64.tar.gz

03-02.创建 admin 证书和私钥

• kubectl 与 apiserver https 安全端口通信，apiserver 对提供的证书进行认证和授权。
• kubectl 作为集群的管理工具，需要被授予最高权限。这里创建具有最高权限的admin 证书。

03-02-01 创建证书签名请求

[root@kube-master ~]# cd /opt/k8s/cert/

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\"
        }
    ]
}

注：

① O 为 system:masters ，kube-apiserver 收到该证书后将请求的 Group 设置为system:masters；

② 预定义的 ClusterRoleBinding cluster-admin 将 Group system:masters 与Role cluster-admin 绑定，该 Role 授予所有 API的权限；

③ 该证书只会被 kubectl 当做 client 证书使用，所以 hosts 字段为空；

03-02-02 生成证书和私钥

[root@kube-master cert]# cfssl gencert -ca=/opt/k8s/cert/ca.pem \\

-ca-key=/opt/k8s/cert/ca-key.pem \\

-config=/opt/k8s/cert/ca-config.json \\

-profile=kubernetes admin-csr.json | cfssljson_linux-amd64 -bare admin

[root@kube-master cert]# ls admin*

admin.csr admin-csr.json admin-key.pem admin.pem

03-03.创建和分发 kubeconfig 文件

03-03-01 创建kubeconfig文件

kubeconfig 为 kubectl 的配置文件，包含访问 apiserver 的所有信息，如 apiserver 地址、CA 证书和自身使用的证书；

① 设置集群参数，（--server=${KUBE_APISERVER} ，指定IP和端口；我使用的是haproxy的VIP和端口；如果没有haproxy代理，就用实际服务的IP和端口；如：https://192.168.10.108:6443）

[root@kube-master ~]# kubectl config set-cluster kubernetes \\

--certificate-authority=/opt/k8s/cert/ca.pem \\

-- -certs=true \\

--server=https://192.168.10.10:8443 \\

--kubeconfig=/root/.kube/kubectl.kubeconfig

② 设置客户端认证参数

[root@kube-master ~]# kubectl config set-credentials kube-admin \\

--client-certificate=/opt/k8s/cert/admin.pem \\

--client-key=/opt/k8s/cert/admin-key.pem \\

-- -certs=true \\

--kubeconfig=/root/.kube/kubectl.kubeconfig

③ 设置上下文参数

[root@kube-master ~]# kubectl config set-context kube-admin@kubernetes \\

--cluster=kubernetes \\

--user=kube-admin \\

--kubeconfig=/root/.kube/kubectl.kubeconfig

④ 设置默认上下文

[root@kube-master ~]# kubectl config use-context kube-admin@kubernetes --kubeconfig=/root/.kube/kubectl.kubeconfig

注：在后续kubernetes认证，文章中会详细讲解

• --certificate-authority ：验证 kube-apiserver 证书的根证书；
• --client-certificate 、 --client-key ：刚生成的 admin 证书和私钥，连接 kube-apiserver 时使用；
• -- -certs=true ：将 ca.pem 和 admin.pem 证书内容嵌入到生成的kubectl.kubeconfig 文件中(不加时，写入的是证书文件路径)；

[root@kube-master ~]# chmod +x /opt/k8s/ /kubectl_environment.sh && /opt/k8s/ /kubectl_environment.sh

03-03-01 验证kubeconfig文件

[root@kube-master ~]# ls /root/.kube/kubectl.kubeconfig

/root/.kube/kubectl.kubeconfig

[root@kube-master ~]# kubectl config view --kubeconfig=/root/.kube/kubectl.kubeconfig

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: REDACTED
    server: https://192.168.10.10:8443
  name: kubernetes
contexts:
- context:
    cluster: kubernetes
    user: kube-admin
  name: kube-admin@kubernetes
current-context: kube-admin@kubernetes
kind: Config
preferences: {}
users:
- name: kube-admin
  user:
    client-certificate-data: REDACTED
    client-key-data: REDACTED

03-03-03 分发 kubeclt 和kubeconfig 文件，分发到所有使用kubectl 命令的节点

[root@kube-master ~]# vim /opt/k8s/ /scp_kubectl.sh

NODE_IPS=(\"192.168.10.108\" \"192.168.10.109\" \"192.168.10.110\")

NODE_IPS=(\"192.168.10.108\" \"192.168.10.109\" \"192.168.10.110\")
for node_ip in ${NODE_IPS[@]};do
    echo \">>> ${node_ip}\"
    scp /root/kubernetes/client/bin/kubectl k8s@${node_ip}:/opt/k8s/bin/
    ssh k8s@${node_ip} \"chmod +x /opt/k8s/bin/*\"
    ssh k8s@${node_ip} \"mkdir -p ~/.kube\"
    scp ~/.kube/config k8s@${node_ip}:~/.kube/config
    ssh root@${node_ip} \"mkdir -p ~/.kube\"
    scp ~/.kube/config root@${node_ip}:~/.kube/config
done

[root@kube-master ~]# chmod +x /opt/k8s/ /scp_kubectl.sh && /opt/k8s/ /scp_kubectl.sh

04.部署 etcd 集群

　　etcd 是基于 Raft 的分布式 key-value 存储系统，由 CoreOS 开发，常用于服务发现、共享配置以及并发控制（如 leader 选举、分布式锁等）。kubernetes 使用 etcd 存储所有运行数据。

本文档介绍部署一个三节点高可用 etcd 集群的步骤：

① 下载和分发 etcd 二进制文件

② 创建 etcd 集群各节点的 x509 证书，用于加密客户端(如 etcdctl) 与 etcd 集群、etcd 集群之间的数据流；

③ 创建 etcd 的 systemd unit 文件，配置服务参数；

④ 检查集群工作状态；

04-01.下载etcd 二进制文件

到 https://github.com/coreos/etcd/releases 页面下载最新版本的发布包：

[root@kube-master ~]# https://github.com/coreos/etcd/releases/download/v3.3.7/etcd-v3.3.7-linux-amd64.tar.gz

[root@kube-master ~]# tar -xvf etcd-v3.3.7-linux-amd64.tar.gz

04-02.创建 etcd 证书和私钥

04-02-01 创建证书签名请求

[root@kube-master ~]# cd /opt/etcd/cert

[root@kube-master cert]# cat > etcd-csr.json <<EOF

{
    \"CN\": \"etcd\",
    \"hosts\": [
        \"127.0.0.1\",
        \"192.168.10.108\",
        \"192.168.10.109\",
        \"192.168.10.110\"
    ],
    \"key\": {
        \"algo\": \"rsa\",
        \"size\": 2048
    },
    \"names\": [
        {
            \"C\": \"CN\",
            \"ST\": \"BeiJing\",
            \"L\": \"BeiJing\",
            \"O\": \"k8s\",
            \"OU\": \"4Paradigm\"
        }
    ]
}

EOF

注：hosts 字段指定授权使用该证书的 etcd 节点 IP 或域名列表，这里将 etcd 集群的三个节点 IP 都列在其中；

04-02-02 生成证书和私钥

[root@kube-master cert]# cfssl gencert -ca=/opt/k8s/cert/ca.pem \\

-ca-key=/opt/k8s/cert/ca-key.pem \\

-config=/opt/k8s/cert/ca-config.json \\

-profile=kubernetes etcd-csr.json | cfssljson_linux-amd64 -bare etcd

[root@kube-master cert]# ls etcd*

etcd.csr etcd-csr.json etcd-key.pem etcd.pem

04-02-03 分发生成的证书和私钥到各 etcd 节点

[root@kube-master ~]# vim /opt/k8s/ /scp_etcd.sh

NODE_IPS=(\"192.168.10.108\" \"192.168.10.109\" \"192.168.10.110\")

for node_ip in ${NODE_IPS[@]};do
        echo \">>> ${node_ip}\"
        scp /root/etcd-v3.3.7-linux-amd64/etcd* k8s@${node_ip}:/opt/k8s/bin
        ssh k8s@${node_ip} \"chmod +x /opt/k8s/bin/*\"
        ssh root@${node_ip} \"mkdir -p /opt/etcd/cert && chown -R k8s /opt/etcd/cert\"
        scp /opt/etcd/cert/etcd*.pem k8s@${node_ip}:/opt/etcd/cert/
done

04-03.创建etcd 的systemd unit 模板及etcd 配置文件

04-03-01 创建etcd 的systemd unit 模板

[root@kube-master ~]# cat > /opt/etcd/etcd.service.template <<EOF

[Unit]
De ion=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
Documentation=https://github.com/coreos
[Service]
User=k8s
Type=notify
WorkingDirectory=/opt/lib/etcd/
ExecStart=/opt/k8s/bin/etcd \\
    --data-dir=/opt/lib/etcd \\
    --name ##NODE_NAME## \\
    --cert-file=/opt/etcd/cert/etcd.pem \\
    --key-file=/opt/etcd/cert/etcd-key.pem \\
    --trusted-ca-file=/opt/k8s/cert/ca.pem \\
    --peer-cert-file=/opt/etcd/cert/etcd.pem \\
    --peer-key-file=/opt/etcd/cert/etcd-key.pem \\
    --peer-trusted-ca-file=/opt/k8s/cert/ca.pem \\
    --peer-client-cert-auth \\
    --client-cert-auth \\
    --listen-peer-urls=https://##NODE_IP##:2380 \\
    --initial-advertise-peer-urls=https://##NODE_IP##:2380 \\
    --listen-client-urls=https://##NODE_IP##:2379,http://127.0.0.1:2379\\
    --advertise-client-urls=https://##NODE_IP##:2379 \\
    --initial-cluster-token=etcd-cluster-0 \\
    --initial-cluster=etcd0=https://192.168.10.108:2380,etcd1=https://192.168.10.109:2380,etcd2=https://192.168.10.110:2380 \\
    --initial-cluster-state=new
Restart=on-failure
RestartSec=5
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target

EOF

注：

• User ：指定以 k8s 账户运行；
• WorkingDirectory 、 --data-dir ：指定工作目录和数据目录为/opt/lib/etcd ，需在启动服务前创建这个目录；
• --name ：指定节点名称，当 --initial-cluster-state 值为 new 时， --name 的参数值必须位于 --initial-cluster 列表中；
• --cert-file 、 --key-file ：etcd server 与 client 通信时使用的证书和私钥；
• --trusted-ca-file ：签名 client 证书的 CA 证书，用于验证 client 证书；
• --peer-cert-file 、 --peer-key-file ：etcd 与 peer 通信使用的证书和私钥；
• --peer-trusted-ca-file ：签名 peer 证书的 CA 证书，用于验证 peer 证书；

04-04.为各节点创建和分发 etcd systemd unit 文件

[root@kube-master ~]# cd /opt/k8s/

[root@kube-master ]# vim etcd_service.sh

NODE_NAMES=(\"etcd0\" \"etcd1\" \"etcd2\")
NODE_IPS=(\"

					

						
继续阅读与本文标签相同的文章
						

														无标签