思享工具箱

k8s集群安装（单节点）

摘要：
一、环境说明1.1、主机清单节点IP主机名安装软件备注Master10.199.142.31k8sm1etcdkube-apiserverkube-controller-managerkube-schedulerkubectl安装在此机器Master10.199.142.32k8sm2etcd集群安装用，单节点不用Master10.199.142.33k8sm3etcd集群安装用，单节点不用Nod
一、环境说明

1.1、主机清单

节点IP主机名安装软件备注
Master10.199.142.31k8sm1etcdkube-apiserver kube-controller-manager kube-schedulerkubectl安装在此机器
Master10.199.142.32k8sm2etcd集群安装用，单节点不用
Master10.199.142.33k8sm3etcd集群安装用，单节点不用
Node10.199.142.34k8sn1docker kubelet kube-proxy
Node10.199.142.35k8sn2docker kubelet kube-proxy

1.2、操作路径

路径说明备注
/root/k8s/放置安装时文件和脚本
/opt/etcd/{cfg,bin,ssl,logs}

etcd的安装位置

cfg是配置目录

bin是执行目录

ssl是证书目录

logs是日志目录

/opt/k8s/{cfg,bin,ssl,logs}

kubernetes的安装位置

1.3、资源下载

  • cfssl：https://pkg.cfssl.org/
# 本次安装下载链接（版本 1.2）：
https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
  • etcd：https://github.com/etcd-io/etcd/releases
# 本次安装下载链接（版本 3.4.15）：
https://github-releases.githubusercontent.com/11225014/f051cf00-7842-11eb-99a4-97cc3ddb6816?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20210317%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20210317T040208Z&X-Amz-Expires=300&X-Amz-Signature=e9bd4970e97c34547807d8616d8b71e51121fa589707fbce4ac9ba71e1656cec&X-Amz-SignedHeaders=host&actor_id=16606154&key_id=0&repo_id=11225014&response-content-disposition=attachment%3B%20filename%3Detcd-v3.4.15-linux-amd64.tar&response-content-type=application%2Foctet-stream
  • k8s：https://github.com/kubernetes/kubernetes/releases （tip：点击对应版本的CHANGELOG）
# 本次安装下载链接（版本 1.20.4）：
https://storage.googleapis.com/kubernetes-release/release/v1.20.4/kubernetes-server-linux-amd64.tar.gz

下载文件汇总，默认放在部署服务器的 /root/k8s/ 目录下：

cfssl_linux-amd64
cfssl-certinfo_linux-amd64
cfssljson_linux-amd64
etcd-v3.4.15-linux-amd64.tar
kubernetes-server-linux-amd64.tar.gz
二、主机准备工作

（没有特别说明，所有节点主机都执行！）

2.1、设置主机名

（在对应主机上执行对应命令）

hostnamectl set-hostnamek8sm1
hostnamectl set-hostnamek8sm2
hostnamectl set-hostnamek8sm3
hostnamectl set-hostnamek8sn1
hostnamectl set-hostname k8sn2

2.2、修改hosts

cat >> /etc/hosts <<EOF
10.199.142.31 k8sm1
10.199.142.32 k8sm2
10.199.142.33 k8sm3
10.199.142.34 k8sn1
10.199.142.35 k8sn2
EOF

2.3、修改时区 同步时间

timedatectl set-timezone Asia/Shanghai
# 如果没有ntpdate命令，则安装：yum install ntpdate -y
ntpdate pool.ntp.org

2.4、关闭selinux

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
setenforce 0

2.5、关闭防火墙

systemctl disable firewalld
systemctl stop firewalld

2.6、关闭swap

swapoff -a
vim /etc/fstab (注释或删除swap行，永久关闭)

2.7、ssh互信

（在k8sm1节点上，免密ssh任何一台机器！）

# 只在Master节点上执行即可，主要用于分发文件和远程执行命令
NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33" "10.199.142.34" "10.199.142.35")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    ssh-copy-id -i ~/.ssh/id_rsa.pub root@${node_ip}
done

2.8、安装docker

（在node节点上安装）

# 下载软件源
wget -O /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 安装docker-ce，也可下载指定的docekr-ce的docker (低版本的docker 无法支持高版本的kubernetes)
yum -y install docker-ce
# 或指定版本安装（选择一种即可）
yum -y install docker-ce-18.09.1-3.el7

# 设置Docker镜像加速器
mkdir -p /etc/docker/
cat > /etc/docker/daemon.json <<EOF
{
 "exec-opts":["native.cgroupdriver=systemd"],
 "registry-mirrors": ["http://hub-mirror.c.163.com"]
}
EOF

# 开启docker，并开机自启动
systemctl start docker & systemctl enable docker

2.9、将桥接的IPv4流量传递到iptables的链

cat > /etc/sysctl.d/k8s.conf << EOF
net.ipv4.ip_nonlocal_bind = 1    
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_local_port_range = 10000 65000
fs.file-max = 2000000
vm.swappiness = 0
EOF

# 加载br_netfilter模块
modprobe br_netfilter

# 查看是否加载
lsmod | grep br_netfilter

# 生效
sysctl --system

2.10、建安装文件夹

（在k8sm1节点上执行）

