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

本文涉及的产品
容器服务 Serverless 版 ACK Serverless,317元额度 多规格
可观测监控 Prometheus 版,每月50GB免费额度
容器服务 Serverless 版 ACK Serverless,952元额度 多规格
简介: Prometheus+Grafana+Alertmanager搭建全方位的监控告警系统-超详细文档

前言

本篇文章介绍k8s集群中部署prometheus、grafana、alertmanager,并且配置prometheus的动态、静态服务发现,实现对容器、物理节点、service、pod等资源指标监控,并在Grafana的web界面展示prometheus的监控指标,然后通过配置自定义告警规则,通过alertmanager实现qq、钉钉、微信报警,文章内容较多,大概1.5万以上字数,可以先关注和转发,在慢慢学习。

prometheus简介

Prometheus是一个开源的系统监控和报警系统,现在已经加入到CNCF基金会,成为继k8s之后第二个在CNCF托管的项目,在kubernetes容器管理系统中,通常会搭配prometheus进行监控,同时也支持多种exporter采集数据,还支持pushgateway进行数据上报,Prometheus性能足够支撑上万台规模的集群。

prometheus特点

1.多维度数据模型

时间序列数据由metrics名称和键值对来组成
可以对数据进行聚合,切割等操作
所有的metrics都可以设置任意的多维标签。

