k8s 监控 jvm k8s集群监控

54-k8s-集群监控-高可以用集群-交付部署

k8s集群监控

1、概述

一个好的系统，主要监控以下内容

• 集群监控

• 节点资源利用率
• 节点数
• 运行Pods

• Pod监控

• 容器指标
• 应用程序【程序占用多少CPU、内存】

2、监控平台

使用普罗米修斯【prometheus】 + Grafana 搭建监控平台

• prometheus【定时搜索被监控服务的状态】

• 开源的
• 监控、报警、数据库
• 以HTTP协议周期性抓取被监控组件状态
• 不需要复杂的集成过程，使用http接口接入即可

• Grafana

• 开源的数据分析和可视化工具
• 支持多种数据源

1、部署prometheus

首先需部署一个守护进程node-exporter.yaml

---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: kube-system
  labels:
    k8s-app: node-exporter
spec:
  selector:
    matchLabels:
      k8s-app: node-exporter
  template:
    metadata:
      labels:
        k8s-app: node-exporter
    spec:
      containers:
      - image: prom/node-exporter
        name: node-exporter
        ports:
        - containerPort: 9100
          protocol: TCP
          name: http
---
apiVersion: v1
kind: Service
metadata:
  labels:
    k8s-app: node-exporter
  name: node-exporter
  namespace: kube-system
spec:
  ports:
  - name: http
    port: 9100
    nodePort: 31672
    protocol: TCP
  type: NodePort
  selector:
    k8s-app: node-exporter

然后执行下面命令

kubectl create -f node-exporter.yaml

然后通过yaml的方式部署prometheus

• configmap：定义一个configmap：存储一些配置文件【不加密】
• prometheus.deploy.yaml：部署一个deployment【包括端口号，资源限制】
• prometheus.svc.yaml：对外暴露的端口
• rbac-setup.yaml：分配一些角色的权限

下面进入目录下，首先部署 rbac-setup.yaml

kubectl create -f rbac-setup.yaml

然后分别部署

# 部署configmap
kubectl create -f configmap.yaml
# 部署deployment
kubectl create -f prometheus.deploy.yml
# 部署svc
kubectl create -f prometheus.svc.yml

部署完成后，我们使用下面命令查看

kubectl get pods -n kube-system

在我们部署完成后，即可看到 prometheus 的 pod了，然后通过下面命令，能够看到对应的端口

kubectl get svc -n kube-system

通过这个，我们可以看到 prometheus 对外暴露的端口为 30003，访问页面即可对应的图形化界面

http://节点ip:30003

2、部署grafana

部署完prometheus后，还需要来部署grafana

kubectl create -f grafana-deploy.yaml
# 创建deployment
kubectl create -f grafana-deploy.yaml
# 创建svc
kubectl create -f grafana-svc.yaml
# 创建 ing
kubectl create -f grafana-ing.yaml

kubectl get pods -n kube-system

3、配置数据源

下面我们需要开始打开 Grafana，然后配置数据源，导入数据显示模板

kubectl get svc -n kube-system

我们可以通过 ip + 30821访问我们的 grafana 图形化页面

默认账号和密码：admin admin

进入后，需要配置 prometheus 的数据源 和 对应的IP【这里IP是我们的ClusterIP】

4、设置显示数据的模板

选择Dashboard，导入我们的模板

然后输入 315 号模板

然后选择 prometheus数据源 mydb，导入即可

导入后的效果如下所示

K8S高可用集群搭建

之前搭建的集群，只有一个master节点，当master节点宕机的时候，通过node将无法继续访问，而master主要是管理作用，所以整个集群将无法提供服务

单节点

高可用集群

搭建一个多master节点的高可用集群，不会存在单点故障问题，但是在node 和 master节点之间，需要存在一个 LoadBalancer组件，作用一是负载，二是检查master节点的状态

对外有一个统一的VIP：虚拟ip来对外进行访问

1、keepalived：配置虚拟ip，检查节点的状态

2、haproxy：负载均衡服务【类似于nginx】

3、apiserver，controller，manager，scheduler：