# 所有节点建立k8s、安装目录
NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33" "10.199.142.34" "10.199.142.35")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /root/k8s/ssl && mkdir -p /opt/k8s/{cfg,bin,ssl,logs}"
done
# Master节点建立etcd安装目录
NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkdir -p /opt/etcd/{cfg,bin,ssl}"
done
三、创建CA证书、密钥

3.1、安装证书制作工具

安装脚本（/root/k8s/install_cfssl.sh），内容如下：

# install_cfssl.sh
# cfssl：生成证书工具
# cfssljson：通过传入json文件生成证书
# cfssl-certinfo：查看证书信息

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

chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson /usr/local/bin/cfssl-certinfo

echo ">>> 安装结果"
ls -trl /usr/local/bin/cfssl*

安装cfssl：

[root@k8sm1 k8s]# sh install_cfssl.sh

3.2、制作根证书

3.2.1、创建CA证书配置文件

创建默认文件：

[root@k8sm1 ssl]# cfssl print-defaults config > ca-config.json

默认创建出的文件内容（需要修改）：

View Code

修改后内容：

# 终版 /root/k8s/ssl/ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "87600h"
      }
    }
  }
}
  • config.json：可以定义多个profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个profile；
  • signing: 表示该证书可用于签名其它证书；生成的ca.pem 证书中CA=TRUE；
  • server auth: 表示client 可以用该CA 对server 提供的证书进行校验；
  • client auth: 表示server 可以用该CA 对client 提供的证书进行验证；

3.2.2、创建CA证书签名请求文件

创建默认文件：

[root@k8sm1 k8s]# cfssl print-defaults csr > ca-csr.json

默认创建出的文件内容（需要修改）：

View Code

修改后内容：

# 终版 /root/k8s/ssl/ca-csr.json 
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
    ]
}
  • CN: Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名(User Name)；浏览器使用该字段验证网站是否合法；
  • O: Organization，kube-apiserver 从证书中提取该字段作为请求用户所属的组(Group)；

3.2.3、生成证书（ca.pem）和秘钥（ca-key.pem）

[root@k8sm1 ssl]#cfssl gencert -initca ca-csr.json | cfssljson -bare ca

结果：

上面生成的证书文件存放在k8sm1的/root/k8s/ssl

-rw-r--r-- 1 root root 292 3月 17 20:40 ca-config.json
-rw-r--r-- 1 root root 254 3月 17 20:40 ca-csr.json
# ca.csr是一个签署请求
-rw-r--r--  1 root root 1001 3月  17 20:42 ca.csr
# ca-key.pem是ca的私钥
-rw-------  1 root root 1679 3月  17 20:42 ca-key.pem
# ca.pem是CA证书
-rw-r--r--  1 root root 1359 3月  17 20:42 ca.pem
四、集群环境变量

4.1、预设环境网段及变量

环境变量脚本（/root/k8s/env.sh），内容如下：

export PATH=/opt/k8s/bin:/opt/etcd/bin:$PATH

# TLS Bootstrapping 使用的Token，
# 可以使用命令生成，命令： head -c 16 /dev/urandom | od -An -t x | tr -d ' 'BOOTSTRAP_TOKEN="555898ed9c5d0ba16cf76fec2c8f94ef"
# 服务网段(Service CIDR)，集群内部使用IP:Port
SERVICE_CIDR="10.200.0.0/16"# Pod 网段(Cluster CIDR)
CLUSTER_CIDR="10.100.0.0/16"
# 服务端口范围(NodePort Range)
NODE_PORT_RANGE="30000-32766"
# etcd 集群所有机器 IP
ECTD_IPS="10.199.142.31,10.199.142.32,10.199.142.33"
# etcd集群服务地址列表
ETCD_ENDPOINTS="https://10.199.142.31:2379,https://10.199.142.32:2379,https://10.199.142.33:2379"
# etcd 集群间通信的IP和端口
ECTD_NODES="etcd01=https://10.199.142.31:2380,etcd02=https://10.199.142.32:2380,etcd03=https://10.199.142.33:2380"
# flanneld 网络配置前缀
FLANNEL_ETCD_PREFIX="/kubernetes/network"
# kubernetes 服务IP(预先分配，一般为SERVICE_CIDR中的第一个IP)
CLUSTER_KUBERNETES_SVC_IP="10.200.0.1"
# 集群 DNS 服务IP(从SERVICE_CIDR 中预先分配)
CLUSTER_DNS_SVC_IP="10.200.0.2"
# 集群 DNS 域名
CLUSTER_DNS_DOMAIN="cluster.local"
# MASTER API Server 地址
#MASTER_URL="k8s-api.virtual.local"MASTER_URL="10.199.142.31"

4.2、分发环境变量配置

（在k8sm1节点上执行）

NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33" "10.199.142.34" "10.199.142.35")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    scp /root/k8s/env.sh root@${node_ip}:/root/k8s/
done
五、部署etcd

5.1、下载etcd

[root@k8sm1 k8s]# tar -xvf etcd-v3.4.15-linux-amd64.tar
[root@k8sm1 k8s]# cd etcd-v3.4.15-linux-amd64
[root@k8sm1 etcd-v3.4.15-linux-amd64]# mv etcd etcdctl /opt/etcd/bin/

5.2、创建etcd证书

  • 创建etcd证书签名请求文件

