为您推荐:
精华内容
最热下载
问答
  • 5星
    75.33MB u010575833 2021-04-27 11:57:42
  • 11.63MB njbaige 2021-10-15 01:05:15
  • 467KB weixin_38670391 2021-02-25 14:28:29
  • 384B weixin_26907201 2021-06-21 09:08:16
  • 20.92MB weixin_27012835 2021-06-19 23:59:02
  • 5星
    76B qq_35427725 2021-06-17 11:14:27
  • 部署一套完整的企业级K8s集群 一、准备环境 服务器要求: • 建议最小硬件配置:4核CPU、4G内存、50G硬盘 • 服务器最好可以访问外网,会有从网上拉取镜像需求,如果服务器不能上网,需要提前下载对应镜像并导入...

    目录

    部署一套完整的企业级K8s集群

    一、准备环境

    二、部署Nginx+Keepalived高可用负载均衡器

    2.1安装软件包(主/备)

    2.2 Nginx配置文件(主/备一样)

    2.3 keepalived配置文件(Nginx Master)

    2.4 keepalived配置文件(Nginx Backup)

    2.5 启动并设置开机启动

    2.6 查看keepalived工作状态

    2.7 Nginx+Keepalived高可用测试

    三、部署Etcd集群

    3.1 准备cfssl证书生成工具

    3.2 生成Etcd证书

    2、使用自签CA签发Etcd HTTPS证书

    3.3 从Github下载二进制文件

    3.4 部署Etcd集群

    四、安装Docker/kubeadm/kubelet【所有节点】

    4.1 安装Docker

    4.2 添加阿里云YUM软件源

    4.3 安装kubeadm,kubelet和kubectl

    五、部署Kubernetes Master

    5.1 初始化Master1

    5.2 初始化Master2、Master3

    5.3 访问负载均衡器测试

    六、加入Kubernetes Node

    七、部署网络组件

    八、部署 Dashboard


    部署一套完整的企业级K8s集群

    一、准备环境

    服务器要求:

    • 建议最小硬件配置:4核CPU、4G内存、50G硬盘

    • 服务器最好可以访问外网,会有从网上拉取镜像需求,如果服务器不能上网,需要提前下载对应镜像并导入节点

    软件环境:

    软件版本
    操作系统CentOS7.8_x64
    Docker19+
    Kubernetes1.20

    服务器整体规划:

    角色IP其他单装组件
    k8s-master1192.168.1.1docker,etcd,nginx,keepalived
    k8s-master2192.168.1.2docker,etcd,nginx,keepalived
    k8s-master3192.168.1.3docker,etcd,nginx,keepalived
    k8s-node1192.168.1.4docker
    负载均衡器对外IP192.168.1.88 (VIP)

    架构图:

    操作系统初始化配置

    # 关闭防火墙
    systemctl stop firewalld 
    systemctl disable firewalld
    
    # 关闭selinux
    sed -i 's/enforcing/disabled/' /etc/selinux/config  # 永久
    setenforce 0  # 临时
    
    # 关闭swap
    swapoff -a  # 临时
    sed -ri 's/.*swap.*/#&/' /etc/fstab    # 永久
    
    # 根据规划设置主机名
    hostnamectl set-hostname <hostname>
    
    # 在master添加hosts
    cat >> /etc/hosts << EOF
    192.168.1.1 k8s-master1
    192.168.1.2 k8s-master2
    192.168.1.3 k8s-master3
    192.168.1.4 k8s-node1
    EOF
    
    # 将桥接的IPv4流量传递到iptables的链
    cat > /etc/sysctl.d/k8s.conf << EOF
    net.bridge.bridge-nf-call-ip6tables = 1
    net.bridge.bridge-nf-call-iptables = 1
    EOF
    sysctl --system  # 生效
    
    # 时间同步
    yum install ntpdate -y
    ntpdate time.windows.com
    

    二、部署Nginx+Keepalived高可用负载均衡器

    架构图:

    2.1安装软件包(主/备)

     yum install epel-release -y
     yum install nginx keepalived -y

    2.2 Nginx配置文件(主/备一样)

    cat > /etc/nginx/nginx.conf << "EOF"
    user nginx;
    worker_processes auto;
    error_log /var/log/nginx/error.log;
    pid /run/nginx.pid;
    
    include /usr/share/nginx/modules/*.conf;
    
    events {
        worker_connections 1024;
    }
    
    # 四层负载均衡,为两台Master apiserver组件提供负载均衡
    stream {
    
        log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    
        access_log  /var/log/nginx/k8s-access.log  main;
    
        upstream k8s-apiserver {
           server 192.168.1.1:6443;   # Master1 APISERVER IP:PORT
           server 192.168.1.2:6443;   # Master2 APISERVER IP:PORT
           server 192.168.1.3:6443;   # Master3 APISERVER IP:PORT
        }
        
        server {
           listen 16443;  # 由于nginx与master节点复用,这个监听端口不能是6443,否则会冲突
           proxy_pass k8s-apiserver;
        }
    }
    
    http {
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';
    
        access_log  /var/log/nginx/access.log  main;
    
        sendfile            on;
        tcp_nopush          on;
        tcp_nodelay         on;
        keepalive_timeout   65;
        types_hash_max_size 2048;
    
        include             /etc/nginx/mime.types;
        default_type        application/octet-stream;
    
        server {
            listen       80 default_server;
            server_name  _;
    
            location / {
            }
        }
    }
    EOF

    2.3 keepalived配置文件(Nginx Master)

    cat > /etc/keepalived/keepalived.conf << EOF
    global_defs { 
       notification_email { 
         acassen@firewall.loc 
         failover@firewall.loc 
         sysadmin@firewall.loc 
       } 
       notification_email_from Alexandre.Cassen@firewall.loc  
       smtp_server 127.0.0.1 
       smtp_connect_timeout 30 
       router_id NGINX_MASTER
    } 
    
    vrrp_script check_nginx {
        script "/etc/keepalived/check_nginx.sh"
    }
    
    vrrp_instance VI_1 { 
        state MASTER 
        interface eno16780032  # 修改为实际网卡名
        virtual_router_id 51 # VRRP 路由 ID实例,每个实例是唯一的 
        priority 100    # 优先级,备服务器设置 90 80
        advert_int 1    # 指定VRRP 心跳包通告间隔时间,默认1秒 
        authentication { 
            auth_type PASS      
            auth_pass 1111 
        }  
        # 虚拟IP
        virtual_ipaddress { 
            192.168.1.88/24
        } 
        track_script {
            check_nginx
        } 
    }
    EOF

    准备上述配置文件中检查nginx运行状态的脚本:

    cat > /etc/keepalived/check_nginx.sh  << "EOF"
    #!/bin/bash
    count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")
    ​
    if [ "$count" -eq 0 ];then
        exit 1
    else
        exit 0
    fi
    EOF

    赋权限:

    chmod +x /etc/keepalived/check_nginx.sh

    2.4 keepalived配置文件(Nginx Backup)

    cat > /etc/keepalived/keepalived.conf << EOF
    global_defs { 
       notification_email { 
         acassen@firewall.loc 
         failover@firewall.loc 
         sysadmin@firewall.loc 
       } 
       notification_email_from Alexandre.Cassen@firewall.loc  
       smtp_server 127.0.0.1 
       smtp_connect_timeout 30 
       router_id NGINX_BACKUP
    } 
    
    vrrp_script check_nginx {
        script "/etc/keepalived/check_nginx.sh"
    }
    
    vrrp_instance VI_1 { 
        state BACKUP 
        interface eno16780032
        virtual_router_id 51  
        priority 90  #注意优先级
        advert_int 1
        authentication { 
            auth_type PASS      
            auth_pass 1111 
        }  
        virtual_ipaddress { 
            192.168.1.88/24
        } 
        track_script {
            check_nginx
        } 
    }
    EOF

    准备上述配置文件中检查nginx运行状态的脚本:

    cat > /etc/keepalived/check_nginx.sh  << "EOF"
    #!/bin/bash
    count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")
    ​
    if [ "$count" -eq 0 ];then
        exit 1
    else
        exit 0
    fi
    EOF

    赋权限:

    chmod +x /etc/keepalived/check_nginx.sh

    注:keepalived根据脚本返回状态码(0为工作正常,非0不正常)判断是否故障转移。

    2.5 启动并设置开机启动

    systemctl daemon-reload
    systemctl start nginx ; systemctl enable nginx
    systemctl status nginx
    systemctl start keepalived ; systemctl enable keepalived
    systemctl status keepalived

    2.6 查看keepalived工作状态

    ip addr
    2: eno16780032: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
        link/ether 00:0c:29:04:f7:2c brd ff:ff:ff:ff:ff:ff
        inet 192.168.1.1/24 brd 192.168.1.255 scope global noprefixroute eno16780032
           valid_lft forever preferred_lft forever
        inet 192.168.1.88/24 scope global secondary eno16780032
           valid_lft forever preferred_lft forever
    

    可以看到,在eno16780032网卡绑定了192.168.1.88 虚拟IP,说明工作正常。

    2.7 Nginx+Keepalived高可用测试

    关闭主节点Nginx,测试VIP是否漂移到备节点服务器。

    在Nginx Master执行 pkill nginx

    在Nginx Backup,ip addr命令查看已成功绑定VIP。

    三、部署Etcd集群

    Etcd 是一个分布式键值存储系统,Kubernetes使用Etcd进行数据存储,kubeadm搭建默认情况下只启动一个Etcd Pod,存在单点故障,生产环境强烈不建议,所以我们这里使用3台服务器组建集群,可容忍1台机器故障,当然,你也可以使用5台组建集群,可容忍2台机器故障。

    节点名称IP
    etcd-1192.168.1.1
    etcd-2192.168.1.2
    etcd-3192.168.1.3

    注:为了节省机器,这里与K8s节点机器复用。也可以独立于k8s集群之外部署,只要apiserver能连接到就行。

    3.1 准备cfssl证书生成工具

    cfssl是一个开源的证书管理工具,使用json文件生成证书,相比openssl更方便使用。

    找任意一台服务器操作,这里用Master节点。

    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
    
    下载:
    链接:https://pan.baidu.com/s/1HkVnrk1BIEtwUunDiRRy9Q 
    提取码:g6cx 
    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证书

    1、自签证书颁发机构(CA)

    创建工作目录:

    mkdir -p ~/etcd_tls
    cd ~/etcd_tls

    自签CA:

    cat > ca-config.json << EOF
    {
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "www": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }
    EOF
    cat > ca-csr.json << EOF
    {
        "CN": "etcd CA",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "Beijing",
                "ST": "Beijing"
            }
        ]
    }
    EOF

    生成证书:

    cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

    会生成ca.pem和ca-key.pem文件。

    2、使用自签CA签发Etcd HTTPS证书

    创建证书申请文件:

    cat > server-csr.json << EOF
    {
        "CN": "etcd",
        "hosts": [
        "192.168.1.1",
        "192.168.1.2",
        "192.168.1.3"
        ],
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "BeiJing",
                "ST": "BeiJing"
            }
        ]
    }
    EOF

    注:上述文件hosts字段中IP为所有etcd节点的集群内部通信IP,一个都不能少!为了方便后期扩容可以多写几个预留的IP。

    生成证书:

    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

    会生成server.pem和server-key.pem文件。

    3.3 从Github下载二进制文件

    下载地址:https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz

    链接:https://pan.baidu.com/s/17taFEWgUqAT0E7DN7J-Blw 
    提取码:44v4 

    3.4 部署Etcd集群

    以下在节点1上操作,为简化操作,待会将节点1生成的所有文件拷贝到节点2和节点3。

    1、创建工作目录并解压二进制包

    mkdir /opt/etcd/{bin,cfg,ssl} -p
    tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
    mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/

    2、创建etcd配置文件

    cat > /opt/etcd/cfg/etcd.conf << EOF
    #[Member]
    ETCD_NAME="etcd-1"
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    ETCD_LISTEN_PEER_URLS="https://192.168.1.1:2380"
    ETCD_LISTEN_CLIENT_URLS="https://192.168.1.1:2379"
    
    #[Clustering]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.1.1:2380"
    ETCD_ADVERTISE_CLIENT_URLS="https://192.168.1.1:2379"
    ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.1.1:2380,etcd-2=https://192.168.1.2:2380,etcd-3=https://192.168.1.3:2380"
    ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
    ETCD_INITIAL_CLUSTER_STATE="new"
    EOF

    3、配置systemd管理etcd

    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=/opt/etcd/cfg/etcd.conf
    ExecStart=/opt/etcd/bin/etcd \
    --cert-file=/opt/etcd/ssl/server.pem \
    --key-file=/opt/etcd/ssl/server-key.pem \
    --peer-cert-file=/opt/etcd/ssl/server.pem \
    --peer-key-file=/opt/etcd/ssl/server-key.pem \
    --trusted-ca-file=/opt/etcd/ssl/ca.pem \
    --peer-trusted-ca-file=/opt/etcd/ssl/ca.pem \
    --logger=zap
    Restart=on-failure
    LimitNOFILE=65536
    ​
    [Install]
    WantedBy=multi-user.target
    EOF

    4、拷贝刚才生成的证书

    cp ~/etcd_tls/ca*pem ~/etcd_tls/server*pem /opt/etcd/ssl/

    5、启动并设置开机启动(三个节点添加之后可以正常启动)

    systemctl daemon-reload
    systemctl start etcd ; systemctl enable etcd

    6、将上面节点1所有生成的文件拷贝到节点2和节点3

    scp -r /opt/etcd/ root@192.168.1.2:/opt/
    scp /usr/lib/systemd/system/etcd.service root@192.168.1.2:/usr/lib/systemd/system/
    scp -r /opt/etcd/ root@192.168.1.3:/opt/
    scp /usr/lib/systemd/system/etcd.service root@192.168.1.3:/usr/lib/systemd/system/
    

    然后在节点2和节点3分别修改etcd.conf配置文件中的节点名称和当前服务器IP:

    vim /opt/etcd/cfg/etcd.conf
    #[Member]
    ETCD_NAME="etcd-1"   # 修改此处,节点2改为etcd-2,节点3改为etcd-3
    ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    ETCD_LISTEN_PEER_URLS="https://192.168.31.71:2380"   # 修改此处为当前服务器IP
    ETCD_LISTEN_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器IP
    ​
    #[Clustering]
    ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前服务器IP
    ETCD_ADVERTISE_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器IP
    ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.31.71:2380,etcd-2=https://192.168.31.72:2380,etcd-3=https://192.168.31.73:2380"
    ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
    ETCD_INITIAL_CLUSTER_STATE="new"

    启动etcd并设置开机启动。

    systemctl daemon-reload
    systemctl start etcd ; systemctl enable etcd

    7、查看集群状态

    ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.1.1:2379,https://192.168.1.2:2379,https://192.168.1.3:2379" endpoint health --write-out=table
    

    结果展示为一下表示正常:

    +----------------------------+--------+-------------+-------+
    |          ENDPOINT    | HEALTH |    TOOK     | ERROR |
    +----------------------------+--------+-------------+-------+
    | https://192.168.1.1:2379 |   true | 10.301506ms |    |
    | https://192.168.1.3:2379 |   true | 12.87467ms |     |
    | https://192.168.1.2:2379 |   true | 13.225954ms |    |
    +----------------------------+--------+-------------+-------+
    

    如果有问题第一步先看日志:/var/log/message 或 journalctl -u etcd

    四、安装Docker/kubeadm/kubelet【所有节点】

    4.1 安装Docker

    wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
    yum -y install docker-ce
    systemctl enable docker && systemctl start docker

    配置镜像下载加速器:

    cat > /etc/docker/daemon.json << EOF
    {
      "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
    }
    EOF

    重启docker:

    systemctl daemon-reload
    systemctl restart docker
    docker info

    4.2 添加阿里云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

    4.3 安装kubeadm,kubelet和kubectl

    这里指定版本号部署:

    yum install -y kubelet-1.20.4 kubeadm-1.20.4 kubectl-1.20.4
    systemctl enable kubelet

    五、部署Kubernetes Master

    5.1 初始化Master1

    生成初始化配置文件:

    cat > kubeadm-config.yaml << EOF
    apiVersion: kubeadm.k8s.io/v1beta2
    bootstrapTokens:
    - groups:
      - system:bootstrappers:kubeadm:default-node-token
      token: 9037x2.tcaqnpaqkra9vsbw
      ttl: 24h0m0s
      usages:
      - signing
      - authentication
    kind: InitConfiguration
    localAPIEndpoint:
      advertiseAddress: 192.168.1.1
      bindPort: 6443
    nodeRegistration:
      criSocket: /var/run/dockershim.sock
      name: k8s-master1
      taints:
      - effect: NoSchedule
        key: node-role.kubernetes.io/master
    ---
    apiServer:
      certSANs:  # 包含所有Master/LB/VIP IP,一个都不能少!为了方便后期扩容可以多写几个预留的IP。
      - k8s-master1
      - k8s-master2
      - k8s-master3
      - 192.168.1.1
      - 192.168.1.2
      - 192.168.1.3
      - 127.0.0.1
      extraArgs:
        authorization-mode: Node,RBAC
      timeoutForControlPlane: 4m0s
    apiVersion: kubeadm.k8s.io/v1beta2
    certificatesDir: /etc/kubernetes/pki
    clusterName: kubernetes
    controlPlaneEndpoint: 192.168.1.88:16443 # 负载均衡虚拟IP(VIP)和端口
    controllerManager: {}
    dns:
      type: CoreDNS
    etcd:
      external:  # 使用外部etcd
        endpoints:
        - https://192.168.1.1:2379 # etcd集群3个节点
        - https://192.168.1.2:2379
        - https://192.168.1.3:2379
        caFile: /opt/etcd/ssl/ca.pem # 连接etcd所需证书
        certFile: /opt/etcd/ssl/server.pem
        keyFile: /opt/etcd/ssl/server-key.pem
    imageRepository: registry.aliyuncs.com/google_containers # 由于默认拉取镜像地址k8s.gcr.io国内无法访问,这里指定阿里云镜像仓库地址
    kind: ClusterConfiguration
    kubernetesVersion: v1.20.4 # K8s版本,与上面安装的一致
    networking:
      dnsDomain: cluster.local
      podSubnet: 10.244.0.0/16  # Pod网络,与下面部署的CNI网络组件yaml中保持一致
      serviceSubnet: 10.96.0.0/12  # 集群内部虚拟网络,Pod统一访问入口
    scheduler: {}
    EOF

    初始化k8s:

    kubeadm init --config kubeadm-config.yaml
    You can now join any number of control-plane nodes by copying certificate authorities
    and service account keys on each node and then running the following as root:
    
      kubeadm join 192.168.1.88:16443 --token 9037x2.tcaqnpaqkra9vsbw \
        --discovery-token-ca-cert-hash sha256:b1e726042cdd5df3ce62e60a2f86168cd2e64bff856e061e465df10cd36295b8 \
        --control-plane 
    
    Then you can join any number of worker nodes by running the following on each as root:
    
    kubeadm join 192.168.1.88:16443 --token 9037x2.tcaqnpaqkra9vsbw \
        --discovery-token-ca-cert-hash sha256:b1e726042cdd5df3ce62e60a2f86168cd2e64bff856e061e465df10cd36295b8
    

    初始化完成后,会有两个join的命令,带有 --control-plane 是用于加入组建多master集群的,不带的是加入节点的。

    拷贝kubectl使用的连接k8s认证文件到默认路径:

    mkdir -p $HOME/.kube
    sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
    sudo chown $(id -u):$(id -g) $HOME/.kube/config
    kubectl get node
    NAME          STATUS     ROLES                  AGE     VERSION
    k8s-master1   NotReady   control-plane,master   6m42s   v1.20.4

    5.2 初始化Master2、Master3

    将Master1节点生成的证书拷贝到Master2、Master3:

     scp -r /etc/kubernetes/pki/ 192.168.1.2:/etc/kubernetes/
     scp -r /etc/kubernetes/pki/ 192.168.1.3:/etc/kubernetes/
    

    复制加入master join命令在master2、master3执行:

      kubeadm join 192.168.1.88:16443 --token 9037x2.tcaqnpaqkra9vsbw \
        --discovery-token-ca-cert-hash sha256:b1e726042cdd5df3ce62e60a2f86168cd2e64bff856e061e465df10cd36295b8 \
        --control-plane 
    

    拷贝kubectl使用的连接k8s认证文件到默认路径:

    mkdir -p $HOME/.kube
    sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
    sudo chown $(id -u):$(id -g) $HOME/.kube/config
    kubectl get node
    NAME          STATUS     ROLES                  AGE     VERSION
    k8s-master1   NotReady   control-plane,master   28m     v1.20.4
    k8s-master2   NotReady   control-plane,master   2m12s   v1.20.4
    k8s-master3   NotReady   control-plane,master   2m10s   v1.20.4

    注:由于网络插件还没有部署,还没有准备就绪 NotReady

    5.3 访问负载均衡器测试

    找K8s集群中任意一个节点,使用curl查看K8s版本测试,使用VIP访问:

    curl -k https://192.168.1.88:16443/version
    
    {
      "major": "1",
      "minor": "20",
      "gitVersion": "v1.20.4",
      "gitCommit": "e87da0bd6e03ec3fea7933c4b5263d151aafd07c",
      "gitTreeState": "clean",
      "buildDate": "2021-04-18T16:03:00Z",
      "goVersion": "go1.15.8",
      "compiler": "gc",
      "platform": "linux/amd64"
    }

    可以正确获取到K8s版本信息,说明负载均衡器搭建正常。该请求数据流程:curl -> vip(nginx) -> apiserver

    通过查看Nginx日志也可以看到转发apiserver IP:

    tail /var/log/nginx/k8s-access.log -f
    192.168.1.1 192.168.1.1:6443 - [04/Apr/2021:19:17:57 +0800] 200 423
    

    六、加入Kubernetes Node

    在192.168.1.4(Node)执行。

    向集群添加新节点,执行在kubeadm init输出的kubeadm join命令:

    kubeadm join 192.168.1.88:16443 --token 9037x2.tcaqnpaqkra9vsbw \
        --discovery-token-ca-cert-hash sha256:e6a724bb7ef8bb363762fbaa088f6eb5975e0c654db038560199a7063735a697 
    

    后续其他节点也是这样加入。

    注:默认token有效期为24小时,当过期之后,该token就不可用了。这时就需要重新创建token,可以直接使用命令快捷生成:kubeadm token create --print-join-command

    七、部署网络组件

    Calico是一个纯三层的数据中心网络方案,是目前Kubernetes主流的网络方案。

    部署Calico:

    链接:https://pan.baidu.com/s/1cRF0XRwOhaNfBe3OVKT79Q 
    提取码:otm5 

    kubectl apply -f calico.yaml kubectl get pods -n kube-system

    等Calico Pod都Running,节点也会准备就绪:

    kubectl get node
    NAME          STATUS   ROLES                  AGE   VERSION
    k8s-master1    Ready    control-plane,master   50m   v1.20.4
    k8s-master2    Ready    control-plane,master   24m   v1.20.4
    k8s-master3    Ready    control-plane,master   24m   v1.20.4
    k8s-node1     Ready    <none>            20m   v1.20.4

    八、部署 Dashboard

    Dashboard是官方提供的一个UI,可用于基本管理K8s资源。

    链接:https://pan.baidu.com/s/1_6v6BuEkpN-DPoyvQjF_nA 
    提取码:2zh0 

    kubectl apply -f kubernetes-dashboard.yaml

    # 查看部署

    kubectl get pods -n kubernetes-dashboard

    访问地址:https://NodeIP:30001

    创建service account并绑定默认cluster-admin管理员集群角色:

    kubectl create serviceaccount dashboard-admin -n kube-system
    kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
    kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

    使用输出的token登录Dashboard。

    展开全文
    lee_yanyi 2021-04-26 09:50:13
  • 253KB weixin_42795002 2020-12-22 18:07:00
  • 818B weixin_26934905 2021-06-21 08:57:13
  • Kubernetes已经成为业界公认的容器...在创建一个生产就绪的Kubernetes平台之前,你需要准备好将应用程序从传统环境中迁移出来,而这绝不是一项简单的任务。你需要一个etcd数据库、kube-controller、kube-schedule...

    Kubernetes已经成为业界公认的容器编排事实标准,它几乎无所不在。现在已经很难遇到一个从未了解Kubernetes这一技术的IT从业者。软件开发、测试以及基础设施都在其“业务范围”内。

     

    在创建一个生产就绪的Kubernetes平台之前,你需要准备好将应用程序从传统环境中迁移出来,而这绝不是一项简单的任务。你需要一个etcd数据库、kube-controller、kube-scheduler、证书、core-DNS等。它还要投入资源和时间来调研以确定合适的组件组合以及可靠、自适应的测试方法以便在交换或增强组件时可以快速更改。

     

    除了创建环境和管理流程之外,公司战略战术的规划也格外重要。很少有公司仅仅为了满足基础设施的需求而开始采用容器。你的容器环境设计和技术栈更可能需要支持新旧计算形态,同时要避免重复使用资产、资源和费用。(技术栈和设计的功能示例如下图)
     
    构建企业级Kubernetes平台,你需要的工具都在这里!

    图1 搭建容器技术栈
     
    构建企业级Kubernetes平台,你需要的工具都在这里!

    图2 容器环境设计

     

    管理和自动化

     

    Rancher是一个开源的企业级Kubernetes管理平台,为企业用户提供Kubernetes-as-a-Service (Kubernetes即服务),它简洁直观的界面风格及操作体验,极大程度解决了业界遗留已久的Kubernetes原生UI易用性不佳以及学习曲线陡峭的问题。通过使用Rancher,你可以远离手动创建Kubernetes集群的痛苦并且可以一键自动设置集群。它还提供一套K8s集群所需的功能集,包括配置、访问控制、全局DNS、灾备和恢复、监控、日志以及集群升级。使用Ansible将可以为K8s节点配置 CentOS VMs。
     

    日志和监控

     

    Rancher具有内置的FluentD部署,可用于构建EFK堆栈。可以将每个集群配置为把FluentD日志推送到Elasticsearch实例。

     

    Kibana是一个开源的可视化平台,可以极为方便地查看和搜索Elasticsearch日志。

     
    Elasticsearch Github repo:

    https://github.com/helm/charts/tree/master/stable/elasticsearch

     

    Prometheus是一个收集监控指标的优质方案,Prometheus server可用于存储时间序列数据,alert-manager可用于管理告警,node-exporter可从节点导出指标,Kube-state-metrics可以为所有k8s对象生成指标。
     

    Prometheus Github repo:

    https://github.com/helm/charts/tree/master/stable/prometheus

     

    然而,Prometheus缺少用户界面,因此需要Grafana,这是一个数据可视化工具。它能够连接到Prometheus server,提供监控用的图表和dashboard。
     

    Grafana Github repo:

    https://github.com/helm/charts/tree/master/stable/grafana
     

    管理和自动化

     

    Rancher是一个开源的企业级Kubernetes管理平台,为企业用户提供Kubernetes-as-a-Service (Kubernetes即服务),它简洁直观的界面风格及操作体验,极大程度解决了业界遗留已久的Kubernetes原生UI易用性不佳以及学习曲线陡峭的问题。通过使用Rancher,你可以远离手动创建Kubernetes集群的痛苦并且可以一键自动设置集群。它还提供一套K8s集群所需的功能集,包括配置、访问控制、全局DNS、灾备和恢复、监控、日志以及集群升级。使用Ansible将可以为K8s节点配置 CentOS VMs。
     

    日志和监控

     

    Rancher具有内置的FluentD部署,可用于构建EFK堆栈。可以将每个集群配置为把FluentD日志推送到Elasticsearch实例。

     

    Kibana是一个开源的可视化平台,可以极为方便地查看和搜索Elasticsearch日志。
     

    Elasticsearch Github repo:

    https://github.com/helm/charts/tree/master/stable/elasticsearch

     

    Prometheus是一个收集监控指标的优质方案,Prometheus server可用于存储时间序列数据,alert-manager可用于管理告警,node-exporter可从节点导出指标,Kube-state-metrics可以为所有k8s对象生成指标。

     

    Prometheus Github repo:

    https://github.com/helm/charts/tree/master/stable/prometheus

     
    然而,Prometheus缺少用户界面,因此需要Grafana,这是一个数据可视化工具。它能够连接到Prometheus server,提供监控用的图表和dashboard。

     

    Grafana Github repo:

    https://github.com/helm/charts/tree/master/stable/grafana
     

    持久化存储

     

    在Kubernetes里的一切都是动态的和无状态的,这违背了传统存储方案的原则。因此,选择一个可行的持久化存储方案是你将面临的其中一个难题。市场上有许多流行的解决方案,如Ceph、Rook、StarageIO以及Portworx。

     

    其中,Portworx具有数据移动性、高可用性、独立性、持久卷的动态加密配置。在worker节点上,我们建议anotherdisk(vmdk)通过Portworx创建存储池。Portworx配备了名为stork的智能调度程序,可以通过仅在几个工作节点上安装Portworx来节省许可成本。

     

    你可以使用这个helm chart部署Portworx:

    https://github.com/portworx/helm/tree/master/charts/portworx
     

    容器安全

     

    容器安全在一直不断发展,由于pod的动态特性,让容器内发生的所有进程和通信具有可见性和可控制变得至关重要。Neuvector可以提供主机和pod的连续运行时保护,它可以通过扫描Kubernetes集群、节点、pod以及容器镜像来保护容器不受安全漏洞的影响。此外,还有一个附带的优势是能够为集群提供docker和kubernetes基准。它还能通过学习pod/service的良好行为来成为网络防火墙,并且基于此动态创建安全策略。当service在“保护模式”中时,它能够防止任何未经授权的进程或网络通信为该pod或服务运行。

     

    你可使用这个helm chart 部署 Neuvector:

    https://github.com/neuvector/neuvector-helm
     

    负载均衡

     

    一旦应用程序部署在K8S集群中后,有几个选项可以将它们暴露到集群外部。另一个需要考虑的因素是,如果你是将应用程序从传统基础架构迁移到容器中来,并且希望保留回滚的状态或想要在传统环境中保留现在已经迁移到K8S集群中的服务。

     

    AVI Networks可以提供软件定义的负载均衡器,它有一个控制平面和一个服务平面。这一负载均衡器提供负载均衡、流量管理、弹性伸缩以及端到端的自动化K8S服务。AVI在K8S云上将服务引擎部署为PODS,它可以处理南北流量(即客户端和服务器之间的流量),以及K8S服务的负载均衡。

     
    每次在K8S云中创建ingress时,AVI都配置了DNS服务器和IPAM池,可以自动创建虚拟服务。它将从IPAM分配一个IP,创建一个DNS入口并且配置后端的pod池。AVI同时能够通过ingress的注释添加各种HTTP策略以及网络安全策略的功能。
     

    CI/CD工具

     

    由于所有东西及其依赖项都被打包到容器中,因此Kubernetes可以使得持续部署成为现实,它还能从特定的工作节点中调度工作负载。而滚动更新策略可以零停机执行持续部署。

     

    Jenkins是一个十分出色的持续集成和镜像构建的工具,它提供与Gitlab、Nexus、JFrog artifactory、SonarQube、Neuvector、Fority、Helm和Rancher进行进行集成,以构成一个完整的CI/CD 流水线。

     

    Helm打包整个应用程序栈到chart中,包括应用程序所需的pod、服务、secert、ingress、持久化存储等。Helm还能在跨不同环境的情况下保持部署一致。(如下图)
     
    构建企业级Kubernetes平台,你需要的工具都在这里!

    图3 容器组件
     

    总而言之,现在有很多方法可以帮助构建Kubernetes平台,将应用程序部署在K8S集群中变得比以往任何时候都更容易。我希望这能让你更好地了解需要关注的领域以及知道哪些工具或平台能够让K8S集群在企业中成为现实。

    展开全文
    cenmeng8703 2019-09-18 06:37:33
  • 386B weixin_27031001 2021-06-21 09:08:15
  • 实战1:基于Jenkins+k8s+Git等技术链构建企业级DevOps自动化容器云平台 1、安装Jenkins 可用如下两种方法 1)通过docker直接下载jenkins镜像,基于镜像启动服务 2)在k8s中部署Jenkins服务 2、安装nfs服务 #选择...

    1.1 什么是DevOps?

    DevOps中的Dev是Devlopment(开发),Ops是Operation(运维),用一句话来说 DevOps 就是打通开发运维的壁垒,实现开发运维一体化。DevOps整个流程包括敏捷开发->持续集成->持续交付->持续部署。

    1.1.1 敏捷开发

    提高开发效率,及时跟进用户需求,缩短开发周期。

    敏捷开发包括编写代码和构建代码两个阶段,可以使用git或者svn来管理代码,用maven对代码进行构建

    1.1.2 持续集成(CI)

    持续集成强调开发人员提交了新代码之后,立刻自动的进行构建、(单元)测试。根据测试结果,我们可以确定新代码和原有代码能否正确地集成在一起。持续集成过程中很重视自动化测试验证结果,对可能出现的一些问题进行预警,以保障最终合并的代码没有问题。

    常见的持续集成工具:

    1. Jenkins

    Jenkins是用Java语言编写的,是目前使用最多和最受欢迎的持续集成工具,使用Jenkins,可以自动监测到git或者svn存储库代码的更新,基于最新的代码进行构建,把构建好的源码或者镜像发布到生产环境。Jenkins还有个非常好的功能:它可以在多台机器上进行分布式地构建和负载测试

    2. TeamCity

    3.  Travis CI

    4.   GoCD

    5.  Bamboo

    6.   GitLab CI

    7.  Codeship

    它的好处主要有以下几点:

    1)较早的发现错误:每次集成都通过自动化的构建(包括编译,发布,自动化测试)来验证,哪个环节出现问题都可以较早的发现。

    2)快速的发现错误:每完成一部分代码的更新,就会把代码集成到主干中,这样就可以快速的发现错误,比较容易的定位错误。

    3)提升团队绩效:持续集成中代码更新速度快,能及时发现小问题并进行修改,使团队能创造出更好的产品。

    4)防止分支过多的偏离主干:经常持续集成,会使分支代码经常向主干更新,当单元测试失败或者出现bug,如果开发者需要在没有调试的情况下恢复仓库的代码到没有bug的状态,只有很小部分的代码会丢失。

    持续集成的目的是提高代码质量,让产品快速的更新迭代。它的核心措施是,代码集成到主干之前,必须通过自动化测试。只要有一个测试用例失败,就不能集成。

    Martin Fowler说过,"持续集成并不能消除Bug,而是让它们非常容易发现和改正。"

    互动:Martin Fowler是谁?

    马丁·福勒

    马丁·福勒是一个软件开发方面的著作者和国际知名演说家,专注于面向对象分析与设计,统一建模语言,领域建模,以及敏捷软件开发方法,包括极限编程。

    与持续集成相关的还有持续交付和持续部署。

    1.1.3 持续交付

    持续交付在持续集成的基础上,将集成后的代码部署到更贴近真实运行环境的「类生产环境」(production-like environments)中。交付给质量团队或者用户,以供评审。如果评审通过,代码就进入生产阶段。如果所有的代码完成之后一起交付,会导致很多问题爆发出来,解决起来很麻烦,所以持续集成,也就是每更新一次代码,都向下交付一次,这样可以及时发现问题,及时解决,防止问题大量堆积。

    1.1.4 持续部署

    持续部署是指当交付的代码通过评审之后,自动部署到生产环境中。持续部署是持续交付的最高阶段。Puppet,SaltStack和Ansible是这个阶段使用的流行工具。容器化工具在部署阶段也发挥着重要作用。Docker和k8s是流行的工具,有助于在开发,测试和生产环境中实现一致性。除此之外,k8s还可以实现自动扩容缩容等功能。

     

    1.2  k8s在DevOps中可实现的功能

    1.2.1 自动化

    敏捷开发->持续集成->持续交付->持续部署。

    1.2.2 多集群管理

    可以根据客户需求对开发,测试,生产环境部署多套kubernetes集群,每个环境使用独立的物理资源,相互之间避免影响。

    1.2.3 多环境一致性

    Kubernetes是基于docker的容器编排工具,因为容器的镜像是不可变的,所以镜像把OS、业务代码、运行环境、程序库、目录结构都包含在内,镜像保存在我们的私有仓库,只要用户从我们提供的私有仓库拉取镜像,就能保证环境的一致性。

    1.2.4 实时反馈和智能化报表

    每次集成或交付,都会第一时间将结果通过多途径的方式反馈给你,也可以定制适合企业专用的报表平台。

    1.3  Jenkins+K8S+harbor+git+sonarqube+nexus构建DevOps容器云平台流程

    Jenkins是开源的CI&CD工具, 提供超过1000个插件来支持构建、部署、自动化, 满足任何项目的需要。完整的DevOps流程:

    开发提交代码到代码仓库gitlab-àjenkins检测到代码更新-à调用k8s api在k8s中创建jenkins slave pod:

    d拉取代码---à通过maven把拉取的代码进行构建成war包或者jar包--->上传代码到Sonarqube,进行静态代码扫描- -->基于war包构建docker image-->把镜像上传到harbor镜像仓库-->基于镜像部署应用到开发环境-->部署应用到测试环境--->部署应用到生产环境。

    实战1:基于Jenkins+k8s+Git等技术链构建企业级DevOps自动化容器云平台
    1、安装Jenkins
    可用如下两种方法
    1)通过docker直接下载jenkins镜像,基于镜像启动服务
    2)在k8s中部署Jenkins服务
    2、安装nfs服务
    #选择自己的任意一台机器,我选择k8s的控制节点master1
    1)、在master1上安装nfs,作为服务端
    [root@master1 ~]# yum install nfs-utils -y
    [root@master1 ~]# systemctl start nfs
    [root@master1 ~]# systemctl enable nfs
    2)、在node2和node1上安装nfs,作为客户端
    yum install nfs-utils -y
    systemctl start nfs
    systemctl enable nfs
    3)、在master1上创建一个nfs共享目录
    [root@master1 ~]# mkdir /data/v1  -p
    [root@master1 ~]# cat /etc/exports
    /data/v1       192.168.40.0/24(rw,no_root_squash)
    #使配置文件生效
    [root@master1 ~]# exportfs -arv  
    [root@master1 ~]# systemctl restart nfs 
    3、在kubernetes中部署jenkins
    (1)创建名称空间
    [root@master1 ~]# kubectl create namespace jenkins-k8s
    (2)创建pv
    [root@master1 ~]# cat pv.yaml 
    #跟新资源清单文件
    [root@master1 ~]# kubectl apply -f pv.yaml
    (3)创建pvc
    [root@master1 ~]# cat pvc.yaml 
    #更新资源清单文件
    [root@master1 ~]# kubectl apply -f pvc.yaml
    #查看pvc和pv绑定是否成功
    [root@master1 ~]# kubectl get pvc -n jenkins-k8s
    NAME      STATUS   VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS 
    jenkins-k8s-pvc   Bound    jenkins-k8s-pv   10Gi       RWX                           
    (4)创建一个sa账号
    [root@master1 ~]# kubectl create sa jenkins-k8s-sa -n jenkins-k8s
    (5)把上面的sa账号做rbac授权
    [root@master1 ~]# kubectl create clusterrolebinding jenkins-k8s-sa-cluster -n jenkins-k8s  --clusterrole=cluster-admin --serviceaccount=jenkins-k8s:jenkins-k8s-sa
    (6)通过deployment部署jenkins
    注:下面实验用到的镜像是jenkins.tar.gz和jenkins-jnlp.tar.gz,把这两个压缩包上传到k8s的node1和node2节点,用如下方法手动解压:
    docker load -i jenkins.tar.gz
    docker load -i jenkins-jnlp.tar.gz
    [root@master1 ~]# cat jenkins-deployment.yaml 
    #更新资源清单文件
    kubectl apply -f jenkins-deployment.yaml
    [root@master1 ~]# kubectl get pods -n jenkins-k8s
    NAME                       READY   STATUS             RESTARTS   AGE
    jenkins-74b4c59549-qvmrt   0/1     CrashLoopBackOff   1          15s
    #上面可以看到CrashLoopBackOff,解决方法如下:
    #查看jenkins-74b4c59549-qvmrt日志
    [root@master1 ~]# kubectl logs jenkins-74b4c59549-qvmrt -n jenkins-k8s
    touch: cannot touch '/var/jenkins_home/copy_reference_file.log': Permission denied
    #上面问题是因为/data/v1目录权限问题,按如下方法解决:
    [root@master1 ~]# chown -R 1000.1000 /data/v1/
    [root@master1 ~]# kubectl delete -f jenkins-deployment.yaml
    [root@master1 ~]# kubectl apply -f jenkins-deployment.yaml
    [root@master1 ~]# kubectl get pods -n jenkins-k8s
    NAME                       READY   STATUS    RESTARTS   AGE
    jenkins-74b4c59549-gp95l   1/1     Running   0          16s
    (7)把jenkins前端加上service,提供外部网络访问
    [root@master1 ~]# cat jenkins-service.yaml 
    #更新资源清单文件
    [root@master1 ~]# kubectl apply -f jenkins-service.yaml
    [root@master1 ~]# kubectl get svc -n jenkins-k8s
    NAME              TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)                          
    jenkins-service   NodePort   10.110.34.67   <none>        8080:30002/TCP,50000:32331/TCP   
    4、配置Jenkins
    在浏览器访问jenkins的web界面:
    http://192.168.40.130:30002/login?from=%2F
    

    1)获取管理员密码
    在nfs服务端,也就是我们的master1节点获取密码:
    [root@master1 ~]# cat  /data/v1/jenkins-home/secrets/initialAdminPassword
    f9b0b4400c4a4d6eaec6762616db6d63
    把获取到的密码拷贝到上面管理员密码下的方框里
    点击继续,出现如下界面
    

    2)安装插件

    安装推荐的插件

    插件安装好之后显示如下

    3)创建第一个管理员用户

    用户名和密码都设置成admin,线上环境需要设置成复杂的密码

    修改好之后点击保存并完成,出现如下界面

    点击保存并完成,出现如下界面

    点击保存并完成,出现如下界面

    点击开始使用Jenkins

     

    5、测试jenkins的CI/CD

    #在Jenkins中安装kubernetes插件

    (1)在jenkins中安装k8s插件

    ManageJnekins------>插件管理------>可选插件------>搜索kubernetes------>出现如下

    选中kubernetes之后------>点击下面的直接安装------>安装之后选择重新启动jenkins---> http://192.168.40.130:30002/restart-->重启之后登陆jenkins即可

     

    #配置jenkins连接到我们存在的k8s集群

    (1)访问http://192.168.40.130:30002/configureClouds/

    新增一个云,在下拉菜单中选择kubernets并添加

    (2)填写云kubernetes配置内容

    kubernetes

    https://192.168.40.130:6443

    (3)测试jenkins和k8s是否可以通信

    点击连接测试,如果显示Connection test successful或者显示Connected to Kubernetes 1.20

    说明测试成功,Jenkins可以和k8s进行通信

    配置k8s集群的时候jenkins地址需要写上面域名的形式,配置之后执行如下:

    http://jenkins-service.jenkins-k8s.svc.cluster.local:8080

    应用------>保存

    (1)配置pod template

    访问http://192.168.40.130:30002/configureClouds/

    添加Pod模板------>KubernetesPod Template--->按如下配置

    (2)在上面的podtemplate下添加容器

    添加容器------>Container Template------>按如下配置------>

    Docker镜像:使用jenkins-jnlp.tar.gz解压出来的镜像,把这个镜像上传到k8s的各node节点,手动解压:docker load -ijenkins-jnlp.tar.gz

    解压出来的镜像是xianchao/jenkins-jnlp:v1

    在每一个pod template右下脚都有一个Advanced,点击Advanced,出现如下

    在ServiceAccount处输入jenkins-k8s-sa,这个sa就是我们最开始安装jenkins时的sa

    (3)给上面的podtemplate添加卷

    添加卷------>选择Host Path  Volume

    /var/run/docker.sock

    /var/run/docker.sock

     

    /root/.kube

    /home/jenkins/.kube

    上面配置好之后,应用------>保存

     

    #添加dockerhub凭据

    注意:下面需要用到dockerhub存放镜像,大家如果没有dockerhub可以自己申请一个

     

    首页------>系统管理----à管理凭据--à全局--à添加凭据

    username:xianchao
    password:1989*****
    ID:dockerhub
    描述:这个地方随便写
    上面修改好之后选择确定即可
    
    
    #测试通过Jenkins发布代码到k8s开发环境、测试环境、生产环境
    在k8s的控制节点创建名称空间:
    [root@master1 ~]# kubectl create ns devlopment
    namespace/devlopment created
    [root@master1 ~]# kubectl create ns production
    namespace/production created
    [root@master1 ~]# kubectl create ns qatest
    namespace/qatest created
    
    
    回到首页:
    新建一个任务------>输入一个任务名称处输入jenkins-variable-test-deploy------>流水线------>确定------>在Pipeline script处输入如下内容
    node('testhan') {
        stage('Clone') {
            echo "1.Clone Stage"
            git url: "https://github.com/luckylucky421/jenkins-sample.git"
            script {
                build_tag = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
            }
        }
        stage('Test') {
          echo "2.Test Stage"
    
    
        }
        stage('Build') {
            echo "3.Build Docker Image Stage"
            sh "docker build -t xianchao/jenkins-demo:${build_tag} ."
        }
        stage('Push') {
            echo "4.Push Docker Image Stage"
            withCredentials([usernamePassword(credentialsId: 'dockerhub', passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {
                sh "docker login -u ${dockerHubUser} -p ${dockerHubPassword}"
                sh "docker push xianchao/jenkins-demo:${build_tag}"
            }
        }
        stage('Deploy to dev') {
            echo "5. Deploy DEV"
        sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-dev.yaml"
            sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-dev.yaml"
    //        sh "bash running-devlopment.sh"
            sh "kubectl apply -f k8s-dev.yaml  --validate=false"
      }  
      stage('Promote to qa') {  
        def userInput = input(
                id: 'userInput',
    
    
                message: 'Promote to qa?',
                parameters: [
                    [
                        $class: 'ChoiceParameterDefinition',
                        choices: "YES\nNO",
                        name: 'Env'
                    ]
                ]
            )
            echo "This is a deploy step to ${userInput}"
            if (userInput == "YES") {
                sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-qa.yaml"
                sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-qa.yaml"
    //            sh "bash running-qa.sh"
                sh "kubectl apply -f k8s-qa.yaml --validate=false"
                sh "sleep 6"
                sh "kubectl get pods -n qatest"
            } else {
                //exit
            }
        }
      stage('Promote to pro') {  
        def userInput = input(
    
    
                id: 'userInput',
                message: 'Promote to pro?',
                parameters: [
                    [
                        $class: 'ChoiceParameterDefinition',
                        choices: "YES\nNO",
                        name: 'Env'
                    ]
                ]
            )
            echo "This is a deploy step to ${userInput}"
            if (userInput == "YES") {
                sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-prod.yaml"
                sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-prod.yaml"
    //            sh "bash running-production.sh"
                sh "cat k8s-prod.yaml"
                sh "kubectl apply -f k8s-prod.yaml --record --validate=false"
            }
        }
    }
    
    
    应用------>保存------>立即构建
    在左侧可以看到构建任务,如下所示:
    
    
    

    点击Input request,部署应用到预生产环境

    点击Input request,部署应用到生产环境

    看到Finished:SUCCESS,,说明pipeline构建任务完成
    
    
    6、验证开发、预生产、生产环境部署的应用是否正常运行
    [root@master1 ~]# kubectl get pods -n devlopment
    NAME                            READY   STATUS    RESTARTS   AGE
    jenkins-demo-784885d9c9-b4jkg   1/1     Running   0          6m18s
    [root@master1 ~]# kubectl get pods -n qatest
    NAME                            READY   STATUS    RESTARTS   AGE
    jenkins-demo-784885d9c9-59tsm   1/1     Running   0          5m19s
    [root@master1 ~]# kubectl get pods -n production
    NAME                              READY   STATUS              RESTARTS   AGE
    jenkins-demo-784885d9c9-42hz4   1/1       running             0          5m38s
    
    实战2:Jenkins管理插件BlueOcean配置和使用
    # BlueOcean是什么?
    为了适应Jenkins Pipeline和 Freestyle jobs任务,Jenkins推出了BlueOcean UI,其目的就是让程序员执行任务时,降低工作流程的复杂度和提升工作流程的清晰度,它具有如下特征:
    1、清晰的可视化:对CI/CD pipelines, 可以快速直观的观察项目pipeline状态。
    2、pipeline可编辑:引导用户通过直观的、可视化的过程来创建Pipeline,从而使Pipeline的创建变得平易近人。
    3、pipeline精确度:通过UI直接介入pipeline的中间问题。
    #安装BlueOcean插件
    主页—>系统管理插件管理可选插件—>过滤BlueOcean直接安装
    

    安装完成后,重启jenkins
    http://192.168.40.130:30002/restart
    
    
    

    重启进入jenkins之后,在主页左侧可以看到打开Blue Ocean

    实战3:Jenkins实现k8s应用按照指定版本回滚
    回到首页:
    新建一个任务------>输入一个任务名称处输入jenkins-variable-test-deploy-rollout------>流水线------>确定------>在Pipeline script处输入如下内容
    
    
    
    
    node('testhan') {
      stage('git clone') {
        git url: "https://github.com/luckylucky421/jenkins-rollout"
        sh "ls -al"
        sh "pwd"
    }
      stage('select env') {
        def envInput = input(
          id: 'envInput',
          message: 'Choose a deploy environment',
          parameters: [
             [
                 $class: 'ChoiceParameterDefinition',
                 choices: "devlopment\nqatest\nproduction",
                 name: 'Env'
             ]
         ]
    )
    echo "This is a deploy step to ${envInput}"
    sh "sed -i 's/<namespace>/${envInput}/' getVersion.sh"
    sh "sed -i 's/<namespace>/${envInput}/' rollout.sh"
    sh "bash getVersion.sh"
    // env.WORKSPACE = pwd()
    // def version = readFile "${env.WORKSPACE}/version.csv"
    // println version
    }
      stage('select version') {
         env.WORKSPACE = pwd()
      def version = readFile "${env.WORKSPACE}/version.csv"
      println version
          def userInput = input(id: 'userInput',
                                            message: '选择回滚版本',
                                            parameters: [
                [
                     $class: 'ChoiceParameterDefinition',
                     choices: "$version\n",
                     name: 'Version'
           ]
          ]
    )
           sh "sed -i 's/<version>/${userInput}/' rollout.sh"
    }
      stage('rollout deploy') {
          sh "bash rollout.sh"
    }
    }
    
    
    

    点击应用->保存-立即构建

    END

    精彩文章推荐

    从0开始轻松玩转k8s,助力企业实现智能化转型+世界500强实战项目汇总

    Nginx如何限流?

    使用 root 用户执行Docker、K8s命令?No!

    GitLab 持续集成

    使用k3s部署轻量Kubernetes集群快速教程

    K8S 常见面试题总结

    K8s 超详细总结!

    两大容器管理平台,Kubernetes与OpenShift有什么区别?

    从0开始轻松玩转k8s,助力企业实现智能化转型+世界500强实战项目汇总

    容器运行时Containerd基础

     Docker+k8s+DevOps+CKA+k8s故障排查训练营

    技术交流

    为了大家更快速的学习知识,掌握技术,随时沟通交流问题,特组建了技术交流群,大家在群里可以分享自己的技术栈,抛出日常问题,群里会有很多大佬及时解答的,这样我们就会结识很多志同道合的人,长按或者扫描下图二维码可加我微信,备注运维或者k8s或者devops即可进群,让我们共同的努力,向着美好的未来出发吧~~,想要免费获取linux、k8s、DevOps、Openstack、Openshift、运维、开发、测试、架构师、Python、Go、面试文档、容器、岗位内推等资料也可进群获取哈~~    

    微信: luckylucky421302

     点击阅读 | 即刻学习

    微信公众号


                        

                        点亮,服务器10年不宕机

    点击阅读原文即可了解更多信息

           

          

    展开全文
    weixin_38320674 2021-08-03 00:49:35
  • 225.36MB weixin_26997697 2021-06-16 07:55:58
  • 环境配置 角色 IP 备注 推荐配置 K8S 10.40.6.201 10.40.6.210 10.40.6.213 自行准备 CPU:2C+ 内存:4G+ Harbor 10.40.6.165 Git 10.40.6.165 Jenkins 部署在K8S平台 二. 准备工作 1. 对项目的理解 • 单体架构、...

    一. 持续集成/部署/交付概述

    持续集成(Continuous Integration,CI): 代码合并、构建、部署、测试都在一起,不断地执行这个过程,并对结果反馈。
    持续部署(Continuous Deployment,CD): 部署到测试环境、预生产环境、生产环境。
    持续交付(Continuous Delivery,CD): 将最终产品发布到生产环境,给用户使用。

    img

    img

    img

    环境配置

    角色IP备注推荐配置
    K8S10.40.6.201 10.40.6.210 10.40.6.213自行准备CPU:2C+ 内存:4G+
    Harbor10.40.6.165
    Git10.40.6.165
    Jenkins部署在K8S平台

    二. 准备工作

    1. 对项目的理解

    • 单体架构、微服务
    • 怎么部署
    • 启动是否有依赖

    2. 部署到k8s平台流程

    (1). 制作镜像
    (2). 容器放到Pod
    (3). 控制器管理Pod
    (4). 暴露应用
    (5). 对外发布应用
    (6). 日志管理/监控

    3. 不同环境区分配置文件

    • configmap
    • entrypoint.sh
    • 统一配置中心,例如 Apollo,Nacos

    4. Harbor镜像仓库

    Harbor 部署参考: https://blog.csdn.net/agonie201218/article/details/115691894

    kubernetes从harbor拉取镜像没有权限解决方法 unauthorized https://andyoung.blog.csdn.net/article/details/120313644

    5. GitLab代码版本仓库

    GitLab 详细安装及使用教程: https://blog.csdn.net/agonie201218/article/details/120859712

    三. Kubernetes中部署Jenkins

    参考 github jenkinsci/kubernetes-plugin 插件 :https://github.com/jenkinsci/kubernetes-plugin/tree/master/src/main/kubernetes

    image-20211209155806474

    img

    NFS服务部署 PV、 PVC 参考:https://andyoung.blog.csdn.net/article/details/120147604

    https://andyoung.blog.csdn.net/article/details/120843117

    1. 部署有状态的jenkins Pod

    # jenkins
    
    ---
    apiVersion: apps/v1
    kind: StatefulSet
    metadata:
      name: jenkins
      labels:
        name: jenkins
    spec:
      selector:
        matchLabels:
          name: jenkins
      serviceName: jenkins
      replicas: 1
      updateStrategy:
        type: RollingUpdate
      template:
        metadata:
          name: jenkins
          labels:
            name: jenkins
        spec:
          terminationGracePeriodSeconds: 10
          serviceAccountName: jenkins
          containers:
            - name: jenkins
              image: jenkins/jenkins:lts-alpine
              imagePullPolicy: Always
              ports:
                - containerPort: 8080
                - containerPort: 50000
              resources:
                limits:
                  cpu: 1
                  memory: 1Gi
                requests:
                  cpu: 0.5
                  memory: 500Mi
              env:
                - name: LIMITS_MEMORY
                  valueFrom:
                    resourceFieldRef:
                      resource: limits.memory
                      divisor: 1Mi
                - name: JAVA_OPTS
                  # value: -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap -XX:MaxRAMFraction=1 -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay=0 -Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson.slaves.NodeProvisioner.MARGIN0=0.85
                  value: -Xmx$(LIMITS_MEMORY)m -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay=0 -Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson.slaves.NodeProvisioner.MARGIN0=0.85
              volumeMounts:
                - name: jenkins-home
                  mountPath: /var/jenkins_home
              livenessProbe:
                httpGet:
                  path: /login
                  port: 8080
                initialDelaySeconds: 60
                timeoutSeconds: 5
                failureThreshold: 12 # ~2 minutes
              readinessProbe:
                httpGet:
                  path: /login
                  port: 8080
                initialDelaySeconds: 60
                timeoutSeconds: 5
                failureThreshold: 12 # ~2 minutes
          securityContext:
            fsGroup: 1000
      volumeClaimTemplates:
      - metadata:
          name: jenkins-home
          # annotations:
          #   volume.beta.kubernetes.io/storage-class: anything
        spec:
          accessModes: [ "ReadWriteOnce" ]
          resources:
            requests:
              storage: 1Gi
    
    ---
    ## 创建jenkins service
    apiVersion: v1
    kind: Service
    metadata:
      name: jenkins
    spec:
      # type: LoadBalancer
      selector:
        name: jenkins
      # ensure the client ip is propagated to avoid the invalid crumb issue when using LoadBalancer (k8s >=1.7)
      #externalTrafficPolicy: Local
      ports:
        -
          name: http
          port: 80
          targetPort: 8080
          protocol: TCP
        -
          name: agent
          port: 50000
          protocol: TCP
    
    ---
    ## 创建jenkins ingress
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      name: jenkins
      annotations:
        nginx.ingress.kubernetes.io/ssl-redirect: "true"
        kubernetes.io/tls-acme: "true"
        # "413 Request Entity Too Large" uploading plugins, increase client_max_body_size
        nginx.ingress.kubernetes.io/proxy-body-size: 50m
        nginx.ingress.kubernetes.io/proxy-request-buffering: "off"
        # For nginx-ingress controller < 0.9.0.beta-18
        ingress.kubernetes.io/ssl-redirect: "true"
        # "413 Request Entity Too Large" uploading plugins, increase client_max_body_size
        ingress.kubernetes.io/proxy-body-size: 50m
        ingress.kubernetes.io/proxy-request-buffering: "off"
    spec:
      ingressClassName: nginx
      rules:
      - http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: jenkins
                port:
                  number: 80
        host: jenkins.example.com
      tls:
      - hosts:
        - jenkins.example.com
        secretName: tls-jenkins
    
      securityContext:
        fsGroup: 1000  这个配置可以去掉,但得先给后端存储切换组,如果用这个配置,后面jenkins 使用久了,jenkins 重启后会需要很久参能启动成功,这样就会影响健康检测失败,pod一直启动失败
    

    2. jenkins认证授权

    # In GKE need to get RBAC permissions first with
    # kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin [--user=<user-name>|--group=<group-name>]
    
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: jenkins
    
    ---
    kind: Role
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: jenkins
    rules:
    - apiGroups: [""]
      resources: ["pods"]
      verbs: ["create","delete","get","list","patch","update","watch"]
    - apiGroups: [""]
      resources: ["pods/exec"]
      verbs: ["create","delete","get","list","patch","update","watch"]
    - apiGroups: [""]
      resources: ["pods/log"]
      verbs: ["get","list","watch"]
    - apiGroups: [""]
      resources: ["events"]
      verbs: ["watch"]
    - apiGroups: [""]
      resources: ["secrets"]
      verbs: ["get"]
    
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: RoleBinding
    metadata:
      name: jenkins
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: Role
      name: jenkins
    subjects:
    - kind: ServiceAccount
      name: jenkins
    

    3. 获取jenkins密码并登录

    # kubectl create -f .
    登录容器获取jenkins登录密码:
    # kubectl exec -it jenkins-0 bash
    bash-4.4$ cat /var/jenkins_home/secrets/initialAdminPassword
    0f8c730f4b7a426098283cf94aa57231
    

    jenkins地址:http://jenkins.example.com:30080

    4. jenkins 安装插件

    1. pipeline

    2. git

    3. kubernetes

      image-20211209161913952

    4. Role-based Authorization Strategy(推荐)

      我们可以利用Role-based Authorization Strategy 插件来管理Jenkins用户权限

      https://blog.csdn.net/agonie201218/article/details/120168454

    image-20211209161953626

    1. Chinese (中文汉化插件)

    2. Extended Choice Parameter(参数化构建过程 多选框)

      image-20211209163120882

      6.1 多选框:项目名称。设置4个参数,用 , 隔开

    image-20211209164101884

    6.2 设置多选框值值

    image-20211209164823212

    6.3 最终效果

    image-20211209164916475

    展开全文
    agonie201218 2021-12-10 10:36:14
  • 410.98MB baidu_34422713 2021-06-19 23:17:13
  • qinjiamao1 2020-07-17 07:34:16
  • 279KB weixin_27006759 2021-06-20 23:20:59
  • qq_40942490 2021-03-24 11:11:48
  • weixin_39246554 2021-10-21 15:56:11
  • 867KB qq_35008624 2021-10-24 13:44:23
  • aeaiesb 2020-12-09 11:15:36
  • chengyinwu 2020-09-05 20:45:10
  • weixin_38320674 2021-01-05 09:28:25
  • 5星
    911B weixin_44250399 2021-09-29 17:30:07
  • 17.9MB weixin_38660108 2020-09-28 02:18:49

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,563
精华内容 5,025
关键字:

企业级k8s平台