二进制搭建Kubernetes集群环境

最新推荐文章于 2023-08-09 14:24:47 发布

置顶 JontyYang

最新推荐文章于 2023-08-09 14:24:47 发布

阅读量632

点赞数 2

分类专栏： Kubernetes Docker 入门与实战

本文链接：https://blog.csdn.net/jthello123/article/details/104937308

版权

Docker 入门与实战同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

Kubernetes

5 篇文章 0 订阅

订阅专栏

[kubeadm快速搭建kubernetes集群]

引言

在网上查看了许多关于kubernetes集群的搭建，但是好多东西多很模糊（节点部署操作不明确），于是自己查阅了相关资料，写了这片关于Kubernetes集群搭建的博客。（我提供的是1.15版本的，后面显示kubelet1.13是因为用了1.13的包）

1. 架构

1.1 k8s 架构说明

在这里插入图片描述

1.2 Flannel网络架构图。

在这里插入图片描述

集群功能各模块功能描述：
Master节点：
Master节点上面主要由四个模块组成，APIServer，schedule,controller-manager,etcd
APIServer: APIServer负责对外提供RESTful的kubernetes API的服务，它是系统管理指令的统一接口，任何对资源的增删该查都要交给APIServer处理后再交给etcd，如图，kubectl(kubernetes提供的客户端工具，该工具内部是对kubernetes API的调用）是直接和APIServer交互的。
schedule: schedule负责调度Pod到合适的Node上，如果把scheduler看成一个黑匣子，那么它的输入是pod和由多个Node组成的列表，输出是Pod和一个Node的绑定。 kubernetes目前提供了调度算法，同样也保留了接口。用户根据自己的需求定义自己的调度算法。
controller manager: 如果APIServer做的是前台的工作的话，那么controller manager就是负责后台的。每一个资源都对应一个控制器。而control manager就是负责管理这些控制器的，比如我们通过APIServer创建了一个Pod，当这个Pod创建成功后，APIServer的任务就算完成了。
etcd：etcd是一个高可用的键值存储系统，kubernetes使用它来存储各个资源的状态，从而实现了Restful的API。
Node节点：
每个Node节点主要由三个模板组成：kublet, kube-proxy
kube-proxy: 该模块实现了kubernetes中的服务发现和反向代理功能。kube-proxy支持TCP和UDP连接转发，默认基Round Robin算法将客户端流量转发到与service对应的一组后端pod。服务发现方面，kube-proxy使用etcd的watch机制监控集群中service和endpoint对象数据的动态变化，并且维护一个service到endpoint的映射关系，从而保证了后端pod的IP变化不会对访问者造成影响，另外，kube-proxy还支持session affinity。
kublet：kublet是Master在每个Node节点上面的agent，是Node节点上面最重要的模块，它负责维护和管理该Node上的所有容器，但是如果容器不是通过kubernetes创建的，它并不会管理。本质上，它负责使Pod的运行状态与期望的状态一致。

1.3 Kubernetes工作流程

在这里插入图片描述
所有操作均在root用户下执行

2.集群初始化（初始化三个节点都执行）

2.1节点说明

主机名	IP	用途	部署软件
master	192.168.1.4	master	apiserver,scheduler,controller-manager,etcd,flanneld
slave1	192.168.1.5	slave1	kubelet,kube-proxy,etcd,flanneld
slave2	192.168.1.6	slave2	kubelet,kube-proxy,etcd,flanneld

2.2 操作系统环境

在这里插入图片描述

2.3 软件包

软件包，提取码： k5ec

2.4 初始化环境

2.4.1 设置关闭防火墙及selinux

systemctl stop firewalld && systemctl disable firewalld
setenforce 0
vi /etc/selinux/config
SELINUX=disabled

2.4.2 关闭swap

swapoff -a && sysctl -w vm.swappiness=0
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

2.4.3 设置Docker所需参数

cat > /etc/sysctl.d/kubernetes.conf <<EOF
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
EOF
sysctl -p  /etc/sysctl.d/kubernetes.conf

2.4.4 安装Docker

yum update
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum update
yum install -y docker-ce-18.06.2.ce-3.el7
systemctl start docker
systemctl enable docker && systemctl restart docker && service docker status

2.4.5 创建相关目录

 创建安装包存储目录
mkdir  /data/{install,ssl_config} -p
mkdir /data/ssl_config/{etcd,kubernetes}  -p

 创建安装目录
mkdir /cloud/k8s/etcd/{bin,cfg,ssl} -p
mkdir /cloud/k8s/kubernetes/{bin,cfg,ssl} -p

2.4.6 ssh配置

修改三台机器的/etc/hosts

vi /etc/hosts

添加以下内容（根据自己机器ip添加）

192.168.1.4 master
192.168.1.5 slave1
192.168.1.6 slave2

ssh互信配置

ssh-keygen
ssh-copy-id  master
ssh-copy-id  slave1
ssh-copy-id  slave2

2.4.7 添加path变量

vi /etc/profile
export PATH=$PATH:/cloud/k8s/etcd/bin/:/cloud/k8s/kubernetes/bin/

3.创建ssl证书（只在master节点执行）

3.1 安装及配置CFSSL

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

3.2创建ETCD相关证书

以下操作均在/data/ssl_config/etcd/目录中
etcd证书ca配置

cd /data/ssl_config/etcd/

cat << EOF | tee ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

创建 ETCD CA 配置文件

cat << EOF | tee ca-csr.json
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

创建 ETCD Server 证书

cat << EOF | tee server-csr.json
{
    "CN": "etcd",
    "hosts": [
    "master",
    "slave1",
    "slave2",
    "192.168.1.4",
    "192.168.1.5",
    "192.168.1.6"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

生成 ETCD CA 证书和私钥

cd /data/ssl_config/etcd/
# 生成ca证书
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
# 生成server证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

3.3 创建Kubernetes相关证书

以下操作均在/data/ssl_config/kubernetes/目录中
kubernetes 证书ca配置

cd /data/ssl_config/kubernetes/
cat << EOF | tee ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

创建ca证书配置

cat << EOF | tee ca-csr.json
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

生成API_SERVER证书

cat << EOF | tee server-csr.json
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.1.4",
      "master",
      "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

创建 Kubernetes Proxy 证书

cat << EOF | tee 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

生成 kubernetes CA 证书和私钥

# 生成ca证书
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
# 生成 api-server 证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server
# 生成 kube-proxy 证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

4 部署ETCD（mater节点执行）

4.1 配置软件包（安装包要先放在/data/install，后面同理）

cd /data/install/
tar -xvf etcd-v3.3.10-linux-amd64.tar.gz
cd etcd-v3.3.10-linux-amd64/
cp etcd etcdctl /cloud/k8s/etcd/bin/

4.2 编辑etcd配置文件

vim /cloud/k8s/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.1.4:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.1.4:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.1.4:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.1.4:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.1.4:2380,etcd02=https://192.168.1.5:2380,etcd03=https://192.168.1.6:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

4.3创建 etcd的 systemd unit 文件

vim /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=/cloud/k8s/etcd/cfg/etcd
ExecStart=/cloud/k8s/etcd/bin/etcd \
--name=${ETCD_NAME} \
--data-dir=${ETCD_DATA_DIR} \
--listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \
--listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \
--advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \
--initial-cluster-state=new \
--cert-file=/cloud/k8s/etcd/ssl/server.pem \
--key-file=/cloud/k8s/etcd/ssl/server-key.pem \
--peer-cert-file=/cloud/k8s/etcd/ssl/server.pem \
--peer-key-file=/cloud/k8s/etcd/ssl/server-key.pem \
--trusted-ca-file=/cloud/k8s/etcd/ssl/ca.pem \
--peer-trusted-ca-file=/cloud/k8s/etcd/ssl/ca.pem
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

4.4 配置证书文件

cd /data/ssl_config/etcd/
cp ca*pem server*pem /cloud/k8s/etcd/ssl

4.5 配置文件拷贝到slave1，slave2

cd /cloud/k8s/ 
scp -r etcd slave1:/cloud/k8s/
scp -r etcd slave2:/cloud/k8s/
scp /usr/lib/systemd/system/etcd.service  slave1:/usr/lib/systemd/system/etcd.service
scp /usr/lib/systemd/system/etcd.service  slave2:/usr/lib/systemd/system/etcd.service

** 在slave1，slave2中修改配置文件**

### slave1
cat  /cloud/k8s/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.1.5:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.1.6:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.1.5:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.1.5:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.1.4:2380,etcd02=https://192.168.1.5:2380,etcd03=https://192.168.1.6:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

### slave2
cat  /cloud/k8s/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.1.6:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.1.6:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.1.6:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.1.6:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.1.4:2380,etcd02=https://192.168.1.5:2380,etcd03=https://192.168.1.6:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

另外两台机器配置完成后，启动etcd服务，三台都需启动。

4.6 启动ETCD服务(三个节点执行)

systemctl daemon-reload
systemctl enable etcd
systemctl start etcd
#启动ETCD集群同时启动二个节点，单节点是无法正常启动的。

检查服务是否正常

etcdctl --ca-file=/cloud/k8s/etcd/ssl/ca.pem --cert-file=/cloud/k8s/etcd/ssl/server.pem --key-file=/cloud/k8s/etcd/ssl/server-key.pem --endpoints="https://192.168.1.4:2379,https://192.168.1.5:2379,https://192.168.1.6:2379"  cluster-health

在这里插入图片描述

5 部署flannel网络（master节点执行）

5.1 向 etcd 写入集群 Pod 网段信息

 cd /cloud/k8s/etcd/ssl
 etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem \
 --endpoints="https://192.168.1.4:2379,https://192.168.1.5:2379,https://192.168.1.6:2379" \
 set /coreos.com/network/config  \
 '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'

写入的 Pod 网段 ${CLUSTER_CIDR} 必须是 /16 段地址，必须与 kube-controller-manager 的 --cluster-cidr 参数值一致；

5.2 部署flannel

 cd /data/install/
 tar xf  flannel-v0.11.0-linux-amd64.tar.gz
 mv flanneld mk-docker-opts.sh /cloud/k8s/kubernetes/bin/

5.3 配置flannel

vim  /cloud/k8s/kubernetes/cfg/flanneld
FLANNEL_OPTIONS="--etcd-endpoints=https://192.168.1.4:2379,https://192.168.1.5:2379,https://192.168.1.6:2379 -etcd-cafile=/cloud/k8s/etcd/ssl/ca.pem -etcd-certfile=/cloud/k8s/etcd/ssl/server.pem -etcd-keyfile=/cloud/k8s/etcd/ssl/server-key.pem"

5.4 创建 flanneld 的 systemd unit 文件

vim /usr/lib/systemd/system/flanneld.service
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service

[Service]
Type=notify
EnvironmentFile=/cloud/k8s/kubernetes/cfg/flanneld
ExecStart=/cloud/k8s/kubernetes/bin/flanneld --ip-masq $FLANNEL_OPTIONS
ExecStartPost=/cloud/k8s/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

mk-docker-opts.sh 脚本将分配给 flanneld 的 Pod 子网网段信息写入 /run/flannel/docker 文件，后续 docker 启动时使用这个文件中的环境变量配置 docker0 网桥；
flanneld 使用系统缺省路由所在的接口与其它节点通信，对于有多个网络接口（如内网和公网）的节点，可以用 -iface 参数指定通信接口，如上面的 eth0 接口;
flanneld 运行时需要 root 权限；

5.5 配置Docker启动指定子网段

vim /usr/lib/systemd/system/docker.service
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/run/flannel/subnet.env
ExecStart=/usr/bin/dockerd  $DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target

5.6 将flanneld systemd unit 文件拷贝到slave1，slave2

cd /cloud/k8s/
scp -r kubernetes slave1:/cloud/k8s/
scp -r kubernetes slave2:/cloud/k8s/
scp /cloud/k8s/kubernetes/cfg/flanneld  slave1:/cloud/k8s/kubernetes/cfg/flanneld
scp /cloud/k8s/kubernetes/cfg/flanneld  slave2:/cloud/k8s/kubernetes/cfg/flanneld
scp /usr/lib/systemd/system/docker.service  slave1:/usr/lib/systemd/system/docker.service 
scp /usr/lib/systemd/system/docker.service   slave2:/usr/lib/systemd/system/docker.service
scp /usr/lib/systemd/system/flanneld.service  slave1:/usr/lib/systemd/system/flanneld.service 
scp /usr/lib/systemd/system/flanneld.service  slave2:/usr/lib/systemd/system/flanneld.service 

# 启动服务(每台节点都操作)
systemctl daemon-reload
systemctl start flanneld
systemctl enable flanneld
systemctl restart docker

5.7 验证flannel网络配置（三台都查看，细心查看图片红线处的规律）
master
在这里插入图片描述
slave1

slave2

6 配置master节点（master执行）

kubernetes master 节点运行如下组件：
kube-apiserver
kube-scheduler
kube-controller-manager
kube-scheduler 和 kube-controller-manager 可以以集群模式运行，通过 leader 选举产生一个工作进程，其它进程处于阻塞模式。

6.1 配置 master 节点文件

 cd /data/install/
 tar xf kubernetes-server-linux-amd64.tar.gz 
 cd kubernetes/server/bin/
 cp kube-scheduler kube-apiserver kube-controller-manager kubectl /cloud/k8s/kubernetes/bin/

6.2 配置 kubernetes相关证书

cd /data/ssl_config/kubernetes/
cp *pem /cloud/k8s/kubernetes/ssl/

6.3 部署 kube-apiserver 组件
创建 TLS Bootstrapping Token（token后面会用到）

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

# vim /cloud/k8s/kubernetes/cfg/token.csv
449bbeb0ea7e50f321087a123a509a19,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

创建apiserver配置文件

vim /cloud/k8s/kubernetes/cfg/kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.1.4:2379,https://192.168.1.5:2379,https://192.168.1.6:2379 \
--bind-address=192.168.1.4 \
--secure-port=6443 \
--advertise-address=192.168.1.4 \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth \
--token-auth-file=/cloud/k8s/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/cloud/k8s/kubernetes/ssl/server.pem  \
--tls-private-key-file=/cloud/k8s/kubernetes/ssl/server-key.pem \
--client-ca-file=/cloud/k8s/kubernetes/ssl/ca.pem \
--service-account-key-file=/cloud/k8s/kubernetes/ssl/ca-key.pem \
--etcd-cafile=/cloud/k8s/etcd/ssl/ca.pem \
--etcd-certfile=/cloud/k8s/etcd/ssl/server.pem \
--etcd-keyfile=/cloud/k8s/etcd/ssl/server-key.pem"

创建 kube-apiserver systemd unit 文件

vim  /usr/lib/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/cloud/k8s/kubernetes/cfg/kube-apiserver
ExecStart=/cloud/k8s/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

查看apiserver是否运行

[root@master /data/ssl_config/kubernetes] master
# ps -ef |grep kube-apiserver

在这里插入图片描述
6.4 部署kube-scheduler
创建kube-scheduler配置文件

vim  /cloud/k8s/kubernetes/cfg/kube-scheduler
KUBE_SCHEDULER_OPTS="--logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect"

–address：在 127.0.0.1:10251 端口接收 http /metrics 请求；kube-scheduler 目前还不支持接收 https 请求；
–kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver；
–leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态；

创建kube-scheduler systemd unit 文件

vim /usr/lib/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/cloud/k8s/kubernetes/cfg/kube-scheduler
ExecStart=/cloud/k8s/kubernetes/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动kube-scheduler服务

systemctl daemon-reload 
systemctl enable kube-scheduler.service  
systemctl restart kube-scheduler.service

查看kube-scheduler是否运行

[root@master /data/ssl_config/kubernetes] master
#  ps -ef |grep kube-scheduler
# systemctl status kube-scheduler

在这里插入图片描述
6.5 部署kube-controller-manager
创建kube-controller-manager配置文件

vim  /cloud/k8s/kubernetes/cfg/kube-controller-manager
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=127.0.0.1:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/cloud/k8s/kubernetes/ssl/ca.pem \
--cluster-signing-key-file=/cloud/k8s/kubernetes/ssl/ca-key.pem  \
--root-ca-file=/cloud/k8s/kubernetes/ssl/ca.pem \
--service-account-private-key-file=/cloud/k8s/kubernetes/ssl/ca-key.pem"
创建kube-controller-manager systemd unit 文件

vim  /usr/lib/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=/cloud/k8s/kubernetes/cfg/kube-controller-manager
ExecStart=/cloud/k8s/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动服务

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

查看kube-controller-manager是否运行

[root@master /data/ssl_config/kubernetes] master
# ps -ef |grep kube-controller-manager
#  systemctl status kube-controller-manager
查看master集群状态
# kubectl get cs,nodes

在这里插入图片描述

7部署node 节点

kubernetes work 节点运行如下组件：
docker
kubelet
kube-proxy

7.1 部署 kubelet 组件(master执行)

kublet 运行在每个 worker 节点上，接收 kube-apiserver 发送的请求，管理 Pod 容器，执行交互式命令，如exec、run、logs 等;
kublet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况;
为确保安全，本文档只开启接收 https 请求的安全端口，对请求进行认证和授权，拒绝未授权的访问(如apiserver、heapster)。

配置node节点

cd /data/install/kubernetes/server/bin/
scp kubelet kube-proxy slave1:/cloud/k8s/kubernetes/bin/
scp kubelet kube-proxy slave2:/cloud/k8s/kubernetes/bin/

创建 kubelet bootstrap.kubeconfig 文件

 cd /data/ssl_config/kubernetes/
vim environment.sh
# 创建kubelet bootstrapping kubeconfig
BOOTSTRAP_TOKEN=449bbeb0ea7e50f321087a123a509a19
KUBE_APISERVER="https://192.168.1.4:6443"
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=./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.kubeconfig

创建 kubelet.kubeconfig 文件

vim envkubelet.kubeconfig.sh
# 创建kubelet bootstrapping kubeconfig
BOOTSTRAP_TOKEN=449bbeb0ea7e50f321087a123a509a19
KUBE_APISERVER="https://192.168.1.4:6443"

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kubelet.kubeconfig

# 设置客户端认证参数
kubectl config set-credentials kubelet \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=kubelet.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet \
  --kubeconfig=kubelet.kubeconfig

# 设置默认上下文
kubectl config use-context default --kubeconfig=kubelet.kubeconfig

创建kube-proxy kubeconfig文件

vim  env_proxy.sh
# 创建kube-proxy kubeconfig文件

BOOTSTRAP_TOKEN=449bbeb0ea7e50f321087a123a509a19
KUBE_APISERVER="https://192.168.1.4:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=./ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./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

生成文件bootstrap.kubeconfig kube-proxy.kubeconfig 
# bash environment.sh
# bash envkubelet.kubeconfig.sh
# bash env_proxy.sh

将bootstrap.kubeconfig kube-proxy.kubeconfig 文件拷贝到所有 nodes节点

scp -rp bootstrap.kubeconfig kube-proxy.kubeconfig slave1:/cloud/k8s/kubernetes/cfg/
scp -rp bootstrap.kubeconfig kube-proxy.kubeconfig slave2:/cloud/k8s/kubernetes/cfg/

7.2 创建kubelet 参数配置文件（slave1，slave2执行）
创建 kubelet 参数配置模板文件

[root@slave1 /root] node  （slave2同理根据实际情况修改）
# cat /cloud/k8s/kubernetes/cfg/kubelet.config
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.1.5
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true

创建kubelet配置文件

vim  /cloud/k8s/kubernetes/cfg/kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=slave1 \
--kubeconfig=/cloud/k8s/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/cloud/k8s/kubernetes/cfg/bootstrap.kubeconfig \
--config=/cloud/k8s/kubernetes/cfg/kubelet.config \
--cert-dir=/cloud/k8s/kubernetes/ssl \
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"

创建kubelet systemd unit 文件

 vim /usr/lib/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/cloud/k8s/kubernetes/cfg/kubelet
ExecStart=/cloud/k8s/kubernetes/bin/kubelet $KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target

将kubelet-bootstrap用户绑定到系统集群角色(maste执行)

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

7.3 启动kubelet服务(slave1,slave2)

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

7.4 approve kubelet CSR 请求(master)

kubectl get csr
kubectl certificate approve csr编号
kubectl get csr

csr 状态变为 Approved,Issued 即可
Requesting User：请求 CSR 的用户，kube-apiserver 对它进行认证和授权；
Subject：请求签名的证书信息；
证书的 CN 是 system:node:kube-node2， Organization 是 system:nodes，kube-apiserver 的 Node 授权模式会授予该证书的相关权限；

7.5 查看集群状态

[root@master /root] master
# kubectl  get  nodes,cs


NAME          STATUS   ROLES    AGE    VERSION
node/slave1   Ready    <none>   2d2h   v1.13.0
node/slave2   Ready    <none>   2d2h   v1.13.0

NAME                                 STATUS    MESSAGE             ERROR
componentstatus/controller-manager   Healthy   ok                  
componentstatus/scheduler            Healthy   ok                  
componentstatus/etcd-2               Healthy   {"health":"true"}   
componentstatus/etcd-1               Healthy   {"health":"true"}   
componentstatus/etcd-0               Healthy   {"health":"true"}

8 部署 node kube-proxy 组件（slave1，slave2执行）

kube-proxy 运行在所有 node节点上，它监听 apiserver 中 service 和 Endpoint 的变化情况，创建路由规则来进行服务负载均衡。

** 创建kube-proxy配置文件**

vim  /cloud/k8s/kubernetes/cfg/kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=slave1 \
--cluster-cidr=10.0.0.0/24 \
--kubeconfig=/cloud/k8s/kubernetes/cfg/kube-proxy.kubeconfig"

创建kube-proxy systemd unit 文件

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

[Service]
EnvironmentFile=/cloud/k8s/kubernetes/cfg/kube-proxy
ExecStart=/cloud/k8s/kubernetes/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

启动kube-proxy服务

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

检查服务运行状态

[root@slave1 /root] node(slave2同理)
#  systemctl status kube-proxy

9 其他插件安装

metrics-server二进制搭建
 docker私有库搭建
 CentOS 7中搭建NFS文件共享存储服务的完整步骤
 dashboard部署

写作不易，您的鼓励是我前进的动力。
在这里插入图片描述

JontyYang

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
3
评论
二进制搭建Kubernetes集群环境

目录引言1. 架构1.1 k8s 架构说明1.2 Flannel网络架构图。1.3 Kubernetes工作流程2.集群初始化（初始化三个节点都执行）2.1节点说明2.2 操作系统环境2.3 软件包2.4 初始化环境2.4.1 设置关闭防火墙及selinux2.4.2 关闭swap2.4.3 设置Docker所需参数2.4.4 安装Docker2.4.5 创建相关目录2.4.6 ssh配置2.4....
复制链接

扫一扫