2.灵活的查询语言(PromQL)

    可以对采集的metrics指标进行加法,乘法,连接等操作;

    3.可以直接在本地部署,不依赖其他分布式存储;

    4.通过基于HTTP的pull方式采集时序数据;

    5.可以通过中间网关pushgateway的方式把时间序列数据推送到prometheus server端;

    6.可通过服务发现或者静态配置来发现目标服务对象(targets)。

    7.有多种可视化图像界面,如Grafana等。

    8.高效的存储,每个采样数据占3.5 bytes左右,300万的时间序列,30s间隔,保留60天,消耗磁盘大概200G。

    prometheus组件介绍

    1.Prometheus Server: 用于收集和存储时间序列数据。

    2.Client Library: 客户端库,检测应用程序代码,当Prometheus抓取实例的HTTP端点时,客户端库会将所有跟踪的metrics指标的当前状态发送到prometheus server端。

    3.Exporters: prometheus支持多种exporter,通过exporter可以采集metrics数据,然后发送到prometheus server端

    4.Alertmanager: 从 Prometheus server 端接收到 alerts 后,会进行去重,分组,并路由到相应的接收方,发出报警,常见的接收方式有:电子邮件,微信,钉钉, slack等。

    5.Grafana监控仪表盘

    6.pushgateway: 各个目标主机可上报数据到pushgatewy,然后prometheus server统一从pushgateway拉取数据。

    prometheus架构图

    从上图可发现,Prometheus整个生态圈组成主要包括prometheus server,Exporter,pushgateway,alertmanager,grafana,Web ui界面,Prometheus server由三个部分组成,Retrieval,Storage,PromQL

      Retrieval负责在活跃的target主机上抓取监控指标数据
        Storage存储主要是把采集到的数据存储到磁盘中
          PromQL是Prometheus提供的查询语言模块。

          prometheus工作流程:

          1.  Prometheus  server可定期从活跃的(up)目标主机上(target)拉取监控指标数据,目标主机的监控数据可通过配置静态job或者服务发现的方式被prometheus server采集到,这种方式默认的pull方式拉取指标;也可通过pushgateway把采集的数据上报到prometheus server中;还可通过一些组件自带的exporter采集相应组件的数据;

          2.Prometheus server把采集到的监控指标数据保存到本地磁盘或者数据库;

          3.Prometheus采集的监控指标数据按时间序列存储,通过配置报警规则,把触发的报警发送到alertmanager

          4.Alertmanager通过配置报警接收方,发送报警到邮件,微信或者钉钉等

          5.Prometheus 自带的web ui界面提供PromQL查询语言,可查询监控数据

          6.Grafana可接入prometheus数据源,把监控数据以图形化形式展示出

          安装node-exporter组件

          机器规划:

          我的实验环境使用的k8s集群是一个master节点和一个node节点

          master节点的机器ip是192.168.0.6,主机名是master1

          node节点的机器ip是192.168.0.56,主机名是node1

          master高可用集群安装可参考如下文章:

          k8s1.18高可用集群安装-超详细中文官方文档

          k8s1.18多master节点高可用集群安装-超详细中文官方文档


          node-exporter是什么?

          采集机器(物理机、虚拟机、云主机等)的监控指标数据,能够采集到的指标包括CPU, 内存,磁盘,网络,文件数等信息。

          安装node-exporter组件,在k8s集群的master1节点操作

          cat >node-export.yaml  <<EOF
          apiVersion: apps/v1
          kind: DaemonSet
          metadata:
            name: node-exporter
            namespace: monitor-sa
            labels:
              name: node-exporter
          spec:
            selector:
              matchLabels:
               name: node-exporter
            template:
              metadata:
                labels:
                  name: node-exporter
              spec:
                hostPID: true
                hostIPC: true
                hostNetwork: true
                containers:
                - name: node-exporter
                  image: prom/node-exporter:v0.16.0
                  ports:
                  - containerPort: 9100
                  resources:
                    requests:
                      cpu: 0.15
                  securityContext:
                    privileged: true
                  args:
                  - --path.procfs
                  - /host/proc
                  - --path.sysfs
                  - /host/sys
                  - --collector.filesystem.ignored-mount-points
                  - '"^/(sys|proc|dev|host|etc)($|/)"'
                  volumeMounts:
                  - name: dev
                    mountPath: /host/dev
                  - name: proc
                    mountPath: /host/proc
                  - name: sys
                    mountPath: /host/sys
                  - name: rootfs
                    mountPath: /rootfs
                tolerations:
                - key: "node-role.kubernetes.io/master"
                  operator: "Exists"
                  effect: "NoSchedule"
                volumes:
                  - name: proc
                    hostPath:
                      path: /proc
                  - name: dev
                    hostPath:
                      path: /dev
                  - name: sys
                    hostPath:
                      path: /sys
                  - name: rootfs
                    hostPath:
                      path: /
          EOF

          #通过kubectl apply更新node-exporter

          kubectl apply -f node-export.yaml

          #查看node-exporter是否部署成功

          kubectl get pods -n monitor-sa

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

          NAME                  READY   STATUS    RESTARTS   AGE
          node-exporter-9qpkd   1/1     Running   0          89s
          node-exporter-zqmnk   1/1     Running   0          89s

          通过node-exporter采集数据

          curl  http://主机ip:9100/metrics
          #node-export默认的监听端口是9100,可以看到当前主机获取到的所有监控数据,截取一部分,如下

          # HELP node_cpu_seconds_total Seconds the cpus spent in each mode.
          # TYPE node_cpu_seconds_total counter
          node_cpu_seconds_total{cpu="0",mode="idle"} 56136.98
          # HELP node_load1 1m load average.
          # TYPE node_load1 gauge
          node_load1 0.58
          #HELP:解释当前指标的含义,上面表示在每种模式下node节点的cpu花费的时间,以s为单位
          #TYPE:说明当前指标的数据类型,上面是counter类型
          node_load1该指标反映了当前主机在最近一分钟以内的负载情况,系统的负载情况会随系统资源的使用而变化,因此node_load1反映的是当前状态,数据可能增加也可能减少,从注释中可以看出当前指标类型为gauge(标准尺寸)
          node_cpu_seconds_total{cpu="0",mode="idle"} :
          cpu0上idle进程占用CPU的总时间,CPU占用时间是一个只增不减的度量指标,从类型中也可以看出node_cpu的数据类型是counter(计数器)
          counter计数器:只是采集递增的指标
          gauge标准尺寸:统计的指标可增加可减少

          k8s集群中部署prometheus

          1.创建namespace、sa账号在k8s集群的master节点操作

          #创建一个monitor-sa的名称空间

          kubectl create ns monitor-sa

          #创建一个sa账号

          kubectl create serviceaccount monitor -n monitor-sa  

          #把sa账号monitor通过clusterrolebing绑定到clusterrole上

          kubectl create clusterrolebinding monitor-clusterrolebinding -n monitor-sa --clusterrole=cluster-admin  --serviceaccount=monitor-sa:monitor

          2.创建数据目录

          #在k8s集群的任何一个node节点操作,因为我的k8s集群只有一个node节点node1,所以我在node1上操作如下命令:

          mkdir /data
          chmod 777 /data/

          3.安装prometheus,以下步骤均在在k8s集群的master1节点操作

          1)创建一个configmap存储卷,用来存放prometheus配置信息

          cat  >prometheus-cfg.yaml <<EOF
          ---
          kind: ConfigMap
          apiVersion: v1
          metadata:
            labels:
              app: prometheus
            name: prometheus-config
            namespace: monitor-sa
          data:
            prometheus.yml: |
              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 
          EOF

          注意:通过上面命令生成的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

          #通过kubectl apply更新configmap

          kubectl apply  -f  prometheus-cfg.yaml


          2)通过deployment部署prometheus

          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:
                    - prometheus
                    - --config.file=/etc/prometheus/prometheus.yml
                    - --storage.tsdb.path=/prometheus
                    - --storage.tsdb.retention=720h
                  ports:
                  - containerPort: 9090
                    protocol: TCP
                  volumeMounts:
                  - mountPath: /etc/prometheus/prometheus.yml
                    name: prometheus-config
                    subPath: prometheus.yml
                  - mountPath: /prometheus/
                    name: prometheus-storage-volume
                volumes:
                  - name: prometheus-config
                    configMap:
                      name: prometheus-config
                      items:
                        - key: prometheus.yml
                          path: prometheus.yml
                          mode: 0644
                  - name: prometheus-storage-volume
                    hostPath:
                     path: /data
                     type: Directory
          EOF

          注意:在上面的prometheus-deploy.yaml文件有个nodeName字段,这个就是用来指定创建的这个prometheus的pod调度到哪个节点上,我们这里让nodeName=node1,也即是让pod调度到node1节点上,因为node1节点我们创建了数据目录/data,所以大家记住:你在k8s集群的哪个节点创建/data,就让pod调度到哪个节点。

          #通过kubectl apply更新prometheus

          kubectl apply -f prometheus-deploy.yaml

          #查看prometheus是否部署成功

          kubectl get pods -n monitor-sa

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

          NAME                                 READY   STATUS    RESTARTS   AGE
          node-exporter-9qpkd                  1/1     Running   0          76m
          node-exporter-zqmnk                  1/1     Running   0          76m
          prometheus-server-85dbc6c7f7-nsg94   1/1     Running   0          6m7

          3)给prometheus pod创建一个service

          cat  > prometheus-svc.yaml << EOF
          ---
          apiVersion: v1
          kind: Service
          metadata:
            name: prometheus
            namespace: monitor-sa
            labels:
              app: prometheus
          spec:
            type: NodePort
            ports:
              - port: 9090
                targetPort: 9090
                protocol: TCP
            selector:
              app: prometheus
              component: server
          EOF

          #通过kubectl apply 更新service

          kubectl  apply -f prometheus-svc.yaml

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

          kubectl get svc -n monitor-sa

          显示如下:

          NAME         TYPE       CLUSTER-IP    EXTERNAL-IP   PORT(S)          AGE
          prometheus   NodePort   10.96.45.93   <none>        9090:31043/TCP   50s

          通过上面可以看到service在宿主机上映射的端口是31043,这样我们访问k8s集群的master1节点的ip:31043,就可以访问到prometheus的web ui界面了

          #访问prometheus web ui界面

          火狐浏览器输入如下地址:

          http://192.168.0.6:31043/graph

          可看到如下页面:

          #点击页面的Status->Targets,可看到如下,说明我们配置的服务发现可以正常采集数据

          prometheus热更新

          #为了每次修改配置文件可以热加载prometheus,也就是不停止prometheus,就可以使配置生效,如修改prometheus-cfg.yaml,想要使配置生效可用如下热加载命令:
          curl -X POST http://10.244.1.66:9090/-/reload

          #10.244.1.66是prometheus的pod的ip地址,如何查看prometheus的pod ip,可用如下命令:

          kubectl get pods -n monitor-sa -o wide | grep prometheus

          显示如下, 10.244.1.7就是prometheus的ip

            prometheus-server-85dbc6c7f7-nsg94   1/1     Running   0          29m   10.244.1.7     node1     <none>           <none>

            #热加载速度比较慢,可以暴力重启prometheus,如修改上面的prometheus-cfg.yaml文件之后,可执行如下强制删除:

            kubectl delete -f prometheus-cfg.yaml

            kubectl delete -f prometheus-deploy.yaml

            然后再通过apply更新:

            kubectl apply -f prometheus-cfg.yaml

            kubectl apply -f prometheus-deploy.yaml

            注意:

            线上最好热加载,暴力删除可能造成监控数据的丢失

            Grafana安装和配置

            下载安装Grafana需要的镜像

            上传heapster-grafana-amd64_v5_0_4.tar.gz镜像到k8s的各个master节点和k8s的各个node节点,然后在各个节点手动解压:
            docker load -i heapster-grafana-amd64_v5_0_4.tar.gz

            镜像所在的百度网盘地址如下:

            链接:https://pan.baidu.com/s/1TmVGKxde_cEYrbjiETboEA 
            提取码:052u

            在k8s的master1节点创建grafana.yaml

            cat  >grafana.yaml <<  EOF
            apiVersion: apps/v1
            kind: Deployment
            metadata:
              name: monitoring-grafana
              namespace: kube-system
            spec:
              replicas: 1
              selector:
                matchLabels:
                  task: monitoring
                  k8s-app: grafana
              template:
                metadata:
                  labels:
                    task: monitoring
                    k8s-app: grafana
                spec:
                  containers:
                  - name: grafana
                    image: k8s.gcr.io/heapster-grafana-amd64:v5.0.4
                    ports:
                    - containerPort: 3000
                      protocol: TCP
                    volumeMounts:
                    - mountPath: /etc/ssl/certs
                      name: ca-certificates
                      readOnly: true
                    - mountPath: /var
                      name: grafana-storage
                    env:
                    - name: INFLUXDB_HOST
                      value: monitoring-influxdb
                    - name: GF_SERVER_HTTP_PORT
                      value: "3000"
                      # The following env variables are required to make Grafana accessible via
                      # the kubernetes api-server proxy. On production clusters, we recommend
                      # removing these env variables, setup auth for grafana, and expose the grafana
                      # service using a LoadBalancer or a public IP.
                    - name: GF_AUTH_BASIC_ENABLED
                      value: "false"
                    - name: GF_AUTH_ANONYMOUS_ENABLED
                      value: "true"
                    - name: GF_AUTH_ANONYMOUS_ORG_ROLE
                      value: Admin
                    - name: GF_SERVER_ROOT_URL
                      # If you're only using the API Server proxy, set this value instead:
                      # value: /api/v1/namespaces/kube-system/services/monitoring-grafana/proxy
                      value: /
                  volumes:
                  - name: ca-certificates
                    hostPath:
                      path: /etc/ssl/certs
                  - name: grafana-storage
                    emptyDir: {}
            ---
            apiVersion: v1
            kind: Service
            metadata:
              labels:
                # For use as a Cluster add-on (https://github.com/kubernetes/kubernetes/tree/master/cluster/addons)
                # If you are NOT using this as an addon, you should comment out this line.
                kubernetes.io/cluster-service: 'true'
                kubernetes.io/name: monitoring-grafana
              name: monitoring-grafana
              namespace: kube-system
            spec:
              # In a production setup, we recommend accessing Grafana through an external Loadbalancer
              # or through a public IP.
              # type: LoadBalancer
              # You could also use NodePort to expose the service at a randomly-generated port
              # type: NodePort
              ports:
              - port: 80
                targetPort: 3000
              selector:
                k8s-app: grafana
              type: NodePort
            EOF

            通过kubectl apply 更新grafana

            kubectl  apply -f grafana.yaml

            查看grafana是否部署成功

            kubectl get pods -n kube-system

            显示如下,说明部署成功

              monitoring-grafana-7d7f6cf5c6-vrxw9   1/1     Running   0          3h51m

              查看grafana的service
              kubectl get svc -n kube-system

              显示如下:

                monitoring-grafana   NodePort    10.111.173.47    <none>        80:31044/TCP             3h54m

                上面可以看到grafana暴露的宿主机端口是31044

                我们访问k8s集群的master节点ip:31044即可访问到grafana的web界面

                Grafan界面接入prometheus数据源

                1)登陆grafana,在浏览器访问

                192.168.0.6:31044

                账号密码都是admin

                可看到如下界面:


                2)配置grafana界面:
                开始配置grafana的web界面:
                选择Create your first data source

                出现如下

                Name: Prometheus

                Type: Prometheus

                HTTP 处的URL写 如下:


                http://prometheus.monitor-sa.svc:9090

                配置好的整体页面如下:

                点击左下角Save & Test,出现如下Data source is working,说明prometheus数据源成功的被grafana接入了

                导入监控模板,可在如下链接搜索
                https://grafana.com/dashboards?dataSource=prometheus&search=kubernetes
                也可直接导入node_exporter.json监控模板,这个可以把node节点指标显示出来

                node_exporter.json在百度网盘地址如下:

                  链接:https://pan.baidu.com/s/1vF1kAMRbxQkUGPlZt91MWg 
                  提取码:kyd6

                  还可直接导入docker_rev1.json,可以把容器相关的数据展示出来
                  docker_rev1.json在百度网盘地址如下:


                    链接:https://pan.baidu.com/s/17o_nja5N2R-g9g5PkJ3aFA 
                    提取码:vinv

                    怎么导入监控模板,按如下步骤

                    上面Save & Test测试没问题之后,就可以返回Grafana主页面

                    点击左侧+号下面的Import,出现如下界面

                    选择Upload json file,出现如下

                    选择一个本地的json文件,我们选择的是上面让大家下载的node_exporter.json这个文件,选择之后出现如下

                    注:箭头标注的地方Name后面的名字是node_exporter.json定义的

                    Prometheus后面需要变成Prometheus,然后再点击Import,就可以出现如下界面:

                    导入docker_rev1.json监控模板,步骤和上面导入node_exporter.json步骤一样,导入之后显示如下:

                    安装配置kube-state-metrics组件

                    kube-state-metrics是什么?

                    kube-state-metrics通过监听API Server生成有关资源对象的状态指标,比如Deployment、Node、Pod,需要注意的是kube-state-metrics只是简单的提供一个metrics数据,并不会存储这些指标数据,所以我们可以使用Prometheus来抓取这些数据然后存储,主要关注的是业务相关的一些元数据,比如Deployment、Pod、副本状态等;调度了多少个replicas?现在可用的有几个?多少个Pod是running/stopped/terminated状态?Pod重启了多少次?我有多少job在运行中。

                    安装kube-state-metrics组件

                    1)创建sa,并对sa授权

                    在k8s的master1节点生成一个kube-state-metrics-rbac.yaml文件

                    cat > kube-state-metrics-rbac.yaml <<EOF
                    ---
                    apiVersion: v1
                    kind: ServiceAccount
                    metadata:
                      name: kube-state-metrics
                      namespace: kube-system
                    ---
                    apiVersion: rbac.authorization.k8s.io/v1
                    kind: ClusterRole
                    metadata:
                      name: kube-state-metrics
                    rules:
                    - apiGroups: [""]
                      resources: ["nodes", "pods", "services", "resourcequotas", "replicationcontrollers", "limitranges", "persistentvolumeclaims", "persistentvolumes", "namespaces", "endpoints"]
                      verbs: ["list", "watch"]
                    - apiGroups: ["extensions"]
                      resources: ["daemonsets", "deployments", "replicasets"]
                      verbs: ["list", "watch"]
                    - apiGroups: ["apps"]
                      resources: ["statefulsets"]
                      verbs: ["list", "watch"]
                    - apiGroups: ["batch"]
                      resources: ["cronjobs", "jobs"]
                      verbs: ["list", "watch"]
                    - apiGroups: ["autoscaling"]
                      resources: ["horizontalpodautoscalers"]
                      verbs: ["list", "watch"]
                    ---
                    apiVersion: rbac.authorization.k8s.io/v1
                    kind: ClusterRoleBinding
                    metadata:
                      name: kube-state-metrics
                    roleRef:
                      apiGroup: rbac.authorization.k8s.io
                      kind: ClusterRole
                      name: kube-state-metrics
                    subjects:
                    - kind: ServiceAccount
                      name: kube-state-metrics
                      namespace: kube-system
                    EOF

                    通过kubectl apply更新yaml文件

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

                    2)安装kube-state-metrics组件

                    在k8s的master1节点生成一个kube-state-metrics-deploy.yaml文件

                    cat > kube-state-metrics-deploy.yaml <<EOF
                    apiVersion: apps/v1
                    kind: Deployment
                    metadata:
                      name: kube-state-metrics
                      namespace: kube-system
                    spec:
                      replicas: 1
                      selector:
                        matchLabels:
                          app: kube-state-metrics
                      template:
                        metadata:
                          labels:
                            app: kube-state-metrics
                        spec:
                          serviceAccountName: kube-state-metrics
                          containers:
                          - name: kube-state-metrics
                    #        image: gcr.io/google_containers/kube-state-metrics-amd64:v1.3.1
                            image: quay.io/coreos/kube-state-metrics:v1.9.0
                            ports:
                            - containerPort: 8080
                    EOF

                    通过kubectl apply更新yaml文件

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

                    查看kube-state-metrics是否部署成功

                    kubectl get pods -n kube-system

                    显示如下,看到pod处于running状态,说明部署成功

                      kube-state-metrics-79c9686b96-4njrs   1/1     Running   0          76s


                      相关实践学习
                      通过Ingress进行灰度发布
                      本场景您将运行一个简单的应用,部署一个新的应用用于新的发布,并通过Ingress能力实现灰度发布。
                      容器应用与集群管理
                      欢迎来到《容器应用与集群管理》课程,本课程是“云原生容器Clouder认证“系列中的第二阶段。课程将向您介绍与容器集群相关的概念和技术,这些概念和技术可以帮助您了解阿里云容器服务ACK/ACK Serverless的使用。同时,本课程也会向您介绍可以采取的工具、方法和可操作步骤,以帮助您了解如何基于容器服务ACK Serverless构建和管理企业级应用。 学习完本课程后,您将能够: 掌握容器集群、容器编排的基本概念 掌握Kubernetes的基础概念及核心思想 掌握阿里云容器服务ACK/ACK Serverless概念及使用方法 基于容器服务ACK Serverless搭建和管理企业级网站应用
                      相关文章
                      |
                      16天前
                      |
                      Prometheus 运维 监控
                      智能运维实战:Prometheus与Grafana的监控与告警体系
                      【10月更文挑战第26天】Prometheus与Grafana是智能运维中的强大组合,前者是开源的系统监控和警报工具,后者是数据可视化平台。Prometheus具备时间序列数据库、多维数据模型、PromQL查询语言等特性,而Grafana支持多数据源、丰富的可视化选项和告警功能。两者结合可实现实时监控、灵活告警和高度定制化的仪表板,广泛应用于服务器、应用和数据库的监控。
                      90 3
                      |
                      17天前
                      |
                      Prometheus 监控 Cloud Native
                      基于Docker安装Grafana和Prometheus
                      Grafana 是一款用 Go 语言开发的开源数据可视化工具,支持数据监控和统计,并具备告警功能。通过 Docker 部署 Grafana 和 Prometheus,可实现系统数据的采集、展示和告警。默认登录用户名和密码均为 admin。配置 Prometheus 数据源后,可导入主机监控模板(ID 8919)进行数据展示。
                      51 2
                      |
                      15天前
                      |
                      Prometheus 运维 监控
                      智能运维实战:Prometheus与Grafana的监控与告警体系
                      【10月更文挑战第27天】在智能运维中,Prometheus和Grafana的组合已成为监控和告警体系的事实标准。Prometheus负责数据收集和存储,支持灵活的查询语言PromQL;Grafana提供数据的可视化展示和告警功能。本文介绍如何配置Prometheus监控目标、Grafana数据源及告警规则,帮助运维团队实时监控系统状态,确保稳定性和可靠性。
                      80 0
                      |
                      2月前
                      |
                      存储 Prometheus 监控
                      在Ubuntu系统上安装与配置Prometheus的步骤
                      通过以上步骤,您应该已经成功在Ubuntu系统上安装并配置了Prometheus。您现在可以开始使用Prometheus收集和分析您的系统和应用程序的指标数据了。
                      166 1
                      |
                      3月前
                      |
                      Prometheus 监控 Cloud Native
                      自定义grafana_table(数据源Prometheus)
                      综上所述,自定义 Grafana 表格并将 Prometheus 作为数据源的关键是理解 PromQL 的查询机制、熟悉 Grafana 面板的配置选项,并利用 Grafana 强大的转换和自定义功能使数据展示更为直观和有洞见性。随着对这些工具更深入的了解,您将可以创建出更高级的监控仪表盘,以支持复杂的业务监控需求。
                      271 1
                      |
                      3月前
                      |
                      Prometheus 监控 Cloud Native
                      prometheus学习笔记之Grafana安装与配置
                      prometheus学习笔记之Grafana安装与配置
                      |
                      3月前
                      |
                      Prometheus 监控 数据可视化
                      Grafana 插件生态系统:扩展你的监控能力
                      【8月更文第29天】Grafana 是一个流行的开源平台,用于创建和共享统计数据的仪表板和可视化。除了内置的支持,Grafana 还有一个强大的插件生态系统,允许用户通过安装插件来扩展其功能。本文将介绍一些 Grafana 社区提供的插件,并探讨它们如何增强仪表盘的功能性。
                      244 1
                      |
                      3月前
                      |
                      存储 Prometheus 监控
                      Grafana 与 Prometheus 集成:打造高效监控系统
                      【8月更文第29天】在现代软件开发和运维领域,监控系统已成为不可或缺的一部分。Prometheus 和 Grafana 作为两个非常流行且互补的开源工具,可以协同工作来构建强大的实时监控解决方案。Prometheus 负责收集和存储时间序列数据,而 Grafana 则提供直观的数据可视化功能。本文将详细介绍如何集成这两个工具,构建一个高效、灵活的监控系统。
                      397 1
                      |
                      3月前
                      |
                      Prometheus 监控 Cloud Native
                      Spring Boot 性能护航!Prometheus、Grafana、ELK 组合拳,点燃数字化时代应用稳定之火
                      【8月更文挑战第29天】在现代软件开发中,保证应用性能与稳定至关重要。Spring Boot 作为流行的 Java 框架,结合 Prometheus、Grafana 和 ELK 可显著提升监控与分析能力。Prometheus 负责收集时间序列数据,Grafana 将数据可视化,而 ELK (Elasticsearch、Logstash、Kibana)则管理并分析应用日志。通过具体实例演示了如何在 Spring Boot 应用中集成这些工具:配置 Prometheus 获取度量信息、Grafana 显示结果及 ELK 分析日志,从而帮助开发者快速定位问题,确保应用稳定高效运行。
                      105 1
                      |
                      3月前
                      |
                      存储 Prometheus 监控
                      Prometheus 的报警机制:Alertmanager 的配置与使用
                      【8月更文第29天】Prometheus 是一个非常强大的监控系统,它不仅能够收集和存储时间序列数据,还能通过 Alertmanager 提供灵活的报警机制。Alertmanager 负责接收 Prometheus 发送的警报,并根据配置的规则执行相应的通知动作。本文将详细介绍如何配置 Alertmanager 以及如何使用它来实现基于 Prometheus 指标的报警通知。
                      597 0