cat > /root/k8s/ssl/etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "10.199.142.31",
    "10.199.142.32",
    "10.199.142.33"],
  "key": {
    "algo": "rsa",
    "size": 2048},
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"}
  ]
}
EOF

Tip：hosts 字段指定授权使用该证书的etcd节点集群IP。

  • 生成证书

[root@k8sm1 ssl]# cd /root/k8s/ssl
[root@k8sm1 ssl]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare etcd 
[root@k8sm1 ssl]# cp ca*.pem etcd*.pem /opt/etcd/ssl/

5.3、编写etcd安装脚本

etcd安装脚本（/root/k8s/install_etcd.sh），内容如下：

#!/usr/bin/bash
# example: ./install_etcd.sh etcd01 10.199.142.31
# 参数，当前etcd的名字，IP
ETCD_NAME=$1ETCD_IP=$2# etcd安装路径
WORK_DIR=/opt/etcd
# 数据存放路径
DATA_DIR=/var/lib/etcd/default.etcd

# 加载预设变量
source /root/k8s/env.sh
# 创建节点的配置文件模板
cat >$WORK_DIR/cfg/etcd.conf <<EOF
# [Member]
ETCD_NAME="${ETCD_NAME}"ETCD_DATA_DIR="${DATA_DIR}"ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"
# [Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"ETCD_INITIAL_CLUSTER="${ECTD_NODES}"ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"ETCD_INITIAL_CLUSTER_STATE="new"EOF

# 创建节点的启动脚本模板
cat >/usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd.conf
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/etcd.pem \
--key-file=${WORK_DIR}/ssl/etcd-key.pem \
--peer-cert-file=${WORK_DIR}/ssl/etcd.pem \
--peer-key-file=${WORK_DIR}/ssl/etcd-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
  • 指定etcd的工作目录和数据目录为/var/lib/etcd，需要在启动服务前创建这个目录；
  • 为了保证通信安全，需要指定etcd 的公私钥(cert-file和key-file)、Peers通信的公私钥和CA 证书(peer-cert-file、peer-key-file、peer-trusted-ca-file)、客户端的CA 证书(trusted-ca-file)；
  • --initial-cluster-state值为new时，--name的参数值必须位于--initial-cluster列表中；

5.4、分发、启动etcd服务

  • 执行脚本（此时服务还未起好，会报错，因为是集群，检测不到其他节点）
[root@hz-yf-xtax-it-199-142-31 k8s]# sh install_etcd.sh etcd01 10.199.142.31
  • 分发
NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    scp -r /opt/etcd/ root@${node_ip}:/opt/
    scp /usr/lib/systemd/system/etcd.service root@${node_ip}:/usr/lib/systemd/system/
done
  • 修改节点的配置（/opt/etcd/cfg/etcd.conf）

把单节点的ip信息，换成此节点的IP

# [Member]
ETCD_NAME="etcd02"ETCD_DATA_DIR="/var/lib/etcd/default.etcd"ETCD_LISTEN_PEER_URLS="https://10.199.142.32:2380"ETCD_LISTEN_CLIENT_URLS="https://10.199.142.32:2379"
# [Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.199.142.32:2380"ETCD_ADVERTISE_CLIENT_URLS="https://10.199.142.32:2379"ETCD_INITIAL_CLUSTER="etcd01=https://10.199.142.31:2380,etcd02=https://10.199.142.32:2380,etcd03=https://10.199.142.33:2380"ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"ETCD_INITIAL_CLUSTER_STATE="new"

节点三同理

  • 启动etcd服务

每台节点上，分别执行systemctl start etcd

5.5、验证etcd服务结果：

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/etcd.pem --key=/opt/etcd/ssl/etcd-key.pem --endpoints="https://10.199.142.31:2379,https://10.199.142.32:2379,https://10.199.142.33:2379" endpoint health --write-out=table

结果：

+----------------------------+--------+-------------+-------+
|          ENDPOINT          | HEALTH |    TOOK     | ERROR |
+----------------------------+--------+-------------+-------+
| https://10.199.142.32:2379 |   true | 11.890704ms |       |
| https://10.199.142.31:2379 |   true | 11.739482ms |       |
| https://10.199.142.33:2379 |   true | 12.842723ms |       |
+----------------------------+--------+-------------+-------+
六、安装kubectl

kubectl默认从~/.kube/config配置文件中获取访问kube-apiserver 地址、证书、用户名等信息，需要正确配置该文件才能正常使用kubectl命令。
需要将下载的kubectl 二进制文件和生产的~/.kube/config配置文件拷贝到需要使用kubectl 命令的机器上。

很多童鞋说这个地方不知道在哪个节点上执行，kubectl只是一个和kube-apiserver进行交互的一个命令行工具，所以你想安装到那个节点都行，master或者node任意节点都可以，比如你先在master节点上安装，这样你就可以在master节点使用kubectl命令行工具了，如果你想在node节点上使用(当然安装的过程肯定会用到的)，你就把master上面的kubectl二进制文件和~/.kube/config文件拷贝到对应的node节点上就行了。

6.1、下载kubectl

[root@k8sm1 k8s]# tar -xvf kubernetes-server-linux-amd64.tar.gz
[root@k8sm1 k8s]# cd kubernetes/server/bin/
[root@k8sm1 bin]# cp kubectl /usr/local/bin/

6.2、创建admin证书