• 在 node 节点和 master 节点之间，需要一个 LoadBalancer 组件

• 【作用 1】负载
• 【作用 2】检查 master 节点的状态

• 对外需要一个统一的 VIP

• 【作用 1】虚拟 ip 对外进行访问

高可用集群步骤

使用二进制包方式搭建 Kubernetes 集群主要分为以下几步：

1. 【环境准备】准备四台虚拟机，并安装操作系统 CentOS 7.x
2. 【系统初始化】对四个刚安装好的操作系统进行初始化操作
3. 【安装 docker、kubectl、kubeadm、kubectl】对四个节点进行安装
4. 【配置高可用 VIP】对 master 节点安装keepalived和haproxy
5. 【部署 master 组件】在 master 节点上安装kube-apiserver、kube-controller-manager、kube-scheduler
6. 【安装网络插件】配置 CNI 网络插件，用于节点之间的连通
7. 【测试集群】通过拉取一个 nginx 进行测试，能否进行外网测试

来源尚硅谷：架构采用2个master节点，一个node节点来搭建高可用集群记性测试

角色	IP	步骤
k8sLoadBalancer	192.168.10.101	initdockerkubectlkubeadmkubectl
k8smaster1	192.168.10.105	initdockerkubectlkubeadmkubectlkeepalivedhaproxy
k8smaster2	192.168.10.106	initdockerkubectlkubeadmkubectlkeepalivedhaproxy
k8snode1	192.168.10.107	initdockerkubectlkubeadmkubectl

1、初始化操作

分别在三个节点上进行操作

# 关闭防火墙
systemctl stop firewalld
# 禁用 firewalld 服务
systemctl disable firewalld

# 关闭 selinux
# 临时关闭【立即生效】告警，不启用，Permissive，查看使用 getenforce 命令
setenforce 0  
# 永久关闭【重启生效】
sed -i 's/SELINUX=enforcing/\SELINUX=disabled/' /etc/selinux/config  

# 关闭 swap
# 临时关闭【立即生效】查看使用 free 命令
swapoff -a 
# 永久关闭【重启生效】
sed -ri 's/.*swap.*/#&/' /etc/fstab

# 在主机名静态查询表中添加 4 台主机
cat >> /etc/hosts << EOF
192.168.10.101 k8sLoadBalancer
192.168.10.105 k8smaster1
192.168.10.106 k8smaster2
192.168.10.107 k8snode1
EOF

# 将桥接的 IPv4 流量传递到 iptables 的链【3 个节点上都执行】
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

# 根据规划设置主机名【k8sLoadBalancer 节点上操作】
hostnamectl set-hostname k8sLoadBalancer
# 根据规划设置主机名【k8smaster1 节点上操作】
hostnamectl set-hostname ks8master1
# 根据规划设置主机名【k8smaster2 节点上操作】
hostnamectl set-hostname k8smaster2
# 根据规划设置主机名【k8snode1 节点操作】
hostnamectl set-hostname k8snode1

2、安装 docker、kubelet、kubeadm、kubectl

参考：http://bbigsun.gitee.io/kubernetes-study

所有节点安装 docker/kubelet/kubeadm/kubectl，Kubernetes 默认 CRI（容器运行时）为 docker，因此先安装 docker

1、安装 docker

（1）首先配置一下 docker 的阿里 yum 源

cat >/etc/yum.repos.d/docker.repo<<EOF
[docker-ce-edge]
name=Docker CE Edge - \$basearch
baseurl=https://mirrors.aliyun.com/docker-ce/linux/centos/7/\$basearch/edge
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com/docker-ce/linux/centos/gpg
EOF

（2）然后 yum 方式安装 docker

# yum 安装
yum -y install docker-ce

# 查看 docker 版本
docker --version

（3）配置 docker 的镜像源【阿里云】

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

（4）然后启动 docker

systemctl start docker
systemctl enable docker
systemctl status docker

2、安装 kubeadm，kubelet 和 kubectl

（1）配置 kubernetes 阿里云 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

（2）yum 方式安装，由于版本更新频繁，这里指定版本号部署

