Prometheus+Grafana+Alertmanager搭建全方位的监控告警系统-超详细文档(下)

简介: Prometheus+Grafana+Alertmanager搭建全方位的监控告警系统-超详细文档

3)创建service
在8s的master1节点生成一个kube-state-metrics-svc.yaml文件

cat >kube-state-metrics-svc.yaml <<EOF
apiVersion: v1
kind: Service
metadata:
  annotations:
    prometheus.io/scrape: 'true'
  name: kube-state-metrics
  namespace: kube-system
  labels:
    app: kube-state-metrics
spec:
  ports:
  - name: kube-state-metrics
    port: 8080
    protocol: TCP
  selector:
    app: kube-state-metrics
EOF

通过kubectl apply更新yaml

kubectl apply -f kube-state-metrics-svc.yaml

查看service是否创建成功

kubectl get svc -n kube-system | grep kube-state-metrics

显示如下,说明创建成功

    kube-state-metrics   ClusterIP   10.105.53.102    <none>        8080/TCP                 2m38s

    在grafana web界面导入Kubernetes Cluster (Prometheus)-1577674936972.json,出现如下页面

    在grafana web界面导入Kubernetes cluster monitoring (via Prometheus) (k8s 1.16)-1577691996738.json,出现如下页面

    Kubernetes Cluster (Prometheus)-1577674936972.json和Kubernetes cluster monitoring (via Prometheus) (k8s 1.16)-1577691996738.json文件在百度网盘,地址如下:

      链接:https://pan.baidu.com/s/1QAMqT8scsXx-lzEPI6MPgA 提取码:i4yd

      安装和配置Alertmanager-发送报警到qq邮箱

      在k8s的master1节点创建alertmanager-cm.yaml文件

      cat >alertmanager-cm.yaml <<EOF
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: alertmanager
        namespace: monitor-sa
      data:
        alertmanager.yml: |-
          global:
            resolve_timeout: 1m
            smtp_smarthost: 'smtp.163.com:25'
            smtp_from: '15011572657@163.com'
            smtp_auth_username: '15011572657'
            smtp_auth_password: 'BDBPRMLNZGKWRFJP'
            smtp_require_tls: false
          route:
            group_by: [alertname]
            group_wait: 10s
            group_interval: 10s
            repeat_interval: 10m
            receiver: default-receiver
          receivers:
          - name: 'default-receiver'
            email_configs:
            - to: '1980570647@qq.com'
              send_resolved: true
      EOF

      通过kubectl apply 更新文件

      kubectl apply -f alertmanager-cm.yaml

      alertmanager配置文件解释说明:

      smtp_smarthost: 'smtp.163.com:25'
      #用于发送邮件的邮箱的SMTP服务器地址+端口
      smtp_from: '15011572657@163.com'
      #这是指定从哪个邮箱发送报警
      smtp_auth_username: '15011572657'
      #这是发送邮箱的认证用户,不是邮箱名
      smtp_auth_password: 'BDBPRMLNZGKWRFJP'
      #这是发送邮箱的授权码而不是登录密码
      email_configs:
         - to: '1980570647@qq.com'
      #to后面指定发送到哪个邮箱,我发送到我的qq邮箱,大家需要写自己的邮箱地址,不应该跟smtp_from的邮箱名字重复

      在k8s的master1节点重新生成一个prometheus-cfg.yaml文件

      cat prometheus-cfg.yaml

      kind: ConfigMap
      apiVersion: v1
      metadata:
        labels:
          app: prometheus
        name: prometheus-config
        namespace: monitor-sa
      data:
        prometheus.yml: |
          rule_files:
          - /etc/prometheus/rules.yml
          alerting:
            alertmanagers:
            - static_configs:
              - targets: ["localhost:9093"]
          global:
            scrape_interval: 15s
            scrape_timeout: 10s
            evaluation_interval: 1m
          scrape_configs:
          - job_name: 'kubernetes-node'
            kubernetes_sd_configs:
            - role: node
            relabel_configs:
            - source_labels: [__address__]
              regex: '(.*):10250'
              replacement: '${1}:9100'
              target_label: __address__
              action: replace
            - action: labelmap
              regex: __meta_kubernetes_node_label_(.+)
          - job_name: 'kubernetes-node-cadvisor'
            kubernetes_sd_configs:
            - role:  node
            scheme: https
            tls_config:
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
            relabel_configs:
            - action: labelmap
              regex: __meta_kubernetes_node_label_(.+)
            - target_label: __address__
              replacement: kubernetes.default.svc:443
            - source_labels: [__meta_kubernetes_node_name]
              regex: (.+)
              target_label: __metrics_path__
              replacement: /api/v1/nodes/${1}/proxy/metrics/cadvisor
          - job_name: 'kubernetes-apiserver'
            kubernetes_sd_configs:
            - role: endpoints
            scheme: https
            tls_config:
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
            relabel_configs:
            - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
              action: keep
              regex: default;kubernetes;https
          - job_name: 'kubernetes-service-endpoints'
            kubernetes_sd_configs:
            - role: endpoints
            relabel_configs:
            - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
              action: keep
              regex: true
            - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]
              action: replace
              target_label: __scheme__
              regex: (https?)
            - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
              action: replace
              target_label: __metrics_path__
              regex: (.+)
            - source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_port]
              action: replace
              target_label: __address__
              regex: ([^:]+)(?::\d+)?;(\d+)
              replacement: $1:$2
            - action: labelmap
              regex: __meta_kubernetes_service_label_(.+)
            - source_labels: [__meta_kubernetes_namespace]
              action: replace
              target_label: kubernetes_namespace
            - source_labels: [__meta_kubernetes_service_name]
              action: replace
              target_label: kubernetes_name 
          - job_name: kubernetes-pods
            kubernetes_sd_configs:
            - role: pod
            relabel_configs:
            - action: keep
              regex: true
              source_labels:
              - __meta_kubernetes_pod_annotation_prometheus_io_scrape
            - action: replace
              regex: (.+)
              source_labels:
              - __meta_kubernetes_pod_annotation_prometheus_io_path
              target_label: __metrics_path__
            - action: replace
              regex: ([^:]+)(?::\d+)?;(\d+)
              replacement: $1:$2
              source_labels:
              - __address__
              - __meta_kubernetes_pod_annotation_prometheus_io_port
              target_label: __address__
            - action: labelmap
              regex: __meta_kubernetes_pod_label_(.+)
            - action: replace
              source_labels:
              - __meta_kubernetes_namespace
              target_label: kubernetes_namespace
            - action: replace
              source_labels:
              - __meta_kubernetes_pod_name
              target_label: kubernetes_pod_name
          - job_name: 'kubernetes-schedule'
            scrape_interval: 5s
            static_configs:
            - targets: ['192.168.0.6:10251']
          - job_name: 'kubernetes-controller-manager'
            scrape_interval: 5s
            static_configs:
            - targets: ['192.168.0.6:10252']
          - job_name: 'kubernetes-kube-proxy'
            scrape_interval: 5s
            static_configs:
            - targets: ['192.168.0.6:10249','192.168.0.56:10249']
          - job_name: 'kubernetes-etcd'
            scheme: https
            tls_config:
              ca_file: /var/run/secrets/kubernetes.io/k8s-certs/etcd/ca.crt
              cert_file: /var/run/secrets/kubernetes.io/k8s-certs/etcd/server.crt
              key_file: /var/run/secrets/kubernetes.io/k8s-certs/etcd/server.key
            scrape_interval: 5s
            static_configs:
            - targets: ['192.168.0.6:2379']
        rules.yml: |
          groups:
          - name: example
            rules:
            - alert: kube-proxy的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-kube-proxy"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过80%"
            - alert:  kube-proxy的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-kube-proxy"}[1m]) * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过90%"
            - alert: scheduler的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-schedule"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过80%"
            - alert:  scheduler的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-schedule"}[1m]) * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过90%"
            - alert: controller-manager的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-controller-manager"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过80%"
            - alert:  controller-manager的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-controller-manager"}[1m]) * 100 > 0
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过90%"
            - alert: apiserver的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-apiserver"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过80%"
            - alert:  apiserver的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-apiserver"}[1m]) * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过90%"
            - alert: etcd的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-etcd"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过80%"
            - alert:  etcd的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{job=~"kubernetes-etcd"}[1m]) * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}组件的cpu使用率超过90%"
            - alert: kube-state-metrics的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{k8s_app=~"kube-state-metrics"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.k8s_app}}组件的cpu使用率超过80%"
                value: "{{ $value }}%"
                threshold: "80%"      
            - alert: kube-state-metrics的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{k8s_app=~"kube-state-metrics"}[1m]) * 100 > 0
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.k8s_app}}组件的cpu使用率超过90%"
                value: "{{ $value }}%"
                threshold: "90%"      
            - alert: coredns的cpu使用率大于80%
              expr: rate(process_cpu_seconds_total{k8s_app=~"kube-dns"}[1m]) * 100 > 80
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.k8s_app}}组件的cpu使用率超过80%"
                value: "{{ $value }}%"
                threshold: "80%"      
            - alert: coredns的cpu使用率大于90%
              expr: rate(process_cpu_seconds_total{k8s_app=~"kube-dns"}[1m]) * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.k8s_app}}组件的cpu使用率超过90%"
                value: "{{ $value }}%"
                threshold: "90%"      
            - alert: kube-proxy打开句柄数>600
              expr: process_open_fds{job=~"kubernetes-kube-proxy"}  > 600
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>600"
                value: "{{ $value }}"
            - alert: kube-proxy打开句柄数>1000
              expr: process_open_fds{job=~"kubernetes-kube-proxy"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>1000"
                value: "{{ $value }}"
            - alert: kubernetes-schedule打开句柄数>600
              expr: process_open_fds{job=~"kubernetes-schedule"}  > 600
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>600"
                value: "{{ $value }}"
            - alert: kubernetes-schedule打开句柄数>1000
              expr: process_open_fds{job=~"kubernetes-schedule"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>1000"
                value: "{{ $value }}"
            - alert: kubernetes-controller-manager打开句柄数>600
              expr: process_open_fds{job=~"kubernetes-controller-manager"}  > 600
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>600"
                value: "{{ $value }}"
            - alert: kubernetes-controller-manager打开句柄数>1000
              expr: process_open_fds{job=~"kubernetes-controller-manager"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>1000"
                value: "{{ $value }}"
            - alert: kubernetes-apiserver打开句柄数>600
              expr: process_open_fds{job=~"kubernetes-apiserver"}  > 600
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>600"
                value: "{{ $value }}"
            - alert: kubernetes-apiserver打开句柄数>1000
              expr: process_open_fds{job=~"kubernetes-apiserver"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>1000"
                value: "{{ $value }}"
            - alert: kubernetes-etcd打开句柄数>600
              expr: process_open_fds{job=~"kubernetes-etcd"}  > 600
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>600"
                value: "{{ $value }}"
            - alert: kubernetes-etcd打开句柄数>1000
              expr: process_open_fds{job=~"kubernetes-etcd"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "{{$labels.instance}}的{{$labels.job}}打开句柄数>1000"
                value: "{{ $value }}"
            - alert: coredns
              expr: process_open_fds{k8s_app=~"kube-dns"}  > 600
              for: 2s
              labels:
                severity: warnning 
              annotations:
                description: "插件{{$labels.k8s_app}}({{$labels.instance}}): 打开句柄数超过600"
                value: "{{ $value }}"
            - alert: coredns
              expr: process_open_fds{k8s_app=~"kube-dns"}  > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                description: "插件{{$labels.k8s_app}}({{$labels.instance}}): 打开句柄数超过1000"
                value: "{{ $value }}"
            - alert: kube-proxy
              expr: process_virtual_memory_bytes{job=~"kubernetes-kube-proxy"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: scheduler
              expr: process_virtual_memory_bytes{job=~"kubernetes-schedule"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: kubernetes-controller-manager
              expr: process_virtual_memory_bytes{job=~"kubernetes-controller-manager"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: kubernetes-apiserver
              expr: process_virtual_memory_bytes{job=~"kubernetes-apiserver"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: kubernetes-etcd
              expr: process_virtual_memory_bytes{job=~"kubernetes-etcd"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: kube-dns
              expr: process_virtual_memory_bytes{k8s_app=~"kube-dns"}  > 2000000000
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "插件{{$labels.k8s_app}}({{$labels.instance}}): 使用虚拟内存超过2G"
                value: "{{ $value }}"
            - alert: HttpRequestsAvg
              expr: sum(rate(rest_client_requests_total{job=~"kubernetes-kube-proxy|kubernetes-kubelet|kubernetes-schedule|kubernetes-control-manager|kubernetes-apiservers"}[1m]))  > 1000
              for: 2s
              labels:
                team: admin
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): TPS超过1000"
                value: "{{ $value }}"
                threshold: "1000"   
            - alert: Pod_restarts
              expr: kube_pod_container_status_restarts_total{namespace=~"kube-system|default|monitor-sa"} > 0
              for: 2s
              labels:
                severity: warnning
              annotations:
                description: "在{{$labels.namespace}}名称空间下发现{{$labels.pod}}这个pod下的容器{{$labels.container}}被重启,这个监控指标是由{{$labels.instance}}采集的"
                value: "{{ $value }}"
                threshold: "0"
            - alert: Pod_waiting
              expr: kube_pod_container_status_waiting_reason{namespace=~"kube-system|default"} == 1
              for: 2s
              labels:
                team: admin
              annotations:
                description: "空间{{$labels.namespace}}({{$labels.instance}}): 发现{{$labels.pod}}下的{{$labels.container}}启动异常等待中"
                value: "{{ $value }}"
                threshold: "1"   
            - alert: Pod_terminated
              expr: kube_pod_container_status_terminated_reason{namespace=~"kube-system|default|monitor-sa"} == 1
              for: 2s
              labels:
                team: admin
              annotations:
                description: "空间{{$labels.namespace}}({{$labels.instance}}): 发现{{$labels.pod}}下的{{$labels.container}}被删除"
                value: "{{ $value }}"
                threshold: "1"
            - alert: Etcd_leader
              expr: etcd_server_has_leader{job="kubernetes-etcd"} == 0
              for: 2s
              labels:
                team: admin
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 当前没有leader"
                value: "{{ $value }}"
                threshold: "0"
            - alert: Etcd_leader_changes
              expr: rate(etcd_server_leader_changes_seen_total{job="kubernetes-etcd"}[1m]) > 0
              for: 2s
              labels:
                team: admin
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 当前leader已发生改变"
                value: "{{ $value }}"
                threshold: "0"
            - alert: Etcd_failed
              expr: rate(etcd_server_proposals_failed_total{job="kubernetes-etcd"}[1m]) > 0
              for: 2s
              labels:
                team: admin
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}): 服务失败"
                value: "{{ $value }}"
                threshold: "0"
            - alert: Etcd_db_total_size
              expr: etcd_debugging_mvcc_db_total_size_in_bytes{job="kubernetes-etcd"} > 10000000000
              for: 2s
              labels:
                team: admin
              annotations:
                description: "组件{{$labels.job}}({{$labels.instance}}):db空间超过10G"
                value: "{{ $value }}"
                threshold: "10G"
            - alert: Endpoint_ready
              expr: kube_endpoint_address_not_ready{namespace=~"kube-system|default"} == 1
              for: 2s
              labels:
                team: admin
              annotations:
                description: "空间{{$labels.namespace}}({{$labels.instance}}): 发现{{$labels.endpoint}}不可用"
                value: "{{ $value }}"
                threshold: "1"
          - name: 物理节点状态-监控告警
            rules:
            - alert: 物理节点cpu使用率
              expr: 100-avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) by(instance)*100 > 90
              for: 2s
              labels:
                severity: ccritical
              annotations:
                summary: "{{ $labels.instance }}cpu使用率过高"
                description: "{{ $labels.instance }}的cpu使用率超过90%,当前使用率[{{ $value }}],需要排查处理" 
            - alert: 物理节点内存使用率
              expr: (node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) / node_memory_MemTotal_bytes * 100 > 90
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{ $labels.instance }}内存使用率过高"
                description: "{{ $labels.instance }}的内存使用率超过90%,当前使用率[{{ $value }}],需要排查处理"
            - alert: InstanceDown
              expr: up == 0
              for: 2s
              labels:
                severity: critical
              annotations:   
                summary: "{{ $labels.instance }}: 服务器宕机"
                description: "{{ $labels.instance }}: 服务器延时超过2分钟"
            - alert: 物理节点磁盘的IO性能
              expr: 100-(avg(irate(node_disk_io_time_seconds_total[1m])) by(instance)* 100) < 60
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{$labels.mountpoint}} 流入磁盘IO使用率过高!"
                description: "{{$labels.mountpoint }} 流入磁盘IO大于60%(目前使用:{{$value}})"
            - alert: 入网流量带宽
              expr: ((sum(rate (node_network_receive_bytes_total{device!~'tap.*|veth.*|br.*|docker.*|virbr*|lo*'}[5m])) by (instance)) / 100) > 102400
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{$labels.mountpoint}} 流入网络带宽过高!"
                description: "{{$labels.mountpoint }}流入网络带宽持续5分钟高于100M. RX带宽使用率{{$value}}"
            - alert: 出网流量带宽
              expr: ((sum(rate (node_network_transmit_bytes_total{device!~'tap.*|veth.*|br.*|docker.*|virbr*|lo*'}[5m])) by (instance)) / 100) > 102400
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{$labels.mountpoint}} 流出网络带宽过高!"
                description: "{{$labels.mountpoint }}流出网络带宽持续5分钟高于100M. RX带宽使用率{{$value}}"
            - alert: TCP会话
              expr: node_netstat_Tcp_CurrEstab > 1000
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{$labels.mountpoint}} TCP_ESTABLISHED过高!"
                description: "{{$labels.mountpoint }} TCP_ESTABLISHED大于1000%(目前使用:{{$value}}%)"
            - alert: 磁盘容量
              expr: 100-(node_filesystem_free_bytes{fstype=~"ext4|xfs"}/node_filesystem_size_bytes {fstype=~"ext4|xfs"}*100) > 80
              for: 2s
              labels:
                severity: critical
              annotations:
                summary: "{{$labels.mountpoint}} 磁盘分区使用率过高!"
                description: "{{$labels.mountpoint }} 磁盘分区使用大于80%(目前使用:{{$value}

      注意:通过上面命令生成的promtheus-cfg.yaml文件会有一些问题,1和1和2这种变量在文件里没有,需要在k8s的master1节点打开promtheus-cfg.yaml文件,手动把1和1和2这种变量写进文件里,promtheus-cfg.yaml文件需要手动修改部分如下:

      22行的replacement: ':9100'变成replacement: '${1}:9100'
      42行的replacement: /api/v1/nodes//proxy/metrics/cadvisor变成
                    replacement: /api/v1/nodes/${1}/proxy/metrics/cadvisor
      73行的replacement:  变成replacement: $1:$2
      103行的replacement:  变成replacement: $1:$2

      通过kubectl apply 更新文件

      kubectl apply -f prometheus-cfg.yaml

      在k8s的master1节点重新生成一个prometheus-deploy.yaml文件

      cat >prometheus-deploy.yaml <<EOF
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: prometheus-server
        namespace: monitor-sa
        labels:
          app: prometheus
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: prometheus
            component: server
          #matchExpressions:
          #- {key: app, operator: In, values: [prometheus]}
          #- {key: component, operator: In, values: [server]}
        template:
          metadata:
            labels:
              app: prometheus
              component: server
            annotations:
              prometheus.io/scrape: 'false'
          spec:
            nodeName: node1
            serviceAccountName: monitor
            containers:
            - name: prometheus
              image: prom/prometheus:v2.2.1
              imagePullPolicy: IfNotPresent
              command:
              - "/bin/prometheus"
              args:
              - "--config.file=/etc/prometheus/prometheus.yml"
              - "--storage.tsdb.path=/prometheus"
              - "--storage.tsdb.retention=24h"
              - "--web.enable-lifecycle"
              ports:
              - containerPort: 9090
                protocol: TCP
              volumeMounts:
              - mountPath: /etc/prometheus
                name: prometheus-config
              - mountPath: /prometheus/
                name: prometheus-storage-volume
              - name: k8s-certs
                mountPath: /var/run/secrets/kubernetes.io/k8s-certs/etcd/
            - name: alertmanager
              image: prom/alertmanager:v0.14.0
              imagePullPolicy: IfNotPresent
              args:
              - "--config.file=/etc/alertmanager/alertmanager.yml"
              - "--log.level=debug"
              ports:
              - containerPort: 9093
                protocol: TCP
                name: alertmanager
              volumeMounts:
              - name: alertmanager-config
                mountPath: /etc/alertmanager
              - name: alertmanager-storage
                mountPath: /alertmanager
              - name: localtime
                mountPath: /etc/localtime
            volumes:
              - name: prometheus-config
                configMap:
                  name: prometheus-config
              - name: prometheus-storage-volume
                hostPath:
                 path: /data
                 type: Directory
              - name: k8s-certs
                secret:
                 secretName: etcd-certs
              - name: alertmanager-config
                configMap:
                  name: alertmanager
              - name: alertmanager-storage
                hostPath:
                 path: /data/alertmanager
                 type: DirectoryOrCreate
              - name: localtime
                hostPath:
                 path: /usr/share/zoneinfo/Asia/Shanghai
      EOF

      生成一个etcd-certs,这个在部署prometheus需要

      kubectl -n monitor-sa create secret generic etcd-certs --from-file=/etc/kubernetes/pki/etcd/server.key  --from-file=/etc/kubernetes/pki/etcd/server.crt --from-file=/etc/kubernetes/pki/etcd/ca.crt
      通过kubectl apply更新yaml文件

      kubectl apply -f prometheus-deploy.yaml

      #查看prometheus是否部署成功

      kubectl get pods -n monitor-sa | grep prometheus

      显示如下,可看到pod状态是running,说明prometheus部署成功

      NAME                                 READY   STATUS    RESTARTS   AGE
      prometheus-server-85dbc6c7f7-nsg94   1/1     Running   0          6m7

      在k8s的master1节点重新生成一个alertmanager-svc.yaml文件

      cat >alertmanager-svc.yaml <<EOF
      ---
      apiVersion: v1
      kind: Service
      metadata:
        labels:
          name: prometheus
          kubernetes.io/cluster-service: 'true'
        name: alertmanager
        namespace: monitor-sa
      spec:
        ports:
        - name: alertmanager
          nodePort: 30066
          port: 9093
          protocol: TCP
          targetPort: 9093
        selector:
          app: prometheus
        sessionAffinity: None
        type: NodePort
      EOF

      通过kubectl apply更新yaml文件

      kubectl apply -f prometheus-svc.yaml

      #查看service在物理机映射的端口

      kubectl get svc -n monitor-sa

      显示如下:

      NAME           TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
      alertmanager   NodePort   10.111.49.65   <none>        9093:31043/TCP   25s
      prometheus     NodePort   10.96.45.93    <none>        9090:30090/TCP   34h

      注意:上面可以看到prometheus的service暴漏的端口是31043,alertmanager的service暴露的端口是30066

      访问prometheus的web界面

      点击status->targets,可看到如下

      点击Alerts,可看到如下

      把controller-manager的cpu使用率大于90%展开,可看到如下

      FIRING表示prometheus已经将告警发给alertmanager,在Alertmanager 中可以看到有一个 alert。

      登录到alertmanager web界面

      浏览器输入192.168.0.6:30066,显示如下

      这样我在我的qq邮箱,1980570647@qq.com就可以收到报警了,如下

      配置Alertmanager报警-发送报警到钉钉

      打开电脑版钉钉创建机器人

      1.创建钉钉机器人

      打开电脑版钉钉,创建一个群,创建自定义机器人,按如下步骤创建
      https://ding-doc.dingtalk.com/doc#/serverapi2/qf2nxq
      我创建的机器人如下:
      群设置-->智能群助手-->添加机器人-->自定义-->添加
      机器人名称:kube-event
      接收群组:钉钉报警测试
      安全设置:
      自定义关键词:cluster1
      上面配置好之后点击完成即可,这样就会创建一个kube-event的报警机器人,创建机器人成功之后怎么查看webhook,按如下:
      点击智能群助手,可以看到刚才创建的kube-event这个机器人,点击kube-event,就会进入到kube-event机器人的设置界面
      出现如下内容:
      机器人名称:kube-event
      接受群组:钉钉报警测试
      消息推送:开启
      webhook:https://oapi.dingtalk.com/robot/send?access_token=9c03ff1f47b1d15a10d852398cafb84f8e81ceeb1ba557eddd8a79e5a5e5548e
      安全设置:
      自定义关键词:cluster1

      2.安装钉钉的webhook插件,在k8s的master1节点操作

      tar zxvf prometheus-webhook-dingtalk-0.3.0.linux-amd64.tar.gz

      prometheus-webhook-dingtalk-0.3.0.linux-amd64.tar.gz压缩包所在的百度网盘地址如下:

      链接:https://pan.baidu.com/s/1_HtVZsItq2KsYvOlkIP9DQ 
      提取码:d59o

      cd prometheus-webhook-dingtalk-0.3.0.linux-amd64

      启动钉钉报警插件

      nohup ./prometheus-webhook-dingtalk --web.listen-address="0.0.0.0:8060" --ding.profile="cluster1=https://oapi.dingtalk.com/robot/send?access_token=9c03ff1f47b1d15a10d852398cafb84f8e81ceeb1ba557eddd8a79e5a5e5548e" &

      对原来的文件做备份

      cp alertmanager-cm.yaml alertmanager-cm.yaml.bak

      重新生成一个新的alertmanager-cm.yaml文件

      cat >alertmanager-cm.yaml <<EOF
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: alertmanager
        namespace: monitor-sa
      data:
        alertmanager.yml: |-
          global:
            resolve_timeout: 1m
            smtp_smarthost: 'smtp.163.com:25'
            smtp_from: '15011572657@163.com'
            smtp_auth_username: '15011572657'
            smtp_auth_password: 'BDBPRMLNZGKWRFJP'
            smtp_require_tls: false
          route:
            group_by: [alertname]
            group_wait: 10s
            group_interval: 10s
            repeat_interval: 10m
            receiver: cluster1
          receivers:
          - name: cluster1
            webhook_configs:
            - url: 'http://192.168.124.16:8060/dingtalk/cluster1/send'
              send_resolved: true
      EOF

      通过kubectl apply使配置生效

      kubectl delete -f alertmanager-cm.yaml

      kubectl  apply  -f alertmanager-cm.yaml

      kubectl delete -f prometheus-cfg.yaml

      kubectl apply  -f prometheus-cfg.yaml

      kubectl delete  -f prometheus-deploy.yaml

      kubectl apply  -f  prometheus-deploy.yaml

      通过上面步骤,就可以实现钉钉报警了


      接下来会给大家写通过alertmanager发送微信报警,根据报警级别实现钉钉+微信+邮箱同时报警,同时还会扩展prometheus监控,如监控tomcat、nginx、mysql、redis、mongodb等组件,也会介绍使用prometheus的pushgateway进行自定义数据的监控等,请关注我来持续学习。

      相关实践学习
      深入解析Docker容器化技术
      Docker是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。Docker是世界领先的软件容器平台。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。运维人员利用Docker可以在隔离容器中并行运行和管理应用,获得更好的计算密度。企业利用Docker可以构建敏捷的软件交付管道,以更快的速度、更高的安全性和可靠的信誉为Linux和Windows Server应用发布新功能。 在本套课程中,我们将全面的讲解Docker技术栈,从环境安装到容器、镜像操作以及生产环境如何部署开发的微服务应用。本课程由黑马程序员提供。 &nbsp; &nbsp; 相关的阿里云产品:容器服务 ACK 容器服务 Kubernetes 版(简称 ACK)提供高性能可伸缩的容器应用管理能力,支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力,打造云端最佳容器化应用运行环境。 了解产品详情: https://www.aliyun.com/product/kubernetes
      相关文章
      |
      11月前
      |
      存储 前端开发 数据可视化
      Grafana Loki,轻量级日志系统
      本文介绍了基于Grafana、Loki和Alloy构建的轻量级日志系统。Loki是一个由Grafana Labs开发的日志聚合系统,具备高可用性和多租户支持,专注于日志而非指标,通过标签索引而非内容索引实现高效存储。Alloy则是用于收集和转发日志至Loki的强大工具。文章详细描述了系统的架构、组件及其工作流程,并提供了快速搭建指南,包括准备步骤、部署命令及验证方法。此外,还展示了如何使用Grafana查看日志,以及一些基本的LogQL查询示例。最后,作者探讨了Loki架构的独特之处,提出了“巨型单体模块化”的概念,即一个应用既可单体部署也可分布式部署,整体协同实现全部功能。
      4423 69
      Grafana Loki,轻量级日志系统
      |
      9月前
      |
      Prometheus 监控 Cloud Native
      Prometheus+Grafana(docker安装)
      本文档详细介绍了如何使用Docker容器快速部署Prometheus监控系统和Grafana数据可视化平台。该方案适用于需要快速搭建监控环境的开发测试场景,具备部署简单、资源占用低、易于维护等特点。
      |
      存储 数据采集 Prometheus
      Grafana Prometheus Altermanager 监控系统
      Grafana、Prometheus 和 Alertmanager 是一套强大的开源监控系统组合。Prometheus 负责数据采集与存储,Alertmanager 处理告警通知,Grafana 提供可视化界面。本文简要介绍了这套系统的安装配置流程,包括各组件的下载、安装、服务配置及开机自启设置,并提供了访问地址和重启命令。适用于希望快速搭建高效监控平台的用户。
      789 20
      |
      Prometheus 监控 Cloud Native
      Prometheus+Grafana监控Linux主机
      通过本文的步骤,我们成功地在 Linux 主机上使用 Prometheus 和 Grafana 进行了监控配置。具体包括安装 Prometheus 和 Node Exporter,配置 Grafana 数据源,并导入预设的仪表盘来展示监控数据。通过这种方式,可以轻松实现对 Linux 主机的系统指标监控,帮助及时发现和处理潜在问题。
      1199 7
      |
      8月前
      |
      运维 监控 网络协议
      物联网设备状态监控全解析:从告警参数到静默管理的深度指南-优雅草卓伊凡
      物联网设备状态监控全解析:从告警参数到静默管理的深度指南-优雅草卓伊凡
      282 11
      物联网设备状态监控全解析:从告警参数到静默管理的深度指南-优雅草卓伊凡
      |
      Prometheus 运维 监控
      智能运维实战:Prometheus与Grafana的监控与告警体系
      【10月更文挑战第26天】Prometheus与Grafana是智能运维中的强大组合,前者是开源的系统监控和警报工具,后者是数据可视化平台。Prometheus具备时间序列数据库、多维数据模型、PromQL查询语言等特性,而Grafana支持多数据源、丰富的可视化选项和告警功能。两者结合可实现实时监控、灵活告警和高度定制化的仪表板,广泛应用于服务器、应用和数据库的监控。
      1369 3
      |
      7月前
      |
      编解码 监控 算法
      CDN+OSS边缘加速实践:动态压缩+智能路由降低30%视频流量成本(含带宽峰值监控与告警配置)
      本方案通过动态压缩、智能路由及CDN与OSS集成优化,实现视频业务带宽成本下降31%,首帧时间缩短50%,错误率降低53%。结合实测数据分析与架构创新,有效解决冷启动延迟、跨区域传输及设备适配性问题,具备快速投入回收能力。
      496 0
      |
      10月前
      |
      数据采集 运维 监控
      数据采集监控与告警:错误重试、日志分析与自动化运维
      本文探讨了数据采集技术从“简单采集”到自动化运维的演进。传统方式因反爬策略和网络波动常导致数据丢失,而引入错误重试、日志分析与自动化告警机制可显著提升系统稳定性与时效性。正方强调健全监控体系的重要性,反方则担忧复杂化带来的成本与安全风险。未来,结合AI与大数据技术,数据采集将向智能化、全自动方向发展,实现动态调整与智能识别反爬策略,降低人工干预需求。附带的Python示例展示了如何通过代理IP、重试策略及日志记录实现高效的数据采集程序。
      511 7
      数据采集监控与告警:错误重试、日志分析与自动化运维
      |
      10月前
      |
      Prometheus Kubernetes 监控
      Kubernetes监控:Prometheus与AlertManager结合,配置邮件告警。
      完成这些步骤之后,您就拥有了一个可以用邮件通知你的Kubernetes监控解决方案了。当然,所有的这些配置都需要相互照应,还要对你的Kubernetes集群状况有深入的了解。希望这份指南能帮助你创建出适合自己场景的监控系统,让你在首次发现问题时就能做出响应。
      608 22
      |
      Prometheus 监控 Cloud Native
      【监控】prometheus传统环境监控告警常用配置
      【监控】prometheus传统环境监控告警常用配置
      【监控】prometheus传统环境监控告警常用配置

      推荐镜像

      更多