6.2.1、创建admin证书签名请求文件

kubectl 与kube-apiserver 的安全端口通信，需要为安全通信提供TLS 证书和密钥。创建admin 证书签名请求：

cat >/root/k8s/ssl/admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF
  • 后续kube-apiserver使用RBAC 对客户端(如kubelet、kube-proxy、Pod)请求进行授权；
  • kube-apiserver 预定义了一些RBAC 使用的RoleBindings，如cluster-admin 将Group system:masters与Role cluster-admin绑定，该Role 授予了调用kube-apiserver所有API 的权限；
  • O 指定了该证书的Group 为system:masters，kubectl使用该证书访问kube-apiserver时，由于证书被CA 签名，所以认证通过，同时由于证书用户组为经过预授权的system:masters，所以被授予访问所有API 的劝降；
  • hosts 属性值为空列表；

6.2.2、生成证书

[root@k8sm ssl]# cfssl gencert -ca=/root/k8s/ssl/ca.pem -ca-key=/root/k8s/ssl/ca-key.pem -config=/root/k8s/ssl/ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

6.2.3、拷贝证书

[root@k8sm ssl]# cp admin*.pem /opt/k8s/ssl/

6.3、创建kubectl安装脚本

kubectl安装脚本（/root/k8s/install_kubectl.sh），内容如下：

# 加载预设变量
source /root/k8s/env.sh# 默认APISERVER:6443KUBE_APISERVER="https://${MASTER_URL}:6443"# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/k8s/ssl/ca.pem \
  --embed-certs=true\
  --server=${KUBE_APISERVER}
# 设置客户端认证参数
kubectl config set-credentials admin \
  --client-certificate=/opt/k8s/ssl/admin.pem \
  --embed-certs=true\
  --client-key=/opt/k8s/ssl/admin-key.pem \
  --token=${BOOTSTRAP_TOKEN}
# 设置上下文参数
kubectl config set-context kubernetes \
  --cluster=kubernetes \
  --user=admin
# 设置默认上下文
kubectl config use-context kubernetes
  • admin.pem证书O 字段值为system:masters，kube-apiserver 预定义的 RoleBinding cluster-admin 将 Group system:masters 与 Role cluster-admin 绑定，该 Role 授予了调用kube-apiserver 相关 API 的权限
  • 生成的kubeconfig 被保存到 ~/.kube/config 文件

6.4、生成配置文件

[root@k8sm k8s]# sh install_kubectl.sh

Tip：如果分发kubectl到其他机器

  • 拷贝kubectl文件；
  • 将~/.kube/config文件拷贝到运行kubectl命令的机器的~/.kube/目录下去；

kubectl get cs

七、安装Master节点

kubernetes master 节点包含的组件有：

  • kube-apiserver
  • kube-scheduler
  • kube-controller-manager

目前这3个组件需要部署到同一台机器上：（后面再部署高可用的master）

  • kube-scheduler、kube-controller-manager 和 kube-apiserver 三者的功能紧密相关；
  • 同时只能有一个 kube-scheduler、kube-controller-manager 进程处于工作状态，如果运行多个，则需要通过选举产生一个 leader；

master 节点与node 节点上的Pods 通过Pod 网络通信，所以需要在master 节点上部署Flannel 网络。

7.1、下载二进制文件

[root@k8sm1 ~]# cd /root/k8s/kubernetes/server/bin
[root@k8sm1 bin]# cp kube-apiserver kube-controller-manager kube-scheduler /opt/k8s/bin/

7.2、创建kubernetes证书

  • 创建kubernetes证书签名请求文件