# 查看版本
yum list kubeadm --showduplicates

# 安装 kubelet、kubeadm、kubectl，同时指定版本
yum install -y kubelet-1.18.0 kubeadm-1.18.0 kubectl-1.18.0
# 设置开机启动【这里先不启动】
systemctl enable kubelet

3、配置高可用 VIP【haproxy+keepalived】

【k8smaster1 + k8smaster2 上操作】

1、安装 haproxy + keepalived

我们需要在所有的 master 节点【k8smaster1 和 k8smaster2】上部署 haproxy + keepAlive

yum install -y haproxy keepalived

2、配置 haproxy

所有master节点的haproxy配置相同，haproxy 的配置文件是/etc/haproxy/haproxy.cfg

配置中声明了后端代理的两个 master 节点服务器，指定了 haproxy 运行的端口为 16443 等，因此 16443 端口为集群的入口

cat > /etc/haproxy/haproxy.cfg << EOF
#---------------------------------------------------------------------
# Global settings
#---------------------------------------------------------------------
global
    # to have these messages end up in /var/log/haproxy.log you will
    # need to:
    # 1) configure syslog to accept network log events.  This is done
    #    by adding the '-r' option to the SYSLOGD_OPTIONS in
    #    /etc/sysconfig/syslog
    # 2) configure local2 events to go to the /var/log/haproxy.log
    #   file. A line like the following can be added to
    #   /etc/sysconfig/syslog
    #
    #    local2.*                       /var/log/haproxy.log
    #
    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
#---------------------------------------------------------------------
# common defaults that all the 'listen' and 'backend' sections will
# use if not designated in their block
#---------------------------------------------------------------------  
defaults
    mode                    http
    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
#---------------------------------------------------------------------
# kubernetes apiserver frontend which proxys to the backends
#--------------------------------------------------------------------- 
frontend kubernetes-apiserver
    mode                 tcp
    bind                 *:16443
    option               tcplog
    default_backend      kubernetes-apiserver    
#---------------------------------------------------------------------
# round robin balancing between the various backends
#---------------------------------------------------------------------
backend kubernetes-apiserver
    mode        tcp
    balance     roundrobin
    server      k8smaster1   192.168.10.105:6443 check
    server      k8smaster2   192.168.10.106:6443 check
#---------------------------------------------------------------------
# collection haproxy statistics message
#---------------------------------------------------------------------
listen stats
    bind                 *:10080
    stats auth           admin:awesomePassword
    stats refresh        5s
    stats realm          HAProxy\ Statistics
    stats uri            /admin?stats
EOF

3、配置 keepalived

keepalived中使用track_script机制来配置脚本进行探测kubernetes的master节点是否宕机，并以此切换节点实现高可用。

（1）k8smaster1节点的keepalived配置文件如下所示，配置文件所在的位置/etc/keepalived/keepalived.cfg。

cat > /etc/keepalived/keepalived.conf <<EOF 
! Configuration File for keepalived

global_defs {
   router_id k8s
}

vrrp_script check_haproxy {
    script "killall -0 haproxy"
    interval 3
    weight -2
    fall 10
    rise 2
}

vrrp_instance VI_1 {
    state MASTER 
    interface ens33 
    mcast_src_ip 192.168.10.105
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass ceb1b3ec013d66163d6ab
    }
    virtual_ipaddress {
        192.168.10.101
    }
    track_script {
        check_haproxy
    }
}
EOF

需要注意几点（前两点记得修改）：

• mcast_src_ip：配置多播源地址，此地址是当前主机的 ip 地址。
• priority：keepalived根据此项参数的大小仲裁master节点。我们这里让 master 节点为kubernetes提供服务，其他两个节点暂时为备用节点。因此k8smaster1节点设置为100，k8smaster2节点设置为99。
• state：我们将k8smaster1节点的state字段设置为MASTER，其他节点字段修改为BACKUP。
• 上面的集群检查功能是关闭的，等到集群建立完成后再开启。

（2）配置 k8smaster2 节点

cat > /etc/keepalived/keepalived.conf <<EOF 
! Configuration File for keepalived

