精华内容
下载资源
问答
  • 详细的K8S集群部署手册
  • 涉及到的内容 LVS HAProxy Harbor etcd... 主要是考虑到了etcd的问题,如果只有两台物理机部署了5个etcd节点,那么部署了3个etcd的那台物理机故障了,则不满足etcd失败容忍度而导致etcd集群宕机,从而导致k8s集群宕机。

    涉及到的内容

    LVS

    HAProxy

    Harbor

    etcd

    Kubernetes (Master Worker)

    整体拓补图

    以上是最小生产可用的整体拓补图(相关节点根据需要进行增加,但不能减少)

    按功能组划分

    SLB

    LVS

    HAProxy

    etcd

    K8S Node (Master / Worker)

    SLB

    LVS 、HAProxy 被规划为基础层,主要提供了一个高可用的7层负载均衡器。

    由LVS keepalived 提供一个高可用的VIP(虚拟IP)。

    这个VIP DR模式转发到后端的HAProxy服务器。

    HAProxy反代了K8S Master服务器,提供了K8S Master API的高可用和负载均衡能力。

    可以使用Nginx代替HAProxy吗?

    是可以的,这边使用HAproxy是因为k8s文档中出现了HAproxy,且后续可能会有4层反代的要求,从而使用了HAProxy。

    可以直接从LVS转发到Master吗?

    理论上可行,我没有试验。

    如果不缺两台机器推荐还是架设一层具有7层代理能力的服务。

    k8s apiserver、harbor、etcd都是以HTTP的方式提供的api,如果有7层代理能力的服务后续会更容易维护和扩展。

    推荐配置

    用途

    数量

    CPU

    内存

    Keepalive

    2

    4

    4GB

    HAProxy

    2

    4

    4GB

    etcd

    etcd是一个采用了raft算法的分布式键值存储系统。

    这不是k8s专属的是一个独立的分布式系统,具体的介绍大家可以参考官网,这边不多做介绍。

    我们采用了 static pod的方式部署了etcd集群。

    失败容忍度

    最小可用节点数:(n/2)+1,下面是一个参考表格,其中加粗的是推荐的节点数量:

    总数

    最少存活

    失败容忍

    1

    1

    0

    2

    2

    0

    3

    2

    1

    4

    3

    1

    5

    3

    2

    6

    4

    2

    7

    4

    3

    8

    5

    3

    9

    5

    4

    推荐配置

    括号内是官方推荐的配置

    用途

    数量

    CPU

    内存

    etcd

    3

    4 (8~16)

    8GB (16GB~64GB)

    Kubernetes集群

    kubernetes集群主要有两种类型的节点:Master和Worker。

    Master则是集群领导。

    Worker是工作者节点。

    可以看出这边主要的工作在Master节点,Worker节点根据具体需求随意增减就好了。

    Master节点的高可用拓补官方给出了两种方案。

    Stacked etcd topology(堆叠etcd)

    External etcd topology(外部etcd)

    可以看出最主要的区别在于etcd的部署方式。

    第一种方案是所有k8s Master节点都运行一个etcd在本机组成一个etcd集群。

    第二种方案则是使用外部的etcd集群(额外搭建etcd集群)。

    我们采用的是第二种,外部etcd,拓补图如下:

    如果采用堆叠的etcd拓补图则是:

    这边大家可以根据具体的情况选择,推荐使用第二种,外部的etcd。

    Master节点的组件

    apiserver

    controller-manager

    scheduler

    一个master节点主要含有上面3个组件 ( 像cloud-controller-manager这边就不多做说明了,正常不会用到 )

    apiserver: 一个api服务器,所有外部与k8s集群的交互都需要经过它。(可水平扩展)

    controller-manager: 执行控制器逻辑(循环通过apiserver监控集群状态做出相应的处理)(一个master集群中只会有一个节点处于激活状态)

    scheduler: 将pod调度到具体的节点上(一个master集群中只会有一个节点处于激活状态)

    可以看到除了apiserver外都只允许一个 实例处于激活状态(类HBase)运行于其它节点上的实例属于待命状态,只有当激活状态的实例不可用时才会尝试将自己设为激活状态。

    这边牵扯到了领导选举(zookeeper、consul等分布式集群系统也是需要领导选举)

    Master高可用需要几个节点?失败容忍度是多少?

    k8s依赖etcd所以不存在数据一致性的问题(把数据一致性压到了etcd上),所以k8s master不需要采取投票的机制来进行选举,而只需节点健康就可以成为leader。

    所以这边master并不要求奇数,偶数也是可以的。

    那么master高可用至少需要2个节点,失败容忍度是(n/0)+1,也就是只要有一个是健康的k8s master集群就属于可用状态。(这边需要注意的是master依赖etcd,如果etcd不可用那么master也将不可用)

    硬件配置

    用途

    数量

    CPU

    内存

    Master

    3

    4

    8GB

    高可用验证

    至此生产可用的k8s集群已“搭建完成”。为什么打引号?因为还没有进行测试和验证,下面给出我列出的验证清单

    还有涉及的BGP相关的验证不在此次文章内容中,后续会为大家说明。

    写在最后

    还有一点需要注意的是物理机的可用性,如果这些虚拟机全部在一台物理机上那么还是存在“单点问题”。这边建议至少3台物理机以上。

    为什么需要3台物理机以上?

    主要是考虑到了etcd的问题,如果只有两台物理机部署了5个etcd节点,那么部署了3个etcd的那台物理机故障了,则不满足etcd失败容忍度而导致etcd集群宕机,从而导致k8s集群宕机。

    展开全文
  • k8s集群部署

    2020-10-05 19:36:00
    一、虚拟机配置: 1、创建三个虚拟机k8s-node1、k8s-node2、k8s-master(需要两个及以上处理器)。 2、需要配置网卡,网卡1...二、部署K8S集群 环境配置 1.关闭swap(这个应该放到最后执行,先执行有可能会导致后续修改

    一、虚拟机配置:

    1、创建三个虚拟机k8s-node1、k8s-node2、k8s-master(需要两个及以上处理器)。

    2、需要配置网卡,网卡1配置为NAT模式。

    NAT模式:相当于宿主机再构建一个局域网,虚拟机无法和本局域网中的其他真实主机进行通讯。只需要宿主机器能访问互联网,那么虚拟机就能上网,不需要再去配置IP地址,子网掩码,网关。虚拟机和主机能够互相ping通。

    3、网卡2配置为桥接模式(或者只有主机网络),为了方便和宿主机进行连接。桥接网络要保证ip地址和主机的ip地址网段一致,否则ping不通。

    桥接模式:桥接模式的虚拟机就像是局域网中的一台独立的主机,它可以访问网内任何一台机器。但是需要我们手动去配置IP地址和网关,IP地址要与主机的无线网的IP段对应,子网掩码,网关,DNS都需要与宿主机保持一致。
    4、设置宿主机为bios为非安全模式。

    二、部署K8S集群

    环境配置

    1.关闭swap(这个应该放到最后执行,先执行有可能会导致后续修改/etc/hosts失败)。

    #临时关闭(永久关闭之前先执行)
    swapoff -a
    #永久关闭
    注释掉etc/fstab中有swap的一行,然后reboot重启即可
    

    2.关闭防火墙安全规则,并关闭防火墙。

    sed -i 's/enforcing/disabled/' /etc/selinux/config
    setenforce 0
    
    systemctl stop firewalld
    #取消开机启动
    systemctl disable firewalld
    

    3.修改hostname并将对应关系添加到hosts文件中。

    #修改hostname名称
    vim /etc/hostname     //将名称改成想要的值即可
    
    #将节点ip以及对应的hostname添加到hosts文件中
    192.168.1.104    k8s-master
    192.168.2.105    k8s-node2
    192.168.1.106    k8s-node1
    

    4.将桥接的ipv4流量传递到iptables的链。

    cat > /etc/sysctl.d/k8s.conf << EOF
    net.bridge.bridge-nf-call-ip6tables=1
    net.bridge.bridge-nf-call-iptables=1
    EOF
    

    如果修改/etc/hosts/提示是只读文件,运行如下命令(swap关闭会有该提示):

    mount -o remount rw /
    

    安装docker、kubelet、kubeadm、kubectl

    1、安装docker

    #1、删除系统中存在的docker文件
    yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-selinux \
    docker-engine-selinux \
    docker-engine
    #2、将mapper-device lvm 等docker需要使用的组件进行安装
    yum install -y yum-utils device-mapper-persistent-data lvm2
    #3、配置阿里云源
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    #4、更新yum缓存
    yum makecache fast
    #5、安装docker
    yum -y install docker-ce
    #6、启动服务并设置开机重启
    systemctl start docker
    systemctl enable docker
    

    配置docker加速

    {
      "registry-mirrors": ["https://1xapgjb7.mirror.aliyuncs.com"]
    }
    

    2、为k8s添加阿里云yum源:

    $ cat > /etc/yum.repos.d/kubernetes.repo << EOF
    [kubernetes]
    name=Kubernetes
    baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
    enabled=1
    gpgcheck=0
    repo_gpgcheck=0
    gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
    EOF
    

    3、安装kubelet、kubeadm、kubectl

    yum install -y kubelet-1.17.3 kubeadm-1.17.3 kubectl-1.17.3
    

    4、开启kubelet并设置开机启动

    systemctl start kubelet
    systemctl enable kubelet
    

    5、初始化master节点(这一步和下一步都是针对master节点)

     #开始之前先执行一个脚本,用于观察初始化进度
     ./master-images.sh
     #初始化master
     kubeadm init \
      --apiserver-advertise-address=192.168.168.133 \
      --image-repository registry.aliyuncs.com/google_containers \
      --kubernetes-version v1.17.3 \
      --service-cidr=10.96.0.0/16 \
      --pod-network-cidr=10.244.0.0/16
    

    上一步执行完会有提示指令创建一些目录以及在将从节点加入集群的命令,跟着操作就好。

    6、建立Flannel网络:

    kucectl apply -f kube-flannel.yml
    

    7、集群加入从节点(在node1和node2执行):

    kubeadm join 192.168.1.104:6443 --token x3z7ig.4ey4dp0s3c2yagqw --discovery-token-ca-cert-hash sha256:b3ecd425501c2d08e9fb6a50a6af44ddc0effd8b2974ac913d9a1e369f399484
    

    可能会遇到的问题:

    ​ 1、可能会有每次开启虚拟机ip地址变化的问题

    1.1修改配置文件:
    
    vim /etc/sysconfig/network-scripts/ifcfg-ens33                    #不一定是ens33,视自己情况而定
    
    1.2、更改如下,以后启动虚拟机都是指定的ip:
    
    #静态网络地址配置
    NAME=ens33                                              #指定网络链接的名字为ens33,不固定
    DEVICE=ens33                                            #指定文件管理的网卡名称
    BOOTPROTO=static                                        #dhcp动态获取,none和static都表示静态网络
    ONBOOT=yes                                              #是否开机启动
    IPADDR=192.168.1.104                                    #设定ip为192.168.1.104
    NETMASK=255.0.0.0|PREFIX=8                              #子网掩码设置
    GATEWAY=198.168.1.2                                     #网关,必须填,否则上不了网
    DNS1=8.8.8.8                                            #同上,不一定是8.8.8.8
    

    ​ 2、从节点运行kubectl出现:The connection to the server localhost:8080 was refused - did you specify the right host or port?

    出现这个问题是因为kubectl需要使用kubernetes-admin来运行。解决方法如下:

    #在master节点将/etc/kubernetes/admin.conf文件拷贝到从节点对应的目录:
    scp /etc/kubernetes/admin.conf root@192.168.1.105:/etc/kubernetes/
    #配置环境变量:
    echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
    #使上述配置生效
    source ~/.bash_profile
    #完成以后即可运行kubectl
    
    展开全文
  • 主要是考虑到了etcd的问题,如果只有两台物理机部署了5个etcd节点,那么部署了3个etcd的那台物理机故障了,则不满足etcd失败容忍度而导致etcd集群宕机,从而导致k8s集群宕机。 针对于上面的面试题我总结出了互联网...

    一、涉及到的内容

    • LVS
    • HAProxy
    • Harbor
    • etcd
    • Kubernetes (Master Worker)
    • 最近经常有粉丝私信我,说博主没有整理出面试突击的资料。这次直接安排上,谁叫我有求必应呢!花了两星期的时间进行筛选和整理最终完成了这篇30天面试突击文稿,希望对大家有所帮助! 整理内容较广,知识点比较全面,篇幅受限无法全部展现出来,文中所有资料都已整理成文件夹,先关注博主一波私信免费获取

    二、整体拓补图

    以上是最小生产可用的整体拓补图(相关节点根据需要进行增加,但不能减少)

    按功能组划分

    • SLBLVSHAProxy
    • etcd
    • K8S Node (Master / Worker)

    三、SLB

    LVS 、HAProxy 被规划为基础层,主要提供了一个高可用的7层负载均衡器。

    由LVS keepalived 提供一个高可用的VIP(虚拟IP)。

    这个VIP DR模式转发到后端的HAProxy服务器。

    HAProxy反代了K8S Master服务器,提供了K8S Master API的高可用和负载均衡能力。

    1. 可以使用Nginx代替HAProxy吗

    是可以的,这边使用HAproxy是因为k8s文档中出现了HAproxy,且后续可能会有4层反代的要求,从而使用了HAProxy。

    2. 可以直接从LVS转发到Master吗

    理论上可行,我没有试验。

    如果不缺两台机器推荐还是架设一层具有7层代理能力的服务。

    k8s apiserver、harbor、etcd都是以HTTP的方式提供的api,如果有7层代理能力的服务后续会更容易维护和扩展。

    3. 推荐配置

    四、etcd

    etcd是一个采用了raft算法的分布式键值存储系统。

    这不是k8s专属的是一个独立的分布式系统,具体的介绍大家可以参考官网,这边不多做介绍。

    我们采用了 static pod的方式部署了etcd集群。

    1. 失败容忍度

    最小可用节点数:(n/2)+1,下面是一个参考表格,其中加粗的是推荐的节点数量:

    2. 推荐配置

    括号内是官方推荐的配置

    五、Kubernetes集群

    kubernetes集群主要有两种类型的节点:Master和Worker。

    • Master则是集群领导。
    • Worker是工作者节点。

    可以看出这边主要的工作在Master节点,Worker节点根据具体需求随意增减就好了。

    Master节点的高可用拓补官方给出了两种方案。

    1. Stacked etcd topology(堆叠etcd)
    2. External etcd topology(外部etcd)

    可以看出最主要的区别在于etcd的部署方式。

    第一种方案是所有k8s Master节点都运行一个etcd在本机组成一个etcd集群。

    第二种方案则是使用外部的etcd集群(额外搭建etcd集群)。

    1. Master节点的组件

    • apiserver
    • controller-manager
    • scheduler

    一个master节点主要含有上面3个组件 ( 像cloud-controller-manager这边就不多做说明了,正常不会用到 )

    • apiserver: 一个api服务器,所有外部与k8s集群的交互都需要经过它。(可水平扩展)
    • controller-manager: 执行控制器逻辑(循环通过apiserver监控集群状态做出相应的处理)(一个master集群中只会有一个节点处于激活状态)
    • scheduler: 将pod调度到具体的节点上(一个master集群中只会有一个节点处于激活状态)

    可以看到除了apiserver外都只允许一个 实例处于激活状态(类HBase)运行于其它节点上的实例属于待命状态,只有当激活状态的实例不可用时才会尝试将自己设为激活状态。这边牵扯到了领导选举(zookeeper、consul等分布式集群系统也是需要领导选举)

    2. Master高可用需要几个节点?失败容忍度是多少

    k8s依赖etcd所以不存在数据一致性的问题(把数据一致性压到了etcd上),所以k8s master不需要采取投票的机制来进行选举,而只需节点健康就可以成为leader。

    所以这边master并不要求奇数,偶数也是可以的。

    那么master高可用至少需要2个节点,失败容忍度是(n/0)+1,也就是只要有一个是健康的k8s master集群就属于可用状态。(这边需要注意的是master依赖etcd,如果etcd不可用那么master也将不可用)

    3. 硬件配置

    六、高可用验证

    至此生产可用的k8s集群已“搭建完成”。为什么打引号?因为还没有进行测试和验证,下面给出我列出的验证清单

    还有涉及的BGP相关的验证不在此次文章内容中,后续会为大家说明。

    七、写在最后

    还有一点需要注意的是物理机的可用性,如果这些虚拟机全部在一台物理机上那么还是存在“单点问题”。这边建议至少3台物理机以上

    为什么需要3台物理机以上

    主要是考虑到了etcd的问题,如果只有两台物理机部署了5个etcd节点,那么部署了3个etcd的那台物理机故障了,则不满足etcd失败容忍度而导致etcd集群宕机,从而导致k8s集群宕机。

    针对于上面的面试题我总结出了互联网公司java程序员面试涉及到的绝大部分面试题及答案做成了文档和架构视频文档免费分享给大家(包括Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术资料),希望能帮助到您面试前的复习且找到一个好的工作,也节省大家在网上搜索资料的时间来学习,也可以关注我一下以后会有更多干货分享。

     

    展开全文
  • K8S1.14高可用生产集群部署方案

    千次阅读 2019-06-18 13:49:20
    配置两个虚拟IP,一个用于k8s集群的apiserver代理,另一个用于nginx ingress入口(也可以单独配置),同时要设置对haproxy的状态判断,如果节点上的haproxy进程结束需要自动切换VIP到另一节点上, 主HA配置如下: ...

     

    酥心糖关注2人评论4059人阅读2019-04-28 10:34:51

    系统说明

    系统组件版本

    • 操作系统: CentOS 7.6
    • Kernel: 4.4
    • Kubernetes: v1.14.1
    • Docker: 18.09 (支持 1.13.1, 17.03, 17.06, 17.09, 18.06, 18.09 )
    • Etcd: v3.3.12
    • Flannel: v0.11
    • cni-plugins: v0.7.5
    • CoreDNS: 1.4.0

    架构示意图

    image

    架构说明:

    1. 使用六台主机,三台Master节点, 三台node节点
    2. Master节点上部署的Kubernetes组件有kube-apiserver, kube-scheduler, kube-controller-manager,kube-proxy。部署网络组件flannel,数据存储集群Etcd.
    3. Master的两个高可用节点部署Haproxy和keepalived
    4. Node 节点部署的Kubernetes组件有Kubelet,kube-proxy。 容器组件Docker,网络组件Flannel
    5. 集群IP和主机名信息:
    集群角色主机名IP
    Mastermaster-1192.168.20.44
    Mastermaster-2192.168.20.45
    Mastermaster-3192.168.20.46
    Nodek8s-node-1192.168.20.47
    Nodek8s-node-2192.168.20.48
    Nodek8s-node-3192.168.20.49
    1. Ceph 需要一个可用的Ceph集群

    系统初始化

    1. 主机初始化

    安装好CentOS7的系统,做以下操作:

    • 关闭firewalld,Selinux。
    • 更新系统软件包,执行yum update
    • 安装elrepo的源,更新内核为4.4或以上版本,并重启生效
    • 分别设置主机名为,并在本地hosts文件中解析。
    • 安装NTP服务
    • 设置内核参数

    设置内核参数的部分,要确认执行如下操作:

    
    # 高可用Master节点设置内核参数
    cat <<EOF >  /etc/sysctl.d/k8s.conf
    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
    net.ipv4.ip_forward = 1
    vm.swappiness = 0
    EOF
    
    # 其他Master节点和计算节点设置内核参数
    cat <<EOF >  /etc/sysctl.d/k8s.conf
    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
    net.ipv4.ip_forward = 1
    vm.swappiness = 0
    EOF

    2. 安装Docker

    由于在Kubernetes1.14的版本中,支持的版本有 1.13.1, 17.03, 17.06, 17.09, 18.06, 18.09,所以这里统一使用Docker 18.09。

    下载docker-ce-18.09的rpm包和阿里云上对应的docker-ce.repo的源,在所有node节点上直接安装:

    mv docker-ce.repo /etc/yum.repos.d/
    yum install docker-ce-18.09.5-3.el7.x86_64.rpm -y
    

    在所有node节点启动docker,并配置自启动:

    systemctl start docker
    systemctl enable docker

    3. 创建目录

    在所有主机上执行如下命令,创建所需目录:

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

    4. 准备Kubernetes软件包

    从github下载kubernetes 1.14版本的二进制软件包,下载地址: https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.14.md#server-binaries

    下载如下软件包:

    [root@master-1 tmp]# ll
    total 537520
    -rw-r--r-- 1 root root 113938518 Jul 24 19:15 kubernetes-node-linux-amd64.tar.gz
    -rw-r--r-- 1 root root 433740362 Jul 24 19:09 kubernetes-server-linux-amd64.tar.gz

    解压:

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

    5.准备etcd和flannel组件

    从github下载etcd v3.3.12和flannel v0.11.0 :

    wget https://github.com/etcd-io/etcd/releases/download/v3.3.12/etcd-v3.3.12-linux-amd64.tar.gz
    wget https://github.com/coreos/flannel/releases/download/v0.11.0/flannel-v0.11.0-linux-amd64.tar.gz
    

    制作CA证书

    Kubernetes支持使用多种方式生成证书,可以使用easyrsa, openssl 或 cfssl任一一种生成。
    参考链接

    这里使用cfssl创建CA证书。

    1.安装CFSSL

    使用cfssl生成CA证书需要单独安装cfssl。

    [root@master-1 ~]# cd /usr/local/src/
    
    curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /opt/kubernetes/bin/cfssl
    curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o /opt/kubernetes/bin/cfssljson
    curl -L https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o /opt/kubernetes/bin/cfssl-certinfo
    chmod +x /opt/kubernetes/bin/*
    

    所有节点添加Kubernetes的bin目录到系统环境变量:

    echo 'PATH=$PATH:/opt/kubernetes/bin' >>/etc/profile
    source /etc/profile

    2.生成证书

    1. 创建需要的配置文件:
    [root@master-1 ~]# cd /opt/kubernetes/ssl/
    [root@master-1 ssl]# cfssl  print-defaults config > config.json
    [root@master-1 ssl]# cfssl print-defaults csr > csr.json
    [root@master-1 ssl]# ll
    total 8
    -rw-r--r-- 1 root root 567 Jul 26 00:05 config.json
    -rw-r--r-- 1 root root 287 Jul 26 00:05 csr.json
    [root@master-1 ssl]# mv config.json ca-config.json
    [root@master-1 ssl]# mv csr.json  ca-csr.json
    
    1. 修改生成的文件为如下内容:
      ca-config.json文件:
    [root@master-1 ssl]# vim ca-config.json
    {
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "kubernetes": {
            "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ],
            "expiry": "87600h"
          }
        }
      }
    }
    

    ca-csr.json文件:

    [root@master-1 ssl]# vim ca-csr.json 
    {
        "CN": "kubernetes",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
              "C": "CN",
              "ST": "BeiJing",
              "L": "BeiJing",
              "O": "k8s",
              "OU": "System"
            }
        ]
    }
    1. 生成证书(ca-key.pem)和秘钥(ca.pem):
    [root@master-1 ssl]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
    2018/07/26 00:27:00 [INFO] generating a new CA key and certificate from CSR
    2018/07/26 00:27:00 [INFO] generate received request
    2018/07/26 00:27:00 [INFO] received CSR
    2018/07/26 00:27:00 [INFO] generating key: rsa-2048
    2018/07/26 00:27:01 [INFO] encoded CSR
    2018/07/26 00:27:01 [INFO] signed certificate with serial number 479065525331838190845576195908271097044538206777
    [root@master-1 ssl]# ll
    total 20
    -rw-r--r-- 1 root root  386 Jul 26 00:16 ca-config.json
    -rw-r--r-- 1 root root 1001 Jul 26 00:27 ca.csr
    -rw-r--r-- 1 root root  255 Jul 26 00:20 ca-csr.json
    -rw------- 1 root root 1679 Jul 26 00:27 ca-key.pem
    -rw-r--r-- 1 root root 1359 Jul 26 00:27 ca.pem
    
    1. 分发证书到各个节点:
    [root@master-1 ssl]# scp ca.csr ca.pem ca-key.pem ca-config.json 192.168.20.45:/opt/kubernetes/ssl
    [root@master-1 ssl]# scp ca.csr ca.pem ca-key.pem ca-config.json 192.168.20.46:/opt/kubernetes/ssl
    [root@master-1 ssl]# scp ca.csr ca.pem ca-key.pem ca-config.json 192.168.20.47:/opt/kubernetes/ssl
    [root@master-1 ssl]# scp ca.csr ca.pem ca-key.pem ca-config.json 192.168.20.48:/opt/kubernetes/ssl
    [root@master-1 ssl]# scp ca.csr ca.pem ca-key.pem ca-config.json 192.168.20.49:/opt/kubernetes/ssl

    HA 节点部署

    这里选择两个Master节点部署Haproxy 和 keepalived, keepalived上需要添加监控haproxy应用的脚本。

    keepalived 配置

    1. HA节点下载安装keepalive:
    yum install keepalived -y
    1. 配置两个虚拟IP,一个用于k8s集群的apiserver代理,另一个用于nginx ingress入口(也可以单独配置),同时要设置对haproxy的状态判断,如果节点上的haproxy进程结束需要自动切换VIP到另一节点上, 主HA配置如下:
    # cat /etc/keepalived/keepalived.conf 
    ! Configuration File for keepalived
    
    vrrp_script check_haproxy {
            script "/etc/keepalived/check_haproxy.sh"
            interval 3
            weight -20
    }
    
    vrrp_instance K8S {
        state backup 
        interface eth0
        virtual_router_id 44
        priority 200
        advert_int 5
        authentication {
            auth_type PASS
            auth_pass 1111
        }
        virtual_ipaddress {
            192.168.20.50
            192.168.20.60
    
        }
        track_script {
            check_haproxy
       }
    
    }
    
    1. 从HA配置如下:
    ! Configuration File for keepalived
    
    vrrp_script check_haproxy {
            script "/etc/keepalived/check_haproxy.sh"
            interval 3
            weight -20
    }
    
    vrrp_instance K8S {
        state backup
        interface eth0
        virtual_router_id 44
        priority 190
        advert_int 5
        authentication {
            auth_type PASS
            auth_pass 1111
        }
        virtual_ipaddress {
            192.168.20.50
            192.168.20.60
    
        }
        track_script {
            check_haproxy
       }
    }
    
    1. 在这两个节点上配置对应的监测脚本:
    vim /etc/keepalived/check_haproxy.sh
    
    #!/bin/bash
    active_status=`netstat -lntp|grep haproxy|wc -l`
    if [ $active_status -gt 0 ]; then
        exit 0
    else
        exit 1
    fi
    1. 需要添加权限
    chmod +x /etc/keepalived/check_haproxy.sh

    部署Haproxy

    官方配置手册

    1. 需要先确认已经配置了内核参数:
    echo 'net.ipv4.ip_nonlocal_bind = 1'>>/etc/sysctl.conf
    echo 'net.ipv4.ip_forward = 1'>>/etc/sysctl.conf
    
    sysctl -p
    1. 安装haproxy
    yum install haproxy -y
    1. 配置haproxy, 我们为k8s集群设计的VIP为 192.168.20.50,使用4层代理的方式, 配置文件如下:
    # cat /etc/haproxy/haproxy.cfg |egrep -v "^#"
    
    global
    
        log         127.0.0.1 local2
    
        chroot      /var/lib/haproxy
        pidfile     /var/run/haproxy.pid
        maxconn     4000
        user        haproxy
        group       haproxy
        daemon
    
        # turn on stats unix socket
        stats socket /var/lib/haproxy/stats
    
    defaults
        mode                    tcp           # 修改默认为四层代理
        log                     global
        option                  httplog
        option                  dontlognull
        option http-server-close
        option forwardfor       except 127.0.0.0/8
        option                  redispatch
        retries                 3
        timeout http-request    10s
        timeout queue           1m
        timeout connect         10s
        timeout client          1m
        timeout server          1m
        timeout http-keep-alive 10s
        timeout check           10s
        maxconn                 3000
    
    frontend  main 192.168.20.50:6443
        acl url_static       path_beg       -i /static /images /javascript /stylesheets
        acl url_static       path_end       -i .jpg .gif .png .css .js
    
        default_backend             k8s-node
    
    backend k8s-node
        mode        tcp             # 修改为tcp
        balance     roundrobin
        server  k8s-node-1  192.168.20.44:6443 check     # 三个master主机
        server  k8s-node-2  192.168.20.45:6443 check
        server  k8s-node-3  192.168.20.46:6443 check
    

    配置完成之后检查IP是否可以自动切换。

    部署ETCD集群

    1.安装etcd

    执行如下命令,完成etcd的安装:

    [root@master-1 ~]# cd /tmp/
    [root@master-1 tmp]# tar xf etcd-v3.3.12-linux-amd64.tar.gz 
    [root@master-1 tmp]# cd etcd-v3.3.12-linux-amd64
    [root@master-1 tmp]# cp etcd* /opt/kubernetes/bin/
    [root@master-1 tmp]# scp etcd* 192.168.20.45:/opt/kubernetes/bin/
    [root@master-1 tmp]# scp etcd* 192.168.20.46:/opt/kubernetes/bin/
    

    2.生成etcd的专属证书

    1.创建etcd证书签名请求

    [root@master-1 ~]# vim etcd-csr.json
    {
      "CN": "etcd",
      "hosts": [
        "127.0.0.1",
    "192.168.20.44",
    "192.168.20.45",
    "192.168.20.46"
      ],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
      ]
    }
    

    2.生成etcd证书

    [root@master-1 ~]# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem  \
    -ca-key=/opt/kubernetes/ssl/ca-key.pem  \
    -config=/opt/kubernetes/ssl/ca-config.json  \
    -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

    会生成如下文件:

    [root@master-1 ~]# ll
    total 16
    -rw-r--r-- 1 root root 1062 Jul 26 01:18 etcd.csr
    -rw-r--r-- 1 root root  287 Jul 26 00:50 etcd-csr.json
    -rw------- 1 root root 1679 Jul 26 01:18 etcd-key.pem
    -rw-r--r-- 1 root root 1436 Jul 26 01:18 etcd.pem
    
    1. 移动证书到ssl目录:
    [root@master-1 ~]#  cp etcd*.pem /opt/kubernetes/ssl
    [root@master-1 ~]# scp etcd*.pem 192.168.20.45:/opt/kubernetes/ssl
    [root@master-1 ~]# scp etcd*.pem 192.168.20.46:/opt/kubernetes/ssl

    3.配置etcd

    1. 配置ETCD配置文件

    master-1上的配置为:

    [root@master-1 ~]# vim /opt/kubernetes/cfg/etcd.conf
    #[member]
    ETCD_NAME="etcd-node-1"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    #ETCD_SNAPSHOT_COUNTER="10000"
    #ETCD_HEARTBEAT_INTERVAL="100"
    #ETCD_ELECTION_TIMEOUT="1000"
    ETCD_LISTEN_PEER_URLS="https://192.168.20.44:2380"
    ETCD_LISTEN_CLIENT_URLS="https://192.168.20.44:2379,https://127.0.0.1:2379"
    #ETCD_MAX_SNAPSHOTS="5"
    #ETCD_MAX_WALS="5"
    #ETCD_CORS=""
    #[cluster]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.20.44:2380"
    # if you use different ETCD_NAME (e.g. test),
    # set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."
    ETCD_INITIAL_CLUSTER="etcd-node-1=https://192.168.20.44:2380,etcd-node-2=https://192.168.20.45:2380,etcd-node-3=https://192.168.20.46:2380"
    ETCD_INITIAL_CLUSTER_STATE="new"
    ETCD_INITIAL_CLUSTER_TOKEN="k8s-etcd-cluster"
    ETCD_ADVERTISE_CLIENT_URLS="https://192.168.20.44:2379"
    #[security]
    CLIENT_CERT_AUTH="true"
    ETCD_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    PEER_CLIENT_CERT_AUTH="true"
    ETCD_PEER_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_PEER_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_PEER_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"

    master-2上的配置为:

    [root@master-2 tmp]# vim /opt/kubernetes/cfg/etcd.conf
    #[member]
    ETCD_NAME="etcd-node-2"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    #ETCD_SNAPSHOT_COUNTER="10000"
    #ETCD_HEARTBEAT_INTERVAL="100"
    #ETCD_ELECTION_TIMEOUT="1000"
    ETCD_LISTEN_PEER_URLS="https://192.168.20.45:2380"
    ETCD_LISTEN_CLIENT_URLS="https://192.168.20.45:2379,https://127.0.0.1:2379"
    #ETCD_MAX_SNAPSHOTS="5"
    #ETCD_MAX_WALS="5"
    #ETCD_CORS=""
    #[cluster]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.20.45:2380"
    # if you use different ETCD_NAME (e.g. test),
    # set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."
    ETCD_INITIAL_CLUSTER="etcd-node-1=https://192.168.20.44:2380,etcd-node-2=https://192.168.20.45:2380,etcd-node-3=https://192.168.20.46:2380"
    ETCD_INITIAL_CLUSTER_STATE="new"
    ETCD_INITIAL_CLUSTER_TOKEN="k8s-etcd-cluster"
    ETCD_ADVERTISE_CLIENT_URLS="https://192.168.20.45:2379"
    #[security]
    CLIENT_CERT_AUTH="true"
    ETCD_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    PEER_CLIENT_CERT_AUTH="true"
    ETCD_PEER_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_PEER_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_PEER_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    

    master-3上的配置为:

    [root@master-3 ~]# vim /opt/kubernetes/cfg/etcd.conf
    #[member]
    ETCD_NAME="etcd-node-3"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    #ETCD_SNAPSHOT_COUNTER="10000"
    #ETCD_HEARTBEAT_INTERVAL="100"
    #ETCD_ELECTION_TIMEOUT="1000"
    ETCD_LISTEN_PEER_URLS="https://192.168.20.46:2380"
    ETCD_LISTEN_CLIENT_URLS="https://192.168.20.46:2379,https://127.0.0.1:2379"
    #ETCD_MAX_SNAPSHOTS="5"
    #ETCD_MAX_WALS="5"
    #ETCD_CORS=""
    #[cluster]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.20.46:2380"
    # if you use different ETCD_NAME (e.g. test),
    # set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."
    ETCD_INITIAL_CLUSTER="etcd-node-1=https://192.168.20.44:2380,etcd-node-2=https://192.168.20.45:2380,etcd-node-3=https://192.168.20.46:2380"
    ETCD_INITIAL_CLUSTER_STATE="new"
    ETCD_INITIAL_CLUSTER_TOKEN="k8s-etcd-cluster"
    ETCD_ADVERTISE_CLIENT_URLS="https://192.168.20.46:2379"
    #[security]
    CLIENT_CERT_AUTH="true"
    ETCD_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    PEER_CLIENT_CERT_AUTH="true"
    ETCD_PEER_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    ETCD_PEER_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    ETCD_PEER_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"

    在三个节点上创建etcd的systemd文件:

    [root@master-1 ~]# vim /usr/lib/systemd/system/etcd.service
    [Unit]
    Description=etcd
    Documentation=https://github.com/coreos/etcd
    Conflicts=etcd.service
    Conflicts=etcd2.service
    
    [Service]
    Type=notify
    Restart=always
    RestartSec=5s
    LimitNOFILE=40000
    TimeoutStartSec=0
    WorkingDirectory=/var/lib/etcd
    EnvironmentFile=-/opt/kubernetes/cfg/etcd.conf
    # set GOMAXPROCS to number of processors
    ExecStart=/bin/bash -c "GOMAXPROCS=$(nproc) /opt/kubernetes/bin/etcd"
    
    [Install]
    WantedBy=multi-user.target
    
    1. 启动ETCD服务,在三个节点执行如下命令:
    mkdir /var/lib/etcd
    systemctl daemon-reload
    systemctl start etcd
    systemctl enable etcd

    确认所以节点的etcd服务启动。

    4.验证集群

    [root@master-1 ~]# etcdctl --endpoints=https://192.168.20.44:2379 \
     --ca-file=/opt/kubernetes/ssl/ca.pem \
     --cert-file=/opt/kubernetes/ssl/etcd.pem \
     --key-file=/opt/kubernetes/ssl/etcd-key.pem cluster-health
    member 32922a109cfe00b2 is healthy: got healthy result from https://192.168.20.46:2379
    member 4fa519fdd3e64a84 is healthy: got healthy result from https://192.168.20.45:2379
    member cab6e832332e8b2a is healthy: got healthy result from https://192.168.20.44:2379
    cluster is healthy

    Master节点部署

    1.部署Kubernetes软件包

    [root@master-1 ~]# cd /tmp/kubernetes/server/bin/
    [root@master-1 bin]# cp kube-apiserver /opt/kubernetes/bin/
    [root@master-1 bin]# cp kube-controller-manager /opt/kubernetes/bin/
    [root@master-1 bin]# cp kube-scheduler /opt/kubernetes/bin/
    

    2.生成API Server的认证文件

    参考链接

    1.创建用于生成CSR的JSON文件,这里需要指定HA代理的IP,和集群的ClusterIP:

    [root@master-1 ~]# cd /opt/kubernetes/ssl
    [root@master-1 ssl]# vim kubernetes-csr.json
    {
      "CN": "kubernetes",
      "hosts": [
        "127.0.0.1",
        "192.168.20.50",
        "10.1.0.1",
        "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"
        }
      ]
    }
    

    2.生成Kubernetes的证书和私钥

    [root@master-1 ssl]# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
       -ca-key=/opt/kubernetes/ssl/ca-key.pem \
       -config=/opt/kubernetes/ssl/ca-config.json \
       -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
    
    1. 将私钥分发到其它所有的node节点中:
    [root@master-1 ssl]# scp kubernetes*.pem 192.168.20.46:/opt/kubernetes/ssl/
    ...
    1. 创建 API Server使用的token文件
    [root@master-1 ~]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
    197f33fcbbfab2d15603dcc4408358f5
    [root@master-1 ~]# vim /opt/kubernetes/ssl/bootstrap-token.csv
    197f33fcbbfab2d15603dcc4408358f5,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
    1. 创建基础用户名,密码认证配置
    [root@k8s-node-1 ~]#  vim /opt/kubernetes/ssl/basic-auth.csv
    admin,admin,1
    readonly,readonly,2
    
    1. 将ssl目录的文件拷贝到其它的master节点上
    scp -r -p /opt/kubernetes/ssl/*  k8s-node-1:/opt/kubernetes/ssl/
    scp -r -p /opt/kubernetes/ssl/*  k8s-node-2:/opt/kubernetes/ssl/
    scp -r -p /opt/kubernetes/ssl/*  k8s-node-3:/opt/kubernetes/ssl/

    3.部署kube-apiserver

    1. 创建kube-apiserver的systemd文件
    [root@k8s-node-1 ~]#  vim /usr/lib/systemd/system/kube-apiserver.service
    [Unit]
    Description=Kubernetes API Server
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    After=network.target
    
    [Service]
    ExecStart=/opt/kubernetes/bin/kube-apiserver \
      --enable-admission-plugins=MutatingAdmissionWebhook,ValidatingAdmissionWebhook,NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota,NodeRestriction \
      --bind-address=192.168.20.44 \
      --insecure-bind-address=127.0.0.1 \
      --authorization-mode=Node,RBAC \
      --runtime-config=rbac.authorization.k8s.io/v1 \
      --kubelet-https=true \
      --anonymous-auth=false \
      --basic-auth-file=/opt/kubernetes/ssl/basic-auth.csv \
      --enable-bootstrap-token-auth \
      --token-auth-file=/opt/kubernetes/ssl/bootstrap-token.csv \
      --service-cluster-ip-range=10.1.0.0/16 \
      --service-node-port-range=20000-40000 \
      --tls-cert-file=/opt/kubernetes/ssl/kubernetes.pem \
      --tls-private-key-file=/opt/kubernetes/ssl/kubernetes-key.pem \
      --client-ca-file=/opt/kubernetes/ssl/ca.pem \
      --service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \
      --etcd-cafile=/opt/kubernetes/ssl/ca.pem \
      --etcd-certfile=/opt/kubernetes/ssl/kubernetes.pem \
      --etcd-keyfile=/opt/kubernetes/ssl/kubernetes-key.pem \
      --etcd-servers=https://192.168.20.44:2379,https://192.168.20.45:2379,https://192.168.20.46:2379 \
      --enable-swagger-ui=true \
      --allow-privileged=true \
      --audit-log-maxage=30 \
      --audit-log-maxbackup=3 \
      --audit-log-maxsize=100 \
      --audit-log-path=/opt/kubernetes/log/api-audit.log \
      --event-ttl=1h \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    Restart=on-failure
    RestartSec=5
    Type=notify
    LimitNOFILE=65536
    
    [Install]
    WantedBy=multi-user.target
    
    1. 启动kube-apiserver服务
    [root@k8s-node-1 ~]# systemctl daemon-reload
    [root@k8s-node-1 ~]# systemctl start kube-apiserver
    [root@k8s-node-1 ~]# systemctl enable kube-apiserver
    
    1. 查看服务状态是否正常
    [root@master-1 ~]# systemctl status kube-apiserver
    [root@master-1 ~]# netstat -lntp|grep kube-apiserver
    tcp        0      0 192.168.20.44:6443      0.0.0.0:*               LISTEN      4289/kube-apiserver 
    tcp        0      0 127.0.0.1:8080          0.0.0.0:*               LISTEN      4289/kube-apiserver 

    4.部署controller-manager

    1. 生成controller-manager的systemd文件
    [root@master-1 ~]# vim /usr/lib/systemd/system/kube-controller-manager.service
    [Unit]
    Description=Kubernetes Controller Manager
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    
    [Service]
    ExecStart=/opt/kubernetes/bin/kube-controller-manager \
      --bind-address=127.0.0.1 \
      --master=http://127.0.0.1:8080 \
      --allocate-node-cidrs=true \
      --service-cluster-ip-range=10.1.0.0/16 \
      --cluster-cidr=10.2.0.0/16 \
      --cluster-name=kubernetes \
      --cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \
      --cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem \
      --service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \
      --root-ca-file=/opt/kubernetes/ssl/ca.pem \
      --leader-elect=true \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    
    Restart=on-failure
    RestartSec=5
    
    [Install]
    WantedBy=multi-user.target
    1. 启动kube-controller-manager
    [root@master-1 ~]# systemctl daemon-reload
    [root@master-1 ~]# systemctl start kube-controller-manager
    [root@master-1 ~]# systemctl enable kube-controller-manager
    
    1. 查看服务状态
    [root@master-1 ~]# systemctl status kube-controller-manager
    [root@master-1 ~]# netstat -lntp|grep kube-con
    tcp        0      0 127.0.0.1:10252         0.0.0.0:*               LISTEN      4390/kube-controlle 
    

    5.部署Kubernetes Scheduler

    1. 创建systemd文件:
    [root@master-1 ~]# vim /usr/lib/systemd/system/kube-scheduler.service
    [Unit]
    Description=Kubernetes Scheduler
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    
    [Service]
    ExecStart=/opt/kubernetes/bin/kube-scheduler \
      --address=127.0.0.1 \
      --master=http://127.0.0.1:8080 \
      --leader-elect=true \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    
    Restart=on-failure
    RestartSec=5
    
    [Install]
    WantedBy=multi-user.target
    1. 启动服务
    [root@master-1 ~]# systemctl daemon-reload
    [root@master-1 ~]# systemctl start kube-scheduler
    [root@master-1 ~]# systemctl enable kube-scheduler
    1. 查看服务状态
    [root@master-1 ~]# systemctl status kube-scheduler
    [root@master-1 ~]# netstat -lntp|grep kube-scheduler
    tcp        0      0 127.0.0.1:10251         0.0.0.0:*               LISTEN      4445/kube-scheduler

    6. Master节点部署kube-proxy(可选)

    (参见node节点部署部分,需要创建对应的kube-proxy家目录)

    7. 使用上述方式,配置master-1和master-2

    1. 将master-1上的ssl,cfg,bin 文件拷贝到其它master节点的对应位置。
    2. 配置各个服务的启动文件,并启动。

    8.部署kubectl命令行工具

    1. 安装二进制包
    [root@master-1 ~]# cd /tmp/kubernetes/node/bin/
    [root@master-1 bin]# cp kubectl /opt/kubernetes/bin/

    2.创建admin证书签名

    [root@master-1 ~]# vim /opt/kubernetes/ssl/admin-csr.json
    {
      "CN": "admin",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }

    3.生成admin证书和私钥

    [root@master-1 ~]# cd /opt/kubernetes/ssl/
    [root@master-1 ssl]# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
       -ca-key=/opt/kubernetes/ssl/ca-key.pem \
       -config=/opt/kubernetes/ssl/ca-config.json \
       -profile=kubernetes admin-csr.json | cfssljson -bare admin
    
    1. 设置集群参数
    [root@master-1 ~]#  kubectl config set-cluster kubernetes \
        --certificate-authority=/opt/kubernetes/ssl/ca.pem \
        --embed-certs=true \
        --server=https://192.168.20.50:6443
    Cluster "kubernetes" set.
    

    5.设置客户端认证参数:

    [root@naster-1 ~]# kubectl config set-credentials admin \
        --client-certificate=/opt/kubernetes/ssl/admin.pem \
        --embed-certs=true \
        --client-key=/opt/kubernetes/ssl/admin-key.pem
    User "admin" set.
    

    6.设置上下文参数

    [root@master-1 ~]# kubectl config set-context kubernetes \
        --cluster=kubernetes \
        --user=admin
    Context "kubernetes" created.
    

    7.设置默认上下文:

    [root@master-1 ~]# kubectl config use-context kubernetes
    Switched to context "kubernetes".
    

    8.使用Kubectl工具查看当前状态:

    [root@master-1 ~]# kubectl get cs
    NAME                 STATUS    MESSAGE             ERROR
    scheduler            Healthy   ok                  
    controller-manager   Healthy   ok                  
    etcd-1               Healthy   {"health":"true"}   
    etcd-2               Healthy   {"health":"true"}   
    etcd-0               Healthy   {"health":"true"}   

    Node节点部署

    1.安装所需的服务

    将kubernetes-node-linux-amd64.tar.gz压缩包在node节点解压,执行如下操作

    [root@k8s-node-1 ~]# cd /tmp/kubernetes/node/bin
    [root@k8s-node-1 bin]# cp kubelet kube-proxy  /opt/kubernetes/bin/
    [root@k8s-node-1 bin]# scp kubelet kube-proxy  192.168.20.48:/opt/kubernetes/bin/
    [root@k8s-node-1 bin]# scp kubelet kube-proxy  192.168.20.49:/opt/kubernetes/bin/

    2.配置角色和认证参数

    1. 在master-1上创建角色绑定
    [root@master-1 ~]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
    clusterrolebinding.rbac.authorization.k8s.io "kubelet-bootstrap" created
    
    1. 创建kubelet bootstrapping kubeconfig文件,设置集群参数
    [root@master-1 ~]# kubectl config set-cluster kubernetes \
       --certificate-authority=/opt/kubernetes/ssl/ca.pem \
       --embed-certs=true \
       --server=https://192.168.20.50:6443 \
       --kubeconfig=bootstrap.kubeconfig
    Cluster "kubernetes" set.

    3.设置客户端认证参数

    [root@master-1 ~]# kubectl config set-credentials kubelet-bootstrap \
       --token=197f33fcbbfab2d15603dcc4408358f5 \
       --kubeconfig=bootstrap.kubeconfig   
    
    User "kubelet-bootstrap" set.
    

    4.设置上下文认证参数

    [root@master-1 ~]# kubectl config set-context default \
        --cluster=kubernetes \
        --user=kubelet-bootstrap \
        --kubeconfig=bootstrap.kubeconfig
    Context "default" created.
    

    5.选择默认上下文

    [root@master-1 ~]# kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
    Switched to context "default"

    6.执行上面的操作后,会在当前目录生成一个bootstrap.kubeconfig的config文件,将此文件分发到各节点:

    [root@k8s-node-1 ~]# cp bootstrap.kubeconfig /opt/kubernetes/cfg/
    [root@k8s-node-1 ~]# scp bootstrap.kubeconfig 192.168.20.47:/opt/kubernetes/cfg/
    [root@k8s-node-1 ~]# scp bootstrap.kubeconfig 192.168.20.48:/opt/kubernetes/cfg/
    [root@k8s-node-1 ~]# scp bootstrap.kubeconfig 192.168.20.49:/opt/kubernetes/cfg/
    
    1. 将master上更新的配置拷贝到其它master节点。

    3.设置支持CNI

    以下操作需要在所有node节点执行

    1. 设置Kubernetes对CNI的支持:
    [root@k8s-node-2 ~]# mkdir -p /etc/cni/net.d
    [root@k8s-node-2 ~]# vim /etc/cni/net.d/10-default.conf
    {
            "name": "flannel",
            "type": "flannel",
            "delegate": {
                "bridge": "docker0",
                "isDefaultGateway": true,
                "mtu": 1400
            }
    }
    

    4.配置Kubelet服务

    以下操作需要在所有node节点执行

    1. 创建kubelet服务配置文件
    [root@k8s-node-2 ~]# mkdir /var/lib/kubelet
    [root@k8s-node-2 ~]# vim /usr/lib/systemd/system/kubelet.service
    [Unit]
    Description=Kubernetes Kubelet
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    After=docker.service
    Requires=docker.service
    
    [Service]
    WorkingDirectory=/var/lib/kubelet
    ExecStart=/opt/kubernetes/bin/kubelet \
      --address=192.168.20.48 \
      --hostname-override=192.168.20.48 \
      --pod-infra-container-image=mirrorgooglecontainers/pause-amd64:3.1 \
      --experimental-bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
      --kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
      --cert-dir=/opt/kubernetes/ssl \
      --network-plugin=cni \
      --cni-conf-dir=/etc/cni/net.d \
      --cni-bin-dir=/opt/kubernetes/bin/cni \
      --cluster-dns=10.1.0.2 \
      --cluster-domain=cluster.local. \
      --hairpin-mode hairpin-veth \
      --allow-privileged=true \
      --fail-swap-on=false \
      --logtostderr=true \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    Restart=on-failure
    RestartSec=5
    
    [Install]
    WantedBy=multi-user.target
    
    1. 启动Kubelet
    [root@k8s-node-2 ~]# systemctl daemon-reload
    [root@k8s-node-2 ~]# systemctl start kubelet
    [root@k8s-node-2 ~]# systemctl enable kubelet
    [root@k8s-node-2 ~]# systemctl status kubelet
    
    1. 在master节点上查看是否收到node节点的csr请求:
    [root@master-1 ~]# kubectl get csr
    NAME                                                   AGE       REQUESTOR           CONDITION
    node-csr-FDH7Y3rghf1WPsEJH2EYnofvOSeyHn2f-l_-4rH-LEk   2m        kubelet-bootstrap   Pending
    
    1. 批准kubelet的TLS请求
    [root@master-1 ~]# kubectl get csr|grep 'Pending' | awk 'NR>0{print $1}'| xargs kubectl certificate approve
    certificatesigningrequest.certificates.k8s.io "node-csr-FDH7Y3rghf1WPsEJH2EYnofvOSeyHn2f-l_-4rH-LEk" approved
    
    [root@kmaster-1 ~]# kubectl get csr
    NAME                                                   AGE       REQUESTOR           CONDITION
    node-csr-FDH7Y3rghf1WPsEJH2EYnofvOSeyHn2f-l_-4rH-LEk   11m       kubelet-bootstrap   Approved,Issued
    
    1. 之后查看node节点状态:
    [root@master-1 ~]# kubectl get node
    NAME            STATUS    ROLES     AGE       VERSION
    192.168.20.48   Ready     <none>    35s       v1.14.1
    

    node节点上查看kubelet 服务

    [root@k8s-node-2 ~]# netstat -lntp|grep kubelet
    tcp        0      0 127.0.0.1:10248         0.0.0.0:*               LISTEN      7917/kubelet        
    tcp        0      0 192.168.20.32:10250     0.0.0.0:*               LISTEN      7917/kubelet        
    tcp        0      0 192.168.20.32:10255     0.0.0.0:*               LISTEN      7917/kubelet        
    tcp        0      0 192.168.20.32:4194      0.0.0.0:*               LISTEN      7917/kubelet     
    

    5.部署kube-proxy

    1.配置kube-proxy使用LVS,所有节点执行:

    yum install -y ipvsadm ipset conntrack

    2.创建证书请求

    [root@master-1 ~]# vim kube-proxy-csr.json
    {
      "CN": "system:kube-proxy",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
      ]
    }

    3.生成证书

    [root@master-1 ~]#  cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
        -ca-key=/opt/kubernetes/ssl/ca-key.pem \
        -config=/opt/kubernetes/ssl/ca-config.json \
        -profile=kubernetes  kube-proxy-csr.json | cfssljson -bare kube-proxy

    4.分发证书到所有node节点

    [root@master-1 ~]# cp kube-proxy*.pem /opt/kubernetes/ssl/
    [root@master-1 ~]# scp kube-proxy*.pem 192.168.20.47:/opt/kubernetes/ssl/
    [root@master-1 ~]# scp kube-proxy*.pem 192.168.20.48:/opt/kubernetes/ssl/
    [root@master-1 ~]# scp kube-proxy*.pem 192.168.20.49:/opt/kubernetes/ssl/

    5.创建kube-proxy配置文件

    [root@k8s-node-2 ~]# kubectl config set-cluster kubernetes  \
      --certificate-authority=/opt/kubernetes/ssl/ca.pem   \
      --embed-certs=true   \
      --server=https://192.168.20.50:6443 \
      --kubeconfig=kube-proxy.kubeconfig
    Cluster "kubernetes" set.
    

    6.创建kube-proxy用户:

    [root@k8s-node-2 ~]# kubectl config set-credentials kube-proxy \
        --client-certificate=/opt/kubernetes/ssl/kube-proxy.pem \
        --client-key=/opt/kubernetes/ssl/kube-proxy-key.pem \
        --embed-certs=true \
        --kubeconfig=kube-proxy.kubeconfig
    User "kube-proxy" set.

    7.设置默认上下文:

    [root@k8s-node-2 ~]# kubectl config set-context default \
        --cluster=kubernetes \
        --user=kube-proxy \
        --kubeconfig=kube-proxy.kubeconfig
    Context "default" created.
    

    8.切换上下文为default:

    [root@k8s-node-2 ~]# kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
    Switched to context "default".

    9.分发kube-proxy.kubeconfig配置文件到所有

    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.44:/opt/kubernetes/cfg/
    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.45:/opt/kubernetes/cfg/
    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.46:/opt/kubernetes/cfg/
    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.47:/opt/kubernetes/cfg/
    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.48:/opt/kubernetes/cfg/
    [root@k8s-node-2 ~]# scp kube-proxy.kubeconfig 192.168.20.459/opt/kubernetes/cfg/
    

    10.创建kube-proxy服务配置文件

    所有节点执行,注意配置文件中IP需要修改为本机对应的IP

    [root@k8s-node-1 ~]# mkdir /var/lib/kube-proxy
    [root@k8s-node-1 ~]# vim /usr/lib/systemd/system/kube-proxy.service
    [Unit]
    Description=Kubernetes Kube-Proxy Server
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    After=network.target
    
    [Service]
    WorkingDirectory=/var/lib/kube-proxy
    ExecStart=/opt/kubernetes/bin/kube-proxy \
      --bind-address=192.168.20.47 \
      --hostname-override=192.168.20.47 \
      --kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig \
      --masquerade-all \
      --feature-gates=SupportIPVSProxyMode=true \
      --proxy-mode=ipvs \
      --ipvs-min-sync-period=5s \
      --ipvs-sync-period=5s \
      --ipvs-scheduler=rr \
      --logtostderr=true \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    
    Restart=on-failure
    RestartSec=5
    LimitNOFILE=65536
    
    [Install]
    WantedBy=multi-user.target
    

    11.启动服务

    systemctl start kube-proxy
    systemctl enable kube-proxy
    systemctl status kube-proxy
    

    12.查看服务状态,lvs状态

    [root@k8s-node-1 ~]# ipvsadm -L -n
    IP Virtual Server version 1.2.1 (size=4096)
    Prot LocalAddress:Port Scheduler Flags
      -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
    TCP  10.1.0.1:443 rr
      -> 192.168.20.44:6443           Masq    1      0          0         
      -> 192.168.20.45:6443           Masq    1      0          0         
      -> 192.168.20.46:6443           Masq    1      1          0  
    

    所有node节点配置成功后可以看到如下结果:

    [root@master-1 ~]# kubectl get node
    NAME            STATUS   ROLES    AGE     VERSION
    192.168.20.47   Ready    <none>   6d21h   v1.14.1
    192.168.20.48   Ready    <none>   4d1h    v1.14.1
    192.168.20.49   Ready    <none>   4d1h    v1.14.1
    

    Flannel 网络部署

    所有节点都需要部署flannel。

    1.创建Flannel证书

    1.生成证书文件

    [root@master-1 ~]# vim flanneld-csr.json
    {
      "CN": "flanneld",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "ST": "BeiJing",
          "L": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
      ]
    }
    

    2.生成证书

    [root@master-1 ~]# cfssl gencert -ca=/opt/kubernetes/ssl/ca.pem \
        -ca-key=/opt/kubernetes/ssl/ca-key.pem \
        -config=/opt/kubernetes/ssl/ca-config.json \
        -profile=kubernetes flanneld-csr.json | cfssljson -bare flanneld
    

    3.分发证书

    [root@master-1 ~]# cp flanneld*.pem /opt/kubernetes/ssl/
    [root@master-1 ~]# scp flanneld*.pem {all-k8s-node}:/opt/kubernetes/ssl/

    2.部署flannel

    1.将之前下载的flannel压缩包解压,并分发到其它节点如下操作:

    cp mk-docker-opts.sh flanneld /opt/kubernetes/bin/
    scp mk-docker-opts.sh flanneld {all-k8s-node}:/opt/kubernetes/bin/
    

    2.创建如下文件,分发到各个node节点:

    [root@k8s-node-1 tmp]# vim remove-docker0.sh
    #!/bin/bash
    # Delete default docker bridge, so that docker can start with flannel network.
    
    # exit on any error
    set -e
    
    rc=0
    ip link show docker0 >/dev/null 2>&1 || rc="$?"
    if [[ "$rc" -eq "0" ]]; then
      ip link set dev docker0 down
      ip link delete docker0
    fi
    
    [root@k8s-node-1 tmp]# cp remove-docker0.sh /opt/kubernetes/bin/
    [root@k8s-node-1 tmp]# scp remove-docker0.sh 192.168.20.48:/opt/kubernetes/bin/
    [root@k8s-node-1 tmp]# scp remove-docker0.sh 192.168.20.49:/opt/kubernetes/bin/

    3.配置flannel

    [root@k8s-node-1 ~]# vim /opt/kubernetes/cfg/flannel
    FLANNEL_ETCD="-etcd-endpoints=https://192.168.20.31:2379,https://192.168.20.32:2379,https://192.168.20.33:2379"
    FLANNEL_ETCD_KEY="-etcd-prefix=/kubernetes/network"
    FLANNEL_ETCD_CAFILE="--etcd-cafile=/opt/kubernetes/ssl/ca.pem"
    FLANNEL_ETCD_CERTFILE="--etcd-certfile=/opt/kubernetes/ssl/flanneld.pem"
    FLANNEL_ETCD_KEYFILE="--etcd-keyfile=/opt/kubernetes/ssl/flanneld-key.pem"
    1. 创建flannel服务文件
    [root@k8s-node-1 ~]# vim /usr/lib/systemd/system/flannel.service
    [Unit]
    Description=Flanneld overlay address etcd agent
    After=network.target
    Before=docker.service
    
    [Service]
    EnvironmentFile=-/opt/kubernetes/cfg/flannel
    ExecStartPre=/opt/kubernetes/bin/remove-docker0.sh
    ExecStart=/opt/kubernetes/bin/flanneld ${FLANNEL_ETCD} ${FLANNEL_ETCD_KEY} ${FLANNEL_ETCD_CAFILE} ${FLANNEL_ETCD_CERTFILE} ${FLANNEL_ETCD_KEYFILE}
    ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -d /run/flannel/docker
    
    Type=notify
    
    [Install]
    WantedBy=multi-user.target
    RequiredBy=docker.service

    5.分发创建的配置文件到各个节点:

    scp /opt/kubernetes/cfg/flannel {all-k8s-node}:/opt/kubernetes/cfg/
    scp /usr/lib/systemd/system/flannel.service {all-k8s-node}:/usr/lib/systemd/system/
    

    3. Flannel CNI集成

    1.下载CNI插件

    wget https://github.com/containernetworking/plugins/releases/download/v0.7.5/cni-plugins-amd64-v0.7.5.tgz
    [root@k8s-node-1 tmp]# mkdir /opt/kubernetes/bin/cni
    [root@k8s-node-1 tmp]# tar xf cni-plugins-amd64-v0.7.5.tgz -C /opt/kubernetes/bin/cni
    

    2.分发软件到各个节点:

    [root@k8s-node-1 ~]# scp -r /opt/kubernetes/bin/cni/* {all-k8s-node}:/opt/kubernetes/bin/cni/

    3.在etcd中创建key

    [root@master-1 ~]# /opt/kubernetes/bin/etcdctl --ca-file /opt/kubernetes/ssl/ca.pem --cert-file /opt/kubernetes/ssl/flanneld.pem --key-file /opt/kubernetes/ssl/flanneld-key.pem \
         --no-sync -C https://192.168.20.44:2379,https://192.168.20.45:2379,https://192.168.20.46:2379 \
         mk /kubernetes/network/config '{ "Network": "10.2.0.0/16", "Backend": { "Type": "vxlan", "VNI": 1 }}' >/dev/null 2>&1
    

    4.各个节点启动flannel

    [root@k8s-node-1 ~]# chmod +x /opt/kubernetes/bin/*
    [root@k8s-node-1 ~]# systemctl daemon-reload
    [root@k8s-node-1 ~]# systemctl start flannel 
    [root@k8s-node-1 ~]# systemctl enable flannel 
    

    配置Docker使用Flannel

    1.修改docker的systemd的文件:

    [Unit] #在Unit下面修改After和增加Requires
    After=network-online.target firewalld.service flannel.service
    Wants=network-online.target
    Requires=flannel.service
    
    [Service] #增加EnvironmentFile=-/run/flannel/docker
    Type=notify
    EnvironmentFile=-/run/flannel/docker
    ExecStart=/usr/bin/dockerd $DOCKER_OPTS

    2.其它NODE节点也做相同的修改

    [root@k8s-node-2 ~]# scp /usr/lib/systemd/system/docker.service {k8s-node}:/usr/lib/systemd/system/

    3.重启docker, 出现docker0网卡,且在10.2.0.0/16网段,说明配置成功

    [root@k8s-node-3 ~]# systemctl daemon-reload
    [root@k8s-node-3 ~]# systemctl restart docker
    [root@k8s-node-3 ~]# ip a| grep -A 3 'docker0'
    7: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN 
        link/ether 02:42:e9:2b:36:86 brd ff:ff:ff:ff:ff:ff
        inet 10.2.79.1/24 scope global docker0
           valid_lft forever preferred_lft forever
    

    插件部署

    1.创建CoreDNS

    1. 创建coredns.yaml,内容如下:
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: coredns
      namespace: kube-system
      labels:
          kubernetes.io/cluster-service: "true"
          addonmanager.kubernetes.io/mode: Reconcile
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      labels:
        kubernetes.io/bootstrapping: rbac-defaults
        addonmanager.kubernetes.io/mode: Reconcile
      name: system:coredns
    rules:
    - apiGroups:
      - ""
      resources:
      - endpoints
      - services
      - pods
      - namespaces
      verbs:
      - list
      - watch
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
      annotations:
        rbac.authorization.kubernetes.io/autoupdate: "true"
      labels:
        kubernetes.io/bootstrapping: rbac-defaults
        addonmanager.kubernetes.io/mode: EnsureExists
      name: system:coredns
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: system:coredns
    subjects:
    - kind: ServiceAccount
      name: coredns
      namespace: kube-system
    ---
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: coredns
      namespace: kube-system
      labels:
          addonmanager.kubernetes.io/mode: EnsureExists
    data:
      Corefile: |
        .:53 {
            errors
            health
            kubernetes cluster.local. in-addr.arpa ip6.arpa {
                pods insecure
                upstream
                fallthrough in-addr.arpa ip6.arpa
            }
            prometheus :9153
            proxy . /etc/resolv.conf
            cache 30
        }
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      name: coredns
      namespace: kube-system
      labels:
        k8s-app: coredns
        kubernetes.io/cluster-service: "true"
        addonmanager.kubernetes.io/mode: Reconcile
        kubernetes.io/name: "CoreDNS"
    spec:
      replicas: 2
      strategy:
        type: RollingUpdate
        rollingUpdate:
          maxUnavailable: 1
      selector:
        matchLabels:
          k8s-app: coredns
      template:
        metadata:
          labels:
            k8s-app: coredns
        spec:
          serviceAccountName: coredns
          tolerations:
            - key: node-role.kubernetes.io/master
              effect: NoSchedule
            - key: "CriticalAddonsOnly"
              operator: "Exists"
          containers:
          - name: coredns
            image: coredns/coredns:1.4.0
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                memory: 170Mi
              requests:
                cpu: 100m
                memory: 70Mi
            args: [ "-conf", "/etc/coredns/Corefile" ]
            volumeMounts:
            - name: config-volume
              mountPath: /etc/coredns
            ports:
            - containerPort: 53
              name: dns
              protocol: UDP
            - containerPort: 53
              name: dns-tcp
              protocol: TCP
            livenessProbe:
              httpGet:
                path: /health
                port: 8080
                scheme: HTTP
              initialDelaySeconds: 60
              timeoutSeconds: 5
              successThreshold: 1
              failureThreshold: 5
          dnsPolicy: Default
          volumes:
            - name: config-volume
              configMap:
                name: coredns
                items:
                - key: Corefile
                  path: Corefile
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: coredns
      namespace: kube-system
      labels:
        k8s-app: coredns
        kubernetes.io/cluster-service: "true"
        addonmanager.kubernetes.io/mode: Reconcile
        kubernetes.io/name: "CoreDNS"
    spec:
      selector:
        k8s-app: coredns
      clusterIP: 10.1.0.2
      ports:
      - name: dns
        port: 53
        protocol: UDP
      - name: dns-tcp
        port: 53
        protocol: TCP
    
    1. 执行此文件:
    [root@master-1 tmp]# kubectl create -f coredns.yaml
    1. 确认DNS服务运行:
    [root@master-1 ~]# kubectl get pod  -n kube-system  -o wide
    NAME                                    READY   STATUS    RESTARTS   AGE    IP          NODE            NOMINATED NODE   READINESS GATES
    coredns-76fcfc9f65-9fkfh                1/1     Running   2          3d7h   10.2.45.3   192.168.20.49   <none>           <none>
    coredns-76fcfc9f65-zfplt                1/1     Running   1          3d6h   10.2.24.2   192.168.20.48   <none>           <none>
    

    2. 部署Dashboard

    1.执行目录中的yaml,部署Dashboard:

    [root@master-1 ~]# ll /tmp/dashboard/
    total 20
    -rw-r--r-- 1 root root  356 Jul 27 03:43 admin-user-sa-rbac.yaml
    -rw-r--r-- 1 root root 4253 Jul 27 03:47 kubernetes-dashboard.yaml
    -rw-r--r-- 1 root root  458 Jul 27 03:49 ui-admin-rbac.yaml
    -rw-r--r-- 1 root root  477 Jul 27 03:50 ui-read-rbac.yaml
    
    [root@master-1 ~]# kubectl create -f /tmp/dashboard/

    2.确认服务是否正常运行:

    [root@master-1 ~]# kubectl get pod -n kube-system
    NAME                                    READY   STATUS    RESTARTS   AGE
    coredns-76fcfc9f65-9fkfh                1/1     Running   2          3d7h
    coredns-76fcfc9f65-zfplt                1/1     Running   1          3d6h
    kubernetes-dashboard-68ddcc97fc-w4bxf   1/1     Running   1          3d2h
    
    [root@master-1 ~]# kubectl cluster-info
    Kubernetes master is running at https://192.168.20.50:6443
    CoreDNS is running at https://192.168.20.50:6443/api/v1/namespaces/kube-system/services/coredns:dns/proxy
    kubernetes-dashboard is running at https://192.168.20.50:6443/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy
    
    To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
    

    3.根据提示信息,使用dashboard的url,登录,账号admin/admin, 使用如下命令生成token:

    [root@master-1 ~]# kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')

    4.复制token,选择使用令牌的方式登录:

    image

    3. Heapster 部署 (可选)

    1.使用如下文件部署Heastper:

    [root@master-1 ~]# ll heastper/
    total 12
    -rw-r--r-- 1 root root 2306 Jul 26 20:28 grafana.yaml
    -rw-r--r-- 1 root root 1562 Jul 26 20:29 heapster.yaml
    -rw-r--r-- 1 root root 1161 Jul 26 20:29 influxdb.yaml
    
    [root@k8s-node-1 ~]# kubectl create -f heastper/
    1. 登录dashboard,查看石头出现资源利用率的图表。

    image

    1. 使用kubectl cluster-info命令,查看当前服务的url地址。

    补充说明

    etcd无证书配置说明

    在实际的生产环境中,如果都是使用的内网环境,可以将etd集群配置为无证书的模式,这样在配置和后续的故障恢复中会更简单。
    etcd无证书配置需要使用http访问,安装上述文档,需要修改如下配置:

    1. etcd的配置文件注释掉安全证书部分,并将所有url改为http方式:
    # cat /opt/kubernetes/cfg/etcd.conf
    #[member]
    ETCD_NAME="etcd-node-1"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    #ETCD_SNAPSHOT_COUNTER="10000"
    #ETCD_HEARTBEAT_INTERVAL="100"
    #ETCD_ELECTION_TIMEOUT="1000"
    ETCD_LISTEN_PEER_URLS="http://192.168.20.31:2380"
    ETCD_LISTEN_CLIENT_URLS="http://192.168.20.31:2379"
    #ETCD_MAX_SNAPSHOTS="5"
    #ETCD_MAX_WALS="5"
    #ETCD_CORS=""
    #[cluster]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.20.31:2380"
    # if you use different ETCD_NAME (e.g. test),
    # set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."
    ETCD_INITIAL_CLUSTER="etcd-node-1=http://192.168.20.31:2380,etcd-node-2=http://192.168.20.32:2380,etcd-node-3=http://192.168.20.33:2380"
    ETCD_INITIAL_CLUSTER_STATE="new"
    ETCD_INITIAL_CLUSTER_TOKEN="k8s-etcd-cluster"
    ETCD_ADVERTISE_CLIENT_URLS="http://192.168.20.31:2379"
    #[security]
    #CLIENT_CERT_AUTH="true"
    #ETCD_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    #ETCD_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    #ETCD_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    #PEER_CLIENT_CERT_AUTH="true"
    #ETCD_PEER_CA_FILE="/opt/kubernetes/ssl/ca.pem"
    #ETCD_PEER_CERT_FILE="/opt/kubernetes/ssl/etcd.pem"
    #ETCD_PEER_KEY_FILE="/opt/kubernetes/ssl/etcd-key.pem"
    1. fannel网络部分注释掉etcd的证书配置参数,并将URL该位http:
    # cat /opt/kubernetes/cfg/flannel 
    
    FLANNEL_ETCD="-etcd-endpoints=http://192.168.20.31:2379,http://192.168.20.32:2379,http://192.168.20.33:2379"
    FLANNEL_ETCD_KEY="-etcd-prefix=/kubernetes/network"
    #FLANNEL_ETCD_CAFILE="--etcd-cafile=/opt/kubernetes/ssl/ca.pem"
    #FLANNEL_ETCD_CERTFILE="--etcd-certfile=/opt/kubernetes/ssl/flanneld.pem"
    #FLANNEL_ETCD_KEYFILE="--etcd-keyfile=/opt/kubernetes/ssl/flanneld-key.pem"
    

    3.kube-apiserver中去掉etcd的证书配置,这个文件中需要把参数直接删除,并将url改为http:

    # cat /usr/lib/systemd/system/kube-apiserver.service
    [Unit]
    Description=Kubernetes API Server
    Documentation=https://github.com/GoogleCloudPlatform/kubernetes
    After=network.target
    
    [Service]
    ExecStart=/opt/kubernetes/bin/kube-apiserver \
      --admission-control=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota,NodeRestriction \
      --bind-address=192.168.20.31 \
      --insecure-bind-address=127.0.0.1 \
      --authorization-mode=Node,RBAC \
      --runtime-config=rbac.authorization.k8s.io/v1 \
      --kubelet-https=true \
      --anonymous-auth=false \
      --basic-auth-file=/opt/kubernetes/ssl/basic-auth.csv \
      --enable-bootstrap-token-auth \
      --token-auth-file=/opt/kubernetes/ssl/bootstrap-token.csv \
      --service-cluster-ip-range=10.1.0.0/16 \
      --service-node-port-range=20000-40000 \
      --tls-cert-file=/opt/kubernetes/ssl/kubernetes.pem \
      --tls-private-key-file=/opt/kubernetes/ssl/kubernetes-key.pem \
      --client-ca-file=/opt/kubernetes/ssl/ca.pem \
      --service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \
      --etcd-servers=http://192.168.20.31:2379,http://192.168.20.32:2379,http://192.168.20.33:2379 \
      --enable-swagger-ui=true \
      --allow-privileged=true \
      --audit-log-maxage=30 \
      --audit-log-maxbackup=3 \
      --audit-log-maxsize=100 \
      --audit-log-path=/opt/kubernetes/log/api-audit.log \
      --event-ttl=1h \
      --v=2 \
      --logtostderr=false \
      --log-dir=/opt/kubernetes/log
    Restart=on-failure
    RestartSec=5
    Type=notify
    LimitNOFILE=65536
    
    [Install]
    WantedBy=multi-user.target

    4.分别重启flannel、kubelet、kube-apiserver等服务。

    ©著作权归作者所有:来自51CTO博客作者酥心糖的原创作品,如需转载,请注明出处,否则将追究法律责任

    展开全文
  • 涉及到的内容 LVS HAProxy Harbor etcd Kubernetes (Master Worker) 整体拓补图 以上是最小生产可用的整体拓补图(相关节点...K8S Node (Master / Worker) SLB LVS 、HAProxy 被规划为基础层,主要提供了一个高...
  • K8s部署集群方案总结

    千次阅读 2020-04-30 17:21:22
    [abc-db-service:XXXX](访问集群内部service,见部署并初始化数据3,4步骤) 4、编写service targetPort:容器对外开放端口, port:集群内开放端口 5、测试集群内部的访问情况 kubectl describe service service...
  • Kubernetes集群 高可用验证 写在最后 回到目录 涉及到的内容 LVS HAProxy Harbor etcd Kubernetes (Master Worker) 回到目录 整体拓补图 以上是最小生产可用的整体拓补图(相关节点根据需要进行增加,但...
  • k8s集群下canal-server的伪高可用实践前言问题解决方案总结 前言 前面我们已经介绍了canal的admin、server、adapter三个部分的容器化以及在k8s集群下的搭建过程。在创建canal-server的时候,k8s环境下,容器重启会...
  • k8s基本知识 yaml文件格式 部署思路 本文不涉及持续集成,尽量简单化处理。 原定思路 项目文件存放:nas 日志文件存放:nas 优点: 项目文件使用nas存放,如果集群中存在多个项目,可以使用动态供给,不用为每一个...
  • k8s重要概念及部署k8s集群(一)

    万次阅读 多人点赞 2019-06-22 18:15:43
    cluster是 计算、存储和网络资源的集合,k8s利用这些资源运行各种基于容器的应用。 2.master master是cluster的大脑,他的主要职责是调度,即决定将应用放在那里运行。master运行linux操作系统,可以是物理机...
  • K8S集群部署

    2020-04-23 20:12:29
    k8s集群部署准备工作k8s部署部署1:docker 服务部署2:k8s服务部署3:初始化集群 系统环境版本:Ubuntu 16.04.3 LTS 部署方式:多节点部署 环境要求:在同一个pvc下 准备工作 设置主机名 hostnamectl set-hostname...
  • centos7与ubuntu搭建k8s集群方案,包含了在k8s中搭建的各种常用微服务与存储。
  • 本页面介绍了配置高可用(HA) Kubernetes 集群拓扑的两个选项。 您可以设置 HA 集群: 使用堆叠(stacked)控制平面节点,其中 etcd 节点与控制平面节点共存 使用外部 etcd 节点,其中 etcd 在与控制平面不同的...
  • 用来搭建k8s高可用集群,haproxy,keepalived,k8s高可用集群搭建过程
  • KubeOperator 支持两种 Kubernetes 集群部署方式,一种是自动模式,另外一种是手动模式,我们推荐使用自动模式。在自动模式下,用户需要准备软件定义的 IaaS 云平台,比如 VMware vSphere 和 Openstack 等。自动模式...
  • 用Rancher RKE快速部署高可用k8s集群

    千次阅读 2020-07-27 13:03:59
    用Rancher部署高可用k8s集群用Rancher RKE部署高可用k8s集群1. 主机配置1.1 新建虚拟主机1.2 主机初始化配置安装一些必要的安装包安全设置ntp时钟同步内核参数调优关闭swap分区hostname修改加载ipvs相关模块2. ...
  • K8s集群部署

    2019-08-12 20:43:19
    Kubernetes优势 容器编排 轻量级 开源 弹性伸缩 负载均衡 Kubernetes的核心概念 1.Master k8s集群的管理节点,负责管理集群,提供集群的资源数据访问入口。拥有Etcd存储服务(可选),运行Api Server进程,...
  • 在Kubernetes系统中,调度的最小颗粒不是单纯的容器,而是抽象成一个Pod,Pod是一个可以被创建、销毁、调度、管理的最小的部署单元。比如一个或一组容器。 Replication Controllers Replication Controller是...
  • k8s集群下adapter连接server域名问题改造前言问题解析解决方案 前言 成也容器重启,败也容器重启,说好的重启治百病,在容器这里,是重启出百病啊! 之前说过,我们使用statefuset类型使canal-server域名固定之后又...
  • 阿里云环境部署k8s集群

    千次阅读 2018-10-08 13:48:00
    网上讲述如何部署k8s集群的文章很多,特别是k8s中文社区里面,每个平台的部署方式都有详细说明。但就是看了中文社区的指导,发现一路是坑,第一个源访问的时候就404 NotFound, 更别说那生涩的翻译和版本匹配问题。 ...
  • CentOS 7.5 安装 K8S v1.11.0 集群部署 Kubernetes 是 Google 团队发起的开源项目,它的目标是管理跨多个主机的容器,提供基本的部署,维护以及运用伸缩,主要实现语言为 Go 语言。
  • k8s高可用集群部署教程

    千次阅读 2021-08-13 09:18:16
    方法一:使用堆叠(stacked)控制平面节点,集群master节点与etcd节点共存,etcd也运行在控制节点,混布在一起; 方法二:使用外部独立的etcd集群节点,etcd不与Master节点混布; 两种方式的相同之处在于都提供了...
  • 部署一套完整的企业级K8s集群 一、准备环境 服务器要求: • 建议最小硬件配置:4核CPU、4G内存、50G硬盘 • 服务器最好可以访问外网,会有从网上拉取镜像需求,如果服务器不能上网,需要提前下载对应镜像并导入...
  • K8S集群部署istio

    千次阅读 2021-04-08 12:03:03
    istio 适用于容器或虚拟机环境(特别是 k8s),兼容异构架构。 istio 使用 sidecar(边车模式)代理服务的网络,不需要对业务代码本身做任何的改动。 HTTP、gRPC、WebSocket 和 TCP 流量的自动负载均衡。 istio 通过...
  • nacos集群部署-k8s环境

    千次阅读 2021-01-13 21:01:38
    通过 在Kubernetes上部署Nacos1 快速部署gitclonehttps://github.com/nacos-group/nacos-k8s.gitcdnacos-k8schmod+xquick-startup.sh./quick-startup.sh注意:新版本Nacos只有一个mysql,老版本的Nacos用的是主从...
  • Kubernetes(简称K8S)是开源的容器集群管理系统,可以实现容器集群的自动化部署、自动扩缩容、维护等功能。它既是一款容器编排工具,也是全新的基于容器技术的分布式架构领先方案。在Docker技术的基础上,为容器化...
  • 最好是给每个节点设置不同的hostname,可以通过以下命令修改: hostnamectl set-hostname new-name K8S Dashboard是官方的一个基于WEB的用户界面,专门用来管理K8S集群,并可展示集群的状态。K8S集群安装好后默认...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,228
精华内容 6,891
关键字:

k8s集群部署方案

友情链接: X2 5.1(password=emv).zip