cat > /root/k8s/ssl/kube-apiserver-csr.json <<EOF
{
  "CN": "kubernetes",
  "hosts": [
    "127.0.0.1",
    "10.199.142.31",
    "10.199.142.32",
    "10.199.142.33",
    "10.199.142.34",
    "10.199.142.35",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local"],
  "key": {
    "algo": "rsa",
    "size": 2048},
  "names": [
    {
      "C": "CN",
      "ST": "BeiJing",
      "L": "BeiJing",
      "O": "k8s",
      "OU": "System"}
  ]
}
EOF
  • 如果 hosts 字段不为空则需要指定授权使用该证书的 IP 或域名列表，所以上面分别指定了当前部署的 master 节点主机 IP 以及apiserver 负载的内部域名
  • 还需要添加 kube-apiserver 注册的名为 kubernetes 的服务 IP (Service Cluster IP)，一般是 kube-apiserver --service-cluster-ip-range 选项值指定的网段的第一个IP，如 “10.254.0.1”

8.2.2、生成证书

cfssl gencert -ca=/root/k8s/ssl/ca.pem   -ca-key=/root/k8s/ssl/ca-key.pem   -config=/root/k8s/ssl/ca-config.json   -profile=kubernetes kube-apiserver-csr.json | cfssljson -bare kube-apiserver

8.2.3、分发证书

cp kube-apiserver*.pem /opt/k8s/ssl/

8.3、配置和启动kube-apiserver

8.3.1、制作token令牌

创建kube-apiserver使用的客户端token 文件。kubelet 首次启动时向kube-apiserver 发送TLS Bootstrapping 请求，kube-apiserver 验证请求中的token是否与它配置的token.csv 一致，如果一致则自动为kubelet 生成证书和密钥。

source /root/k8s/env.sh
cat >/opt/k8s/cfg/token.csv <<EOF
# 写入内容：序列号,用户名,id,角色
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

8.3.2、创建kube-apiserver安装脚本

kube-apiserver安装脚本（/root/k8s/install_kube-apiserver.sh），内容如下：

#!/usr/bin/bash
# example: ./install_kube-apiserver.sh 10.199.142.31NODE_IP=$1
K8S_DIR=/opt/k8s
ETCD_DIR=/opt/etcd

source /root/k8s/env.sh

cat >${K8S_DIR}/cfg/kube-apiserver.conf <<EOF
KUBE_APISERVER_OPTS="--logtostderr=false \
--v=2\
--log-dir=${K8S_DIR}/logs \
--etcd-servers=${ETCD_ENDPOINTS} \
--bind-address=${NODE_IP} \
--secure-port=6443\
--advertise-address=${NODE_IP} \
--allow-privileged=true\
--service-cluster-ip-range=${SERVICE_CIDR} \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth=true\
--token-auth-file=${K8S_DIR}/cfg/token.csv \
--service-node-port-range=${NODE_PORT_RANGE} \
--kubelet-client-certificate=${K8S_DIR}/ssl/kube-apiserver.pem \
--kubelet-client-key=${K8S_DIR}/ssl/kube-apiserver-key.pem \
--tls-cert-file=${K8S_DIR}/ssl/kube-apiserver.pem  \
--tls-private-key-file=${K8S_DIR}/ssl/kube-apiserver-key.pem \
--client-ca-file=${K8S_DIR}/ssl/ca.pem \
--service-account-key-file=${K8S_DIR}/ssl/ca-key.pem \
--service-account-issuer=api \
--service-account-signing-key-file=${K8S_DIR}/ssl/kube-apiserver-key.pem \
--etcd-cafile=${ETCD_DIR}/ssl/ca.pem \
--etcd-certfile=${ETCD_DIR}/ssl/etcd.pem \
--etcd-keyfile=${ETCD_DIR}/ssl/etcd-key.pem \
--requestheader-client-ca-file=${K8S_DIR}/ssl/ca.pem \
--proxy-client-cert-file=${K8S_DIR}/ssl/kube-apiserver.pem \
--proxy-client-key-file=${K8S_DIR}/ssl/kube-apiserver-key.pem \
--requestheader-allowed-names=kubernetes \
--requestheader-extra-headers-prefix=X-Remote-Extra-\
--requestheader-group-headers=X-Remote-Group \
--requestheader-username-headers=X-Remote-User \
--enable-aggregator-routing=true\
--audit-log-maxage=30\
--audit-log-maxbackup=3\
--audit-log-maxsize=100\
--audit-log-path=${K8S_DIR}/logs/k8s-audit.log"
EOF

# 创建节点的启动脚本模板
cat >/usr/lib/systemd/system/kube-apiserver.service <<EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=${K8S_DIR}/cfg/kube-apiserver.conf
ExecStart=${K8S_DIR}/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

8.3.3、启动apiserver

[root@k8sm k8s]#sh install_kube-apiserver.sh 10.199.142.31

8.3.4、 验证服务

systemctl status kube-apiserver

8.4、配置和启动kube-controller-manager

生成证书

cat > /root/k8s/ssl/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

cd /root/k8s/ssl

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

cp kube-controller-manager*.pem /opt/k8s/ssl/
K8S_DIR=/opt/k8s

source /root/k8s/env.sh
KUBE_CONFIG="${K8S_DIR}/cfg/kube-controller-manager.kubeconfig"KUBE_APISERVER="https://${MASTER_URL}:6443"
kubectl config set-cluster kubernetes \
  --certificate-authority=${K8S_DIR}/ssl/ca.pem \
  --embed-certs=true\
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-controller-manager \
  --client-certificate=${K8S_DIR}/ssl/kube-controller-manager.pem \
  --client-key=${K8S_DIR}/ssl/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}

8.4.1、创建kube-controller-manager安装脚本

kube-controller-manager安装脚本（/root/k8s/install_kube-controller-manager.sh），内容如下：

#!/usr/bin/bash
# example: ./install_kube-controller-manager.shK8S_DIR=/opt/k8s

source /root/k8s/env.sh

cat > ${K8S_DIR}/cfg/kube-controller-manager.conf <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2\\
--log-dir=${K8S_DIR}/logs \\
--leader-elect=true\\
--kubeconfig=${K8S_DIR}/cfg/kube-controller-manager.kubeconfig \\
--bind-address=127.0.0.1\\
--allocate-node-cidrs=true\\
--cluster-cidr=${CLUSTER_CIDR} \\
--service-cluster-ip-range=${SERVICE_CIDR} \\
--cluster-signing-cert-file=${K8S_DIR}/ssl/ca.pem \\
--cluster-signing-key-file=${K8S_DIR}/ssl/ca-key.pem  \\
--root-ca-file=${K8S_DIR}/ssl/ca.pem \\
--service-account-private-key-file=${K8S_DIR}/ssl/ca-key.pem \\
--cluster-signing-duration=87600h0m0s"
EOF