global_defs {
   router_id k8s
}

vrrp_script check_haproxy {
    script "killall -0 haproxy"
    interval 3
    weight -2
    fall 10
    rise 2
}

vrrp_instance VI_1 {
    state BACKUP 
    interface ens33 
    mcast_src_ip 192.168.10.106
    virtual_router_id 51
    priority 99
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass ceb1b3ec013d66163d6ab
    }
    virtual_ipaddress {
        192.168.10.101
    }
    track_script {
        check_haproxy
    }
}
EOF

4、启动和检查 【k8smaster1 和 k8smaster2 均要启动】

# 启动 haproxy
systemctl start haproxy
systemctl enable haproxy
systemctl status haproxy

# 启动 keepalived
systemctl start keepalived.service
systemctl enable keepalived.service
systemctl status keepalived.service

# 启动后查看 master 网卡信息
ip a s ens33

# 检查是否可以 ping 通
ping 192.168.10.101

# 如果出错
#      初始化一下！！！并重新启动！！！
systemctl stop firewalld
setenforce 0  
swapoff -a

4、部署 Kubernetes Master 组件

【k8smaster1 + k8smaster2 + k8snode1 上操作】

1、k8smaster1 节点

（1）初始化操作

# 导出初始化配置文件，然后修改配置，再进行初始化
kubeadm config print init-defaults > kubeadm-init.yaml

# 这里直接写入配置，并初始化
cat > kubeadm-init.yaml << EOF
apiVersion: kubeadm.k8s.io/v1beta2
bootstrapTokens:
- groups:
  - system:bootstrappers:kubeadm:default-node-token
  token: abcdef.0123456789abcdef
  ttl: 24h0m0s
  usages:
  - signing
  - authentication
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: 192.168.10.101 # k8sLoadBalancer ip
  bindPort: 6443
nodeRegistration:
  criSocket: /var/run/dockershim.sock
  name: k8sloadbalancer
  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
---
apiServer: # 添加两行配置
  certSANs:
  - "192.168.10.101" # k8sLoadBalancer ip 即 VIP 的地址
  timeoutForControlPlane: 4m0s
apiVersion: kubeadm.k8s.io/v1beta2
certificatesDir: /etc/kubernetes/pki
clusterName: kubernetes
controllerManager: {}
dns:
  type: CoreDNS
etcd:
  local:
    dataDir: /var/lib/etcd
imageRepository: registry.cn-hangzhou.aliyuncs.com/google_containers   # 阿里云的镜像站点
controlPlaneEndpoint: "192.168.10.101:16443"  # VIP 的地址和端口
kind: ClusterConfiguration
kubernetesVersion: v1.18.0
networking:
  dnsDomain: cluster.local
  serviceSubnet: 10.96.0.0/12
  podSubnet: 10.244.0.0/16        # 添加 pod 网段
scheduler: {}
EOF

# 直接 kubeadm init 初始化，中间会拉取镜像，速度较慢，分为两步来做
# （1）提前拉取镜像
kubeadm config images pull --config kubeadm-init.yaml
# （2）初始化
kubeadm init --config kubeadm-init.yaml --upload-certs

（2）按照提示信息，执行下方命令

# 执行下方命令
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 nodes
# 查看 pod
kubectl get pods -n kube-system

## 输出结果
[root@ks8master1 ~]# kubectl get nodes
[root@ks8master1 ~]# kubectl get pods -n kube-system

2、k8smaster2 节点

按照k8smaster1提示信息，将k8smaster2加入集群

# k8smaster2 加入集群
  kubeadm join 192.168.10.101:16443 --token abcdef.0123456789abcdef \
    --discovery-token-ca-cert-hash sha256:57cc2544224e646773db5ec401ad6e01e3d76ff769407fdd4bb600c18e354b71 \
    --control-plane --certificate-key d8bc6c08b4948778d2c549a9afb2898490fd0edd55388c661caff013de673c23

# 查看集群状态
kubectl get cs
# 查看 pod
kubectl get pods -n kube-system

3、k8snode1 节点