cat > /usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=${K8S_DIR}/cfg/kube-controller-manager.conf
ExecStart=${K8S_DIR}/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start kube-controller-manager
systemctl enable kube-controller-manager
  • --address 值必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器
  • --master=http://${MASTER_URL}:8080：使用http(非安全端口)与 kube-apiserver 通信，需要下面的haproxy安装成功后才能去掉8080端口。
  • --cluster-cidr 指定 Cluster 中 Pod 的 CIDR 范围，该网段在各 Node 间必须路由可达(flanneld保证)
  • --service-cluster-ip-range 参数指定 Cluster 中 Service 的CIDR范围，该网络在各 Node 间必须路由不可达，必须和 kube-apiserver 中的参数一致
  • --cluster-signing-* 指定的证书和私钥文件用来签名为 TLS BootStrap 创建的证书和私钥
  • --root-ca-file 用来对 kube-apiserver 证书进行校验，指定该参数后，才会在Pod 容器的 ServiceAccount 中放置该 CA 证书文件
  • --leader-elect=true 部署多台机器组成的 master 集群时选举产生一处于工作状态的 kube-controller-manager 进程

8.4.2、启动kube-controller-manager

[root@k8sm k8s]# sh install_kube-controller-manager.sh

8.4.3、验证服务

systemctl status kube-controller-manager

8.5、配置和启动kube-scheduler

cat > /root/k8s/ssl/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

cd /root/k8s/ssl

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

cp kube-scheduler*.pem /opt/k8s/ssl/
K8S_DIR=/opt/k8s
source /root/k8s/env.sh
KUBE_CONFIG="${K8S_DIR}/cfg/kube-scheduler.kubeconfig"KUBE_APISERVER="https://${MASTER_URL}:6443"
kubectl config set-cluster kubernetes \
  --certificate-authority=${K8S_DIR}/ssl/ca.pem \
  --embed-certs=true\
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-scheduler \
  --client-certificate=${K8S_DIR}/ssl/kube-scheduler.pem \
  --client-key=${K8S_DIR}/ssl/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}

8.5.1、创建kube-scheduler安装脚本

kube-scheduler安装脚本（/root/k8s/install_kube-scheduler.sh），内容如下：

#!/usr/bin/bash
# example: ./install_kube-scheduler.shK8S_DIR=/opt/k8s
source /root/k8s/env.sh

cat > ${K8S_DIR}/cfg/kube-scheduler.conf <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \
--v=2\
--log-dir=${K8S_DIR}/logs \
--leader-elect \
--kubeconfig=${K8S_DIR}/cfg/kube-scheduler.kubeconfig \
--bind-address=127.0.0.1"
EOF

cat > /usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=${K8S_DIR}/cfg/kube-scheduler.conf
ExecStart=${K8S_DIR}/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start kube-scheduler
systemctl enable kube-scheduler
  • --address 值必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器
  • --master=http://${MASTER_URL}:8080：使用http(非安全端口)与 kube-apiserver 通信，需要下面的haproxy启动成功后才能去掉8080端口
  • --leader-elect=true 部署多台机器组成的 master 集群时选举产生一处于工作状态的 kube-controller-manager 进程

8.5.2、启动kube-scheduler

sh install_kube-scheduler.sh

8.5.3、验证kube-scheduler服务

systemctl status kube-scheduler

8.6、验证Master节点

[root@k8sm k8s]# /opt/k8s/bin/kubectl get componentstatuses

结果：

View Code

9.3.3、创建bootstrap角色

创建 bootstrap角色赋予权限，用于连接 apiserver请求签名

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
八、部署Node节点

9.1、下载二进制文件

NODE_IPS=("192.168.56.108" "192.168.56.109")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    scp /root/k8s/kubernetes/server/bin/kubelet root@${node_ip}:/opt/k8s/bin/
    scp /root/k8s/kubernetes/server/bin/kube-proxy root@${node_ip}:/opt/k8s/bin/
done

9.2、配置docker

9.2.1、修改systemd unit文件,暂时不修改

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

# 原内容
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
# 修改后内容：
EnvironmentFile=-/run/flannel/docker
ExecStart=/usr/bin/dockerd --log-level=info $DOCKER_NETWORK_OPTIONS

9.2.2、重启docker

systemctl daemon-reload
systemctl restart docker

9.3、安装kubelet

9.3.1、配置kubelet

K8S_DIR=/opt/k8s
source /root/k8s/env.sh
KUBE_CONFIG="/root/k8s/bootstrap.kubeconfig"KUBE_APISERVER="https://${MASTER_URL}:6443"
kubectl config set-cluster kubernetes \
  --certificate-authority=${K8S_DIR}/ssl/ca.pem \
  --embed-certs=true\
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials "kubelet-bootstrap"\
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user="kubelet-bootstrap"\
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

mv bootstrap.kubeconfig /root/k8s/

scp /root/k8s/bootstrap.kubeconfig root@10.199.142.34:/opt/k8s/cfg/

scp /root/k8s/ssl/ca*.pem root@10.199.142.34:/opt/k8s/ssl/

配置文件（/root/k8s/gen_bootstrap-kubeconfig.sh）下面的，被上面的替换掉了

#!/usr/bin/bash

source /root/k8s/env.sh
KUBE_APISERVER="https://${MASTER_URL}:6443"# 设置集群参数
kubectl config set-cluster kubernetes \
--certificate-authority=/opt/k8s/ssl/ca.pem \
--embed-certs=true\
--server=${KUBE_APISERVER} \
--kubeconfig=bootstrap.kubeconfig