按照k8smaster1提示信息，将k8snode1加入集群

kubeadm join 192.168.10.101:16443 --token abcdef.0123456789abcdef \
    --discovery-token-ca-cert-hash sha256:57cc2544224e646773db5ec401ad6e01e3d76ff769407fdd4bb600c18e354b71

5、安装集群网络

从官方地址获取到 flannel 的 yaml，在 k8smaster1 上执行

# 下载 yaml 文件
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

6、测试 kubernetes 集群

在 Kubernetes 集群中创建一个 pod，验证是否正常运行：

# 创建 nginx deployment
kubectl create deployment nginx --image=nginx
# 暴露端口
kubectl expose deployment nginx --port=80 --type=NodePort
# 查看状态
kubectl get pod,svc

## [ip:port]
# 浏览器访问：
# 192.168.60.151:32594
# 192.168.60.152:32594
# 192.168.60.153:32594
[root@ks8master1 ~]# kubectl get pod,svc
NAME                 TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP        24m
service/nginx        NodePort    10.109.174.226   <none>        80:32594/TCP   8s

然后我们通过任何一个节点，都能够访问我们的 nginx 页面。

容器交付

在k8s集群中部署Java项目

容器交付流程

1、开发代码阶段：编写代码、编写Dockerfile【打镜像做准备】

2、持续交付/集成：代码编译打包、制作镜像、上传镜像仓库

3、应用部署：环境准备、Pod、Service、Ingress

4、运维：监控、故障排查、应用升级

k8s部署Java项目流程

• 制作镜像【Dockerfile】
• 上传到镜像仓库【Dockerhub、阿里云、网易】
• 控制器部署镜像【Deployment】
• 对外暴露应用【Service、Ingress】
• 运维【监控、升级】

同级别目录，springboot测试案例，\安装文档和yaml文件\javaproject\demojenkins

idea打包生成demojenkins.jar

1、编写程序生成jar包

上传jar和dockerfile

2、dockerfile生成镜像

docker build -t java-demo-01:latest .
查看
docker images

启动镜像测试

制作镜像后，启动镜像测试

docker run -d -p 8111:8111 java-demo-01:latest -t

启动完成后，通过浏览器进行访问，即可看到我们的java程序

http://192.168.10.102:8111/user

3、推送镜像

将制作好的镜像，上传到镜像服务器中【阿里云、DockerHub】

首先我们需要到 阿里云 容器镜像服务，https://cr.console.aliyun.com/cn-hangzhou/instances，然后开始创建镜像仓库

创建镜像仓库，选择本地仓库

4、登录镜像服务器

使用命令登录

docker login --username=[e-mail] registry.cn-shenzhen.aliyuncs.com

然后输入刚刚我们开放时候的注册的密码

5、镜像添加版本号

下面为镜像添加版本号

# 实例
docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/mogublog/java-project-01:[镜像版本号]

# 举例
docker tag 33f11349c27d registry.cn-shenzhen.aliyuncs.com/mogublog/java-project-01:1.0.0

6、推送镜像

添加版本号信息后，可以推送到镜像到阿里云了

docker push registry.cn-shenzhen.aliyuncs.com/mogublog/java-project-01:1.0.0

操作完成后，我们在我们的阿里云镜像服务，就能看到推送上来的镜像了

7、控制器部署镜像

通过控制器部署镜像了，首先根据刚刚的镜像，导出yaml

# 导出yaml
kubectl create deployment  javademo1 --image=registry.cn-hangzhou.aliyuncs.com/XXXXX/java-project-01:1.0.0 --dry-run -o yaml > javademo1.yaml

导出后的 javademo1.yaml 如下所示

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: javademo1
  name: javademo1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: javademo1
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: javademo1
    spec:
      containers:
      - image: registry.cn-shenzhen.aliyuncs.com/XXXXX/java-project-01:1.0.0
        name: java-project-01
        resources: {}
status: {}

然后通过下面命令，通过yaml创建我们的deployment

# 创建
kubectl apply -f javademo1.yaml
# 查看 pods

运维操作等。。。。。。。。。。。。。。。。