# 设置客户端认证参数
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

# 设置默认上下文
kubectl config use-context default --kubeconfig=bootstrap.kubeconfigNODE_IPS=("192.168.56.108" "192.168.56.109")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    scp /root/k8s/bootstrap.kubeconfig root@${node_ip}:/opt/k8s/cfg/
done

9.3.2、生成配置文件

[root@k8sm k8s]# sh gen_bootstrap-kubeconfig.sh

9.3.4、创建kubelet安装脚本

kubelet脚本（/root/k8s/install_kubelet.sh），内容如下：

#!/usr/bin/bash

NODE_NAME=$1
K8S_DIR=/opt/k8s
source /root/k8s/env.sh

cat >${K8S_DIR}/cfg/kubelet.conf <<EOF
KUBELET_OPTS="--logtostderr=false \
--v=2\
--log-dir=${K8S_DIR}/logs \
--hostname-override=${NODE_NAME} \
--network-plugin=cni \
--kubeconfig=${K8S_DIR}/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=${K8S_DIR}/cfg/bootstrap.kubeconfig \
--config=${K8S_DIR}/cfg/kubelet-config.yml \
--cert-dir=${K8S_DIR}/ssl \
--pod-infra-container-image=k8s.gcr.io/pause:3.2"
EOF

cat >${K8S_DIR}/cfg/kubelet-config.yml <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 0.0.0.0port: 10250readOnlyPort: 10255cgroupDriver: systemd
clusterDNS:
  -clusterDomain: 
failSwapOn: false
# 身份验证
authentication:
  anonymous:
    enabled: falsewebhook:
    cacheTTL: 2m0s
    enabled: truex509:
    clientCAFile: ${K8S_DIR}/ssl/ca.pem

# 授权
authorization:
  mode: Webhook
  webhook:
    cacheAuthorizedTTL: 5m0s
    cacheUnauthorizedTTL: 30s

# Node 资源保留
evictionHard:
  imagefs.available: 15%memory.available: 1G
  nodefs.available: 10%nodefs.inodesFree: 5%evictionPressureTransitionPeriod: 5m0s

# 镜像删除策略
imageGCHighThresholdPercent: 85imageGCLowThresholdPercent: 80imageMinimumGCAge: 2m0s

# 旋转证书
rotateCertificates: true# 旋转kubelet client 证书
featureGates:
  RotateKubeletServerCertificate: trueRotateKubeletClientCertificate: true
maxOpenFiles: 1000000maxPods: 110EOF

cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=-${K8S_DIR}/cfg/kubelet.conf
ExecStart=${K8S_DIR}/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet 
systemctl restart kubelet

认证节点

kubectl get csr

NAME AGE SIGNERNAME REQUESTOR CONDITION
csr-7h7nd 49s kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending
csr-xfk22 18s kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending

[root@hz-yf-xtax-it-199-142-31 cfg]# kubectl certificate approve csr-xfk22
certificatesigningrequest.certificates.k8s.io/csr-xfk22 approved

kubectl get node

NAME STATUS ROLES AGE VERSION
k8sn1 NotReady <none> 11s v1.20.4

9.4、安装kube-proxy

9.4.1、创建kube-proxy证书

cat > /root/k8s/ssl/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

9.4.3、生成证书

cfssl gencert -ca=/root/k8s/ssl/ca.pem -ca-key=/root/k8s/ssl/ca-key.pem -config=/root/k8s/ssl/ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

9.4.4、分发证书

scp /root/k8s/ssl/kube-proxy*.pem root@10.199.142.34:/opt/k8s/ssl/

9.4.5、配置kube-proxy

/root/k8s/gen_kube-proxyconfig.sh，内容如下：

xin的

source /root/k8s/env.sh
KUBE_CONFIG="/root/k8s/kube-proxy.kubeconfig"KUBE_APISERVER="https://${MASTER_URL}:6443"
kubectl config set-cluster kubernetes \
  --certificate-authority=${K8S_DIR}/ssl/ca.pem \
  --embed-certs=true\
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-proxy \
  --client-certificate=${K8S_DIR}/ssl/kube-proxy.pem \
  --client-key=${K8S_DIR}/ssl/kube-proxy-key.pem \
  --embed-certs=true\
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

scp /root/k8s/kube-proxy.kubeconfig root@10.199.142.34:/opt/k8s/cfg/

#!/usr/bin/bash

source /root/k8s/env.shKUBE_APISERVER="https://${MASTER_URL}:6443"# 设置集群参数
kubectl config set-cluster kubernetes \
--certificate-authority=/opt/k8s/ssl/ca.pem \
--embed-certs=true\
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig

# 设置客户端认证参数
kubectl config set-credentials kube-proxy\
--client-certificate=/root/k8s/ssl/kube-proxy.pem \
--client-key=/root/k8s/ssl/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

NODE_IPS=("192.168.56.108" "192.168.56.109")
for node_ip in ${NODE_IPS[@]};do
    echo ">>> ${node_ip}"
    scp /root/k8s/kube-proxy.kubeconfig root@${node_ip}:/opt/k8s/cfg/
done

9.4.7、kube-proxy安装脚本

/root/k8s/install_kube-proxy.sh，内容如下：

#!/usr/bin/bash

K8S_DIR=/opt/k8s
source /root/k8s/env.sh

cat > ${K8S_DIR}/cfg/kube-proxy.conf <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2\\
--log-dir=${K8S_DIR}/logs \\
--config=${K8S_DIR}/cfg/kube-proxy-config.yml"
EOF

cat > ${K8S_DIR}/cfg/kube-proxy-config.yml <<EOF
kind: KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
bindAddress: 0.0.0.0metricsBindAddress: 0.0.0.0:10249clientConnection:
  kubeconfig: ${K8S_DIR}/cfg/kube-proxy.kubeconfig
hostnameOverride: k8s-master1
clusterCIDR: ${CLUSTER_CIDR}
EOF

cat > /usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=${K8S_DIR}/cfg/kube-proxy.conf
ExecStart=${K8S_DIR}/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start kube-proxy
systemctl enable kube-proxy

九、安装calico

curl https://docs.projectcalico.org/manifests/calico.yaml -O

diffcalico.yaml calico.yaml.default 
3660,3662c3660
<               value: "Never"
<             -name: IP_AUTODETECTION_METHOD
<               value: "interface=en.*"
---
>               value: "Always"
3687,3688c3685,3686
<             -name: CALICO_IPV4POOL_CIDR
<               value: "10.100.0.0/16"
---
>             # -name: CALICO_IPV4POOL_CIDR
>             #   value: "192.168.0.0/16"3768c3766
<             path: /opt/k8s/bin
---
>             path: /opt/cni/bin

十、部署kubedns插件

十一、部署dashboard插件

问题：
[root@k8sm-1 ~]# /opt/etcd/bin/etcdctl --ca-file=/opt/k8s/ssl/ca.pem --cert-file=/opt/k8s/ssl/flanneld.pem --key-file=/opt/k8s/ssl/flanneld-key.pem --endpoints=${ETCD_ENDPOINTS} get ${FLANNEL_ETCD_PREFIX}/config
Error: client: response is invalid json. The endpoint is probably not valid etcd cluster endpoint
解决办法：
https://blog.csdn.net/sonsunny/article/details/105226586

end

hostnamectl set-hostname k8sm1hostnamectl set-hostname k8sm2hostnamectl set-hostname k8sm3hostnamectl set-hostname k8sn1hostnamectl set-hostname k8sn2

NODE_IPS=("10.199.142.31" "10.199.142.32" "10.199.142.33" "10.199.142.34" "10.199.142.35")for node_ip in ${NODE_IPS[@]};do echo ">>> ${node_ip}" scp /root/k8s/env.sh root@${node_ip}:/root/k8s/done

标签：#k8s#kubernetes#etcd#root权限#集群服务器#node | 浏览：591 | 发布日期：

免责声明：文章转载自《k8s集群安装（单节点）》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇Java多线程-线程的调度(休眠)Unity 国际化 多语言设置下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

centos6 free 和 centos 7的free 的差异与对比

以下内容大多数是转载 在centos6中： 查看内存是这样的： [root@ ~]# free -h　　#人性化输出显示total used free shared buffers cachedMem: 996M 521M 474M 56K 35M 118M-/+ buffers/cache: 368M 628MSwap: 1.5G 234M 1.2G t...

K8S部署之kubeadm

K8S部署笔记 一、集群环境说明 主机名 IP地址 说明 k8s-master01 192.168.1.107 master节点 k8s-master02 192.168.1.108 master节点 k8s-master03 192.168.1.109 master节点 k8s-master-lb（在master节点） 192.16...

ubuntu下nvm,node以及npm的安装与使用

一.安装nvm 首先下载nvm，这里我们需要使用Git，如果没有安装git，可以使用 sudo apt-get install git  来安装 git clone https://github.com/creationix/nvm.git ~/.nvm && cd ~/.nvm && git checkout `gi...

Kubernetes进阶实战读书笔记：StatefulSet控制器（资源升级）

一、滚动更新 1、将myapp控制器下的pod资源镜像升级为："ikubernetes/myapp:v6" [root@master ~]# kubectl set image sts myapp myapp=ikubernetes/myapp:v6 statefulset.apps/myapp image updated 2、实时监控更新操作过程 [ro...

使用 Tye 辅助开发 k8s 应用竟如此简单（五）

续上篇，这篇我们来进一步探索 Tye 更多的使用方法。本篇我们来了解一下如何在 Tye 中实现对分布式链路追踪。 Newbe.Claptrap 是一个用于轻松应对并发问题的分布式开发框架。如果您是首次阅读本系列文章。建议可以先从本文末尾的入门文章开始了解。 我是谁？我在哪儿？我咋了？ 分布式系统纷繁复杂，特别以现在微服务架构的出现，使得应用系统中的应用实...

【原创】从4个9到5个9可用性调优-总章

适用场景&适读对象场景关键词：互联网 分布式 业务集群 qps高 扛量 高可用 涉及内容：缓存调优 GC调优 隔离 上下游防护 运维优化 适读对象：资深业务开发同学，团队leader Part1.背景 之前年底线上用户端工程出了一次可用性故障，导致用户进app首页白屏，系统不可用。 具体原因是：【redis单点大热key叠加pipeline导致...

最新文章

随机推荐

思享工具箱导航