精华内容
下载资源
问答
  • Prometheus 监控

    2018-09-04 21:09:25
    prometheus-2.3.2.linux-amd64.tar.gz 普罗米修斯,监控
  • prometheus监控

    2021-01-17 14:46:41
    prometheus采用服务器端加客户端的方式实现整个监控过程,服务器端安装prometheus服务,客户端安装exporter服务,每隔指定的时间(可配置)服务器端会自动向客户端索要监控数据,然后存储到本地。 1. 下载prometheus...

    一. Prometheus安装

    监控原理:

    prometheus采用服务器端加客户端的方式实现整个监控过程,服务器端安装prometheus服务,客户端安装exporter服务,每隔指定的时间(可配置)服务器端会自动向客户端索要监控数据,然后存储到本地。

    1. 下载prometheus安装包

    下载地址

    2.安装

    将安装包上传到服务器

    tar xvfz prometheus-*.tar.gz
    cd prometheus-*
    

    3.启动prometheus

    ./prometheus --config.file=prometheus.yml 
    #如果想在后台运行可以执行nohup ./prometheus --config.file=prometheus.yml &
    

    至此已经可以访问http://192.168.101.251:9090/访问prometheus页面
    在这里插入图片描述
    选择status->targets查看当前监控了哪些目标机器,目前还没有安装exporter,但默认会监控prometheus服务器
    在这里插入图片描述
    至此prometheus服务器安装完成,想要监控其它服务器还需要在目标服务器上安装exporter客户端。

    4.exporter

    exporter安装

    在prometheus下载地址就可以找一些exporter。下载exporter然后上传到需要被监控的服务器上,比如我下载的是node_exporter,执行以下命令安装

    tar xvfz node_exporter*
    cd node_exporter*
    ./node_exporter
    #如果想在后台运行可以执行nohup ./node_exporter &
    

    在prometheus中配置exporter

    此时目标服务器的exporter服务已经启动,但prometheus还不会向这台被监控服务器索要监控数据,还需要在prometheus.yml中配置。

    A.prometheus.yml配置讲解
    # my global config
    global:
      scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
      evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
      # scrape_timeout is set to the global default (10s).
    # Alertmanager configuration
    alerting:
      alertmanagers:
     - static_configs:
        - targets:
          # - alertmanager:9093
    # Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
    rule_files:
      # - "first_rules.yml"
      # - "second_rules.yml"
    # A scrape configuration containing exactly one endpoint to scrape:
    # Here it's Prometheus itself.
    scrape_configs:
      # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
     - job_name: 'prometheus'
        # metrics_path defaults to '/metrics'
        # scheme defaults to 'http'.
        static_configs:
        - targets: ['localhost:9090']
    

    以上是默认的配置文件内容,这里只介绍本文需要修改的配置,其它内容暂不详细介绍,有需要可以到网上搜索。
    global:该模块定义一些global参数
    scrape_interval:每隔多久时间向被监控服务器索要一次监控数据,这里配置是15s
    evaluation_interval:每隔多久重新扫描rule文件,也就是后面rule_files里面配置的yml文件(实验发现,修改了rule配置文件后Prometheus并不会动态刷新,重启Prometheus后才能生效,修改方法参照prometheus刷新配置
    altering:该模块定义告警方式
    rule_files:该模块定义监控告警细节
    scrape_configs:这个模块是配置需要监控哪些服务器,也就是我们新安装了exporter之后需要修改这个模块下的配置
    job_name:定义一个名字,这个名字在prometheus页面的Status->Targets里面会显示,后面会讲到
    targets:目标机器
    labels:自定义属性

    B.添加exporter信息

    比如我mysql的服务器(192.168.101.250)已经安装完exporter,接下来需要在prometheus.yml中添加以下配置

     - job_name: 'mysql_server'
        static_configs:
        - targets: ['192.168.101.250:9100']
          labels:   #添加自定义属性,用于metric查询,后面会讲到
            role: mysql #名字和值都可以随便取,但是需要满足命名规则
            server_type: linux
    

    最后我的配置文件是这样的

    global:
      scrape_interval:     15s 
      evaluation_interval: 15s 
    alerting:
      alertmanagers:
     - static_configs:
        - targets:
    rule_files:
    scrape_configs:
     - job_name: 'prometheus'
        static_configs:
        - targets: ['localhost:9090']
     - job_name: 'mysql_server'
        static_configs:
        - targets: ['192.168.101.250:9100']
          labels:
            role: mysql
            server_type: linux
    ~                              
    

    然后重启prometheus,访问prometheus页面http://192.168.101.251:9090/targets可以看到如下结果
    在这里插入图片描述
    到此这台新的mysql机器已经添加到了被监控服务器列表中,但是如果我的mysql服务器有多台,上面这种方式添加可阅读性不是很强,我们可以将这些配置写入到一个新的yml文件中,然后在prometheus.yml中指定新创建的yml文件

    创建config文件夹和mysql.yml文件
    mkdir config
    cd config
    touch mysql.yml
    
    mysql.yml文件内容如下:
    - targets:
      - 192.168.101.250:9100
      - 192.168.101.249:9100
      labels:
        role: mysql
        server_type: linux
    
    prometheus.yml修改如下
    #修改对应的mysql_server
     - job_name: 'mysql_server'
        file_sd_configs:
        - files:
          - config/mysql.yml #新创建的mysql.yml文件
    

    此时访问prometheus页面看到如下结果,因为我只是介绍这个功能,并没有在192.168.101.249这台机器上安装exporter,所以看到这台机器的状态是down
    在这里插入图片描述

    查看exporter具体监控了哪些服务器指标(metric)

    访问http://192.168.101.251:9090/graph,下面的下拉列表中的值都是监控指标,这些值也叫metric,在查询时使用
    在这里插入图片描述

    查看每个监控指标的意义

    访问http://192.168.101.251:9090/ 进入Status->Targets,然后点击Endpoint下面的链接,可以看到如下页面,该页面详细列出了所有监控指标已经他们的含义。
    在这里插入图片描述
    这些metric是由exporter决定的,安装不同类型的exporter看到的metric不同。

    查询演示

    接下来我在prometheus服务器上也安装一个exporter,然后做一些简单的查询演示
    添加新的配置后,配置如下,然后重启prometheus服务

    scrape_configs:
     - job_name: 'prometheus'
        static_configs:
        - targets: ['localhost:9090']
     - job_name: 'mysql_server'
        static_configs:
        - targets: ['192.168.101.250:9100']
          labels:
            role: mysql
            server_type: linux
     - job_name: 'nginx_server'
        static_configs:
        - targets: ['192.168.101.251:9100']
          labels:
            role: nginx
            server_type: linux
    

    查看页面显示正常
    在这里插入图片描述
    回到Graph查询页面,

    • 查询有多少被监控服务器
      查询语句:up
      在这里插入图片描述
      如果只想看总数,查询语句:count(up)或者count(up) by (instance,role)
    • 查询有多少linux机器
      查询语句:up{server_type=~“linux”}
      在这里插入图片描述
    • 查询服务器uname相关信息
      查询语句:node_uname_info
    • 查询服务器内存相关情况
      查询语句:node_memory_MemTotal_bytes

    5.告警

    前面我们已经知道了怎么将新服务器加入到监控系统中,以及怎么查看监控指标,但是还没有定义什么情况下指标异常,以及异常后怎么告警。关于告警本文暂不做介绍,有需要可以在网上查,也可以使用Grafana配置prometheus数据源实现监控和报警。

    展开全文
  • Prometheus监控

    2019-03-18 14:12:00
    Prometheus介绍 (1)Prometheus由来 普罗米修斯的灵感来自于谷歌的Borgmon。它最初是由马特·t·普劳德(Matt T. Proud)作为一个研究项目开发的,普劳德曾是谷歌(google)的一名雇员。在普劳德加入SoundCloud之后,他与...

    Prometheus介绍

    (1)Prometheus由来

    普罗米修斯的灵感来自于谷歌的Borgmon。它最初是由马特·t·普劳德(Matt T. Proud)作为一个研究项目开发的,普劳德曾是谷歌(google)的一名雇员。在普劳德加入SoundCloud之后,他与另一位工程师朱利叶斯•沃尔兹(Julius Volz)合作, 认真开发普罗米修斯。其他开发人员也参与了这项工作,并继续在SoundCloud内部进行开发,最终于2015年1月公开 发布。


    (2)Prometheus架构

    Prometheus架构

    • Prometheus Server:用于收集和存储时间序列数据。
    • PushGateway:主要用于短期的 jobs。由于这类 jobs 存在时间较短,可能在 Prometheus 来 pull 之前就消失了。为此,这次 jobs 可以直接向 Prometheus server 端push metrics。
    • Exporters:Exporter是Prometheus的一类数据采集组件的总称。它负责从目标处搜集数据,并将其转化为Prometheus支持的格式。与传统的数据采集组件不同的是,它并不向中央服务器发送数据,而是等待中央服务器主动前来抓取。
    • Alertmanager:从 Prometheus server 端接收到 alerts 后,会进行去除重复数据,分组,并路由到对收的接受方式,发出报警。常见的接收方式有:电子邮件,pagerduty,OpsGenie, webhook 等。

    (3)Prometheus基本原理

    Prometheus的基本原理是通过HTTP协议周期性抓取被监控组件的状态,任意组件只要提供对应的HTTP接口就可以接入监控。不需要任何SDK或者其他的集成过程。这样做非常适合做虚拟化环境监控系统,比如VM、Docker、Kubernetes等。输出被监控组件信息的HTTP接口被叫做exporter 。目前互联网公司常用的组件大部分都有exporter可以直接使用,比如Varnish、Haproxy、Nginx、MySQL、Linux系统信息(包括磁盘、内存、CPU、网络等等)。


    Prometheus安装

    Prometheus Server端安装

    1.下载:
    wget https://github.com/prometheus/prometheus/releases/download/v2.8.0/prometheus-2.8.0.linux-amd64.tar.gz
    tar xf prometheus-2.8.0.linux-amd64.tar.gz -C /usr/local/
    mv /usr/local/prometheus-2.8.0.linux-amd64 /usr/local/prometheus
    mkdir /usr/local/prometheus/data     #数据存放目录
    2.使用screen来管理Prometheus
    yum -y install screen
    screen     #打开一个新的窗口
    /usr/local/prometheus/prometheus --web.listen-address="0.0.0.0:9090" --web.read-timeout=5m --web.max-connections=10 --storage.tsdb.retention=15d  --storage.tsdb.path="data/"   --query.max-concurrency=20   --query.timeout=2m   #C-a d  退出窗口,screen -ls查看后台进程
    3.启动参数说明
    --web.read-timeout=5m #请求链接的最⼤等待时间,防⽌太多的空闲链接 占⽤资源
    --web.max-connections=512 #最⼤链接数
    --storage.tsdb.retention=15d  #prometheus开始采集监控数据后,对于保留期限的设置
    --storage.tsdb.path="data/"  #存储数据路径,wal目录保存着按照⼀定间隔的内存中近期的监控数据
    --query.timeout=2m   #防⽌单个⽤户执⾏过慢的查询
    --query.max-concurrency=20  #允许多少用户同时查询
    注:prometheus 对系统时间⾮常敏感,⼀定要时刻保证系统时间同步,不然曲线是乱的

    Prometheus Client端安装 node_export插件

    wget https://github.com/prometheus/node_exporter/releases/download/v0.17.0/node_exporter-0.17.0.linux-amd64.tar.gz
    tar xf node_exporter-0.17.0.linux-amd64.tar.gz -C /usr/local/
    mv /usr/local/node_exporter-0.17.0.linux-amd64 /usr/local/node_exporter
    2.使用screen来管理Prometheus
    yum -y install screen
    screen  #打开一个新的窗口
    ./node_exporter --collector.systemd

    Prometheus配置文件说明

    # 全局配置
    global:
      scrape_interval:     15s   # 多长时间抓取一次数据
      evaluation_interval: 15s   # 多长时间评估一次报警规则
      scrape_timeout:      10s   # 每次抓取数据的超时时间
    # 告警配置
    alerting:
      ...  #这里我们不使用prometheus自带的告警,使用无需关注
    # 告警规则
    rule_files:
      ...  #制定了规则所在的位置,prometheus可以根据这个配置加载规则
    # 定义Promeetheus监控那些资源
    scrape_configs:
      - job_name: 'prometheus'
        static_configs:
        - targets: ['localhost:9090']   #监控prometheus本身的健康情况
    #添加客户端监控
      - job_name: 'test'
        static_configs:
        - targets: ['jenkins:9100','gitlab:9100']   #此处主机名需要在/etc/hosts上定义。

    注: 修改完配置文件需要重启prometheus, web上输入PrometheusIP:Prot查看页面。
    Prometheus主页面

    Pushgateway

    (1) pushgateway介绍

    Pushgateway是Prometheus 生态中一个重要工具,使用它的原因主要是:

    1. Prometheus 采用 pull 模式,可能由于不在一个子网或者防火墙原因,导致 Prometheus 无法直接拉取各个 target 数据。
    2. 在监控业务数据的时候,需要将不同数据汇总, 由 Prometheus 统一收集。

    Pushgateway缺点:

    1. Prometheus拉取状态UP只能针对Pushgateway,无法做到对每个节点有效。
    2. 将多个节点数据汇总到pushgateway, 如果pushgateway宕机,受影响比多个target大。

    Pushgateway的客户端采用push方式将数据发送到服务端,Prometheus只需要到Pushgateway拉取数据即可。Pushgateway可以单独运⾏在任何节点上的插件(并不⼀定要在被监控客户端)

    (2) pushgateway安装

    wget http://github.com/prometheus/pushgateway/releases/download/v0.7.0/pushgateway-0.7.0.linux-amd64.tar.gz
    tar xf pushgateway-0.7.0.linux-amd64.tar.gz -C /usr/local/
    mv /usr/local/pushgateway-0.7.0.linux-amd64 /usr/local/pushgateway
    screen
    /usr/local/pushgateway/pushgateway

    (3) Prometheus配置文件引用pushgateway

    [root@nagios ~]# tail -3 /usr/local/prometheus/prometheus.yml
      - job_name: 'pushgateway'
        static_configs:
        - targets: ['localhost:9091']       
    #因为我将pushgateway装到了prometheus机器上所以使用的主机名是localhost,端口默认是9091。
    #需要重启prometheus。

    (4) 客户端自定义脚本推送数据到pushgateway

    我们来写一个监控客户端主机登陆用户数量的脚本,将数据推送到pushgateway
    [root@jenkins_test ~]# cat user_login.sh 
    #!/bin/bash
    count=$(w| awk 'NR==1{print $4}')
    label="Count_login_users"
    instance_name=$(hostname)
    echo "$label $count" | curl --data-binary @- http://192.168.18.213:9091/metrics/job/pushgateway/instance/$instance_name
    
    #job/pushgateway  推送到prometheus.yml的哪一个job⾥。
    #instance/$instance_name 推送后显⽰的机器名是什么。

    (5) 客户端定时推送数据

    编写的监控bash脚本是⼀次性执⾏的bash,我们需要按时间段反复执⾏,所以呢?⾃然就得结合contab了。但是crontab默认只能最短⼀分钟的间隔,如果希望⼩于⼀分钟的间隔15s,可以使用如下方法:
    
    [root@jenkins_test ~]# cat user_login.sh 
    #!/bin/bash
    for((i=1;i<=4;i++));
      do 
      count=$(w| awk 'NR==1{print $4}')
      label="Count_login_users"
      instance_name=$(hostname)
      echo "$label $count" | curl --data-binary @- http://192.168.18.213:9091/metrics/job/pushgateway/instance/$instance_name
      sleep 15        #等待15秒
    done
    
    [root@jenkins_test ~]# crontab -l
    * * * * * /bin/bash /root/user_login.sh  &>/dev/null

    (6) Prometheus页面查看数据

    1582262-20190318155319726-496403319.png

    Grafana

    (1) Grafana介绍

    Grafana是一个跨平台的开源的度量分析和可视化工具,可以通过将采集的数据查询然后可视化的展示,并及时通知。它主要有以下几个特点:

    • 展示方式:快速灵活的客户端图表,面板插件有许多不同方式的可视化指标和日志,官方库中具有丰富的仪表盘插件,比如热图、折线图、图表等多种展示方式;
    • 数据源:Graphite,InfluxDB,OpenTSDB,Prometheus,Elasticsearch,CloudWatch和KairosDB等;
    • 通知提醒:4.0之后的添加了报警功能,可以以可视方式定义最重要指标的警报规则,Grafana将不断计算并发送通知,在数据达到阈值时通过Slack、PagerDuty等获得通知;
    • 混合展示:在同一图表中混合使用不同的数据源,可以基于每个查询指定数据源,甚至自定义数据源;
    • 注释:使用来自不同数据源的丰富事件注释图表,将鼠标悬停在事件上会显示完整的事件元数据和标记;

    (2) Grafana安装(安装特别简单)

    wget https://dl.grafana.com/oss/release/grafana-6.0.1-1.x86_64.rpm  #最新版本
    yum localinstall -y grafana-6.0.1-1.x86_64.rpm
    #安装饼图插件
    cd /var/lib/grafana/plugins/
    git clone https://github.com/grafana/piechart-panel.git
    #修改配置文件
    vim /etc/grafana/grafana.ini  
    root_url = http://192.168.18.213:3000    #将localhost改为grafana服务端地址
    #启动Grafana
    systemctl start grafana-server.service
    systemctl enable grafana-server.service
    

    注: 默认运行在3000端口,web上输入IP:Prot查看页面,初始账号密码为admin/admin。
    Grafana主页面

    (3) Grafana配置连接Prometheus数据源

    连接Prometheus数据源

    (4) Grafana导入仪表盘

    导入仪表盘
    编辑仪表盘属性
    编辑属性

    (5) 查看页面展示效果

    页面效果

    转载于:https://www.cnblogs.com/SleepDragon/p/10551884.html

    展开全文
  • 搭建流程:1、docker部署prometheus监控服务2、docker部署alertmanager告警服务3、整合prometheus和alertmanager4、Java Springboot开发自定义监控指标5、prometheus收集自定义监控指标6、配置alertmanager告警规则7...

    搭建流程:

    1、docker部署prometheus监控服务
    2、docker部署alertmanager告警服务
    3、整合prometheus和alertmanager
    4、Java Springboot开发自定义监控指标
    5、prometheus收集自定义监控指标
    6、配置alertmanager告警规则
    7、alertmanager抓取prometheus的监控指标,并post请求发送告警

    linux安装docker

    #安装docker
    sudo yum -y install docker
    #安装成功后启动docker服务
    sudo systemctl start docker
    #查看docker状态
    systemctl status docker

    6fc03b70b1a0e606850c476dd15eefba.png

    docker部署prometheus监控服务

    1、拉取prometheus最新的docker镜像

    docker pull prom/prometheus

    2、在/home目录下新建prometheus目录

    cd /home
    mkdir prometheus

    3、在/home/prometheus目录下添加prometheus.yml配置文件

    global:
    scrape_interval: 15s #收集数据的时间间隔
    scrape_timeout: 10s #收集数据的超时时间
    evaluation_interval: 15s #估算规则的默认周期 每15秒计算一次规则
    scrape_configs: #抓取配置列表
    - job_name: prometheus
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: /metrics #抓取指标请求路径,请求地址:http://localhost:9090/metrics
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - localhost:9090 #localhost为服务器ip地址

    4、docker运行prometheus服务

    #运行prometheus,端口号为9090,将上面添加的prometheus.yml配置文件挂载到prometheus容器中,容器名称为prometheus
    docker run -d -p 9090:9090 -v /home/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml --name prometheus prom/prometheus

    5、查看prometheus运行情况

    #查看docker容器列表
    docker ps
    #查看prometheus启动日志
    docker logs prometheus

    在浏览器中输入http://ip:9090访问prometheus

    754e35ca465667a99a235fe1e12e97de.png

    docker部署alertmanager告警服务

    1、拉取alertmanager最新镜像

    docker pull prom/alertmanager

    2、在/home/prometheus目录下添加alertmanager.yml文件

    global: #全局配置
    resolve_timeout: 5m #收集数据的超时时间
    route: #告警路由
    group_by: ['alertname'] #标签名称,多个标签需要确保唯一性
    group_wait: 10s #发送警报的等待时间
    group_interval: 10s
    repeat_interval: 4h #发送告警的时间间隔,默认4h发送一次告警
    receiver: 'web.hook' #接收者名称配置,对应下面receivers.name的值
    receivers: #告警接受者配置
    - name: 'web.hook' #接收者名称,可以随意配置
    webhook_configs: #采用请求接口的方式发送告警,将告警信息推送给具体的接口
    - url: 'http://localhost:80/alert' #webhook_configs.url表示通过post请求将采集到的json格式数据传到对应的接口中

    通过webhook_configs发送告警时,其为post请求,请求参数如下,其中annotations中的参数是在告警规则(后续会提到)中自定义的,labels中的参数是收集到的指标metrics中的参数以及自定义的labels参数

    {
    "receiver":"web\.hook",
    "status":"firing",
    "alerts":[
    {
    "status":"firing",
    "labels":{
    "alertname":"alert-test-1",
    "groups":"ops",
    "instance":"106.54.245.44:8080",
    "job":"springboot",
    "level":"critical",
    "name":"test-prometheus",
    "service":"SpringBoot"}
    ,
    "annotations":{
    "summary":"指标值大于5监控",
    "title":"spring_boot_prometheus_test指标值大于10"}
    ,
    "startsAt":"2020-06-18T02:00:37.012931223Z",
    "endsAt":"0001-01-01T00:00:00Z",
    "generatorURL":"http://6be9a8b434ae:9090/graph?g0.expr=spring_boot_prometheus_test%7Bname%3D%22test-prometheus%22%2Cservice%3D%22SpringBoot%22%7D+%3E%3D+5&g0.tab=1",
    "fingerprint":"07038d07a4872bf4"}
    ]
    ,
    "groupLabels":{
    "alertname":"alert-test-1"}
    ,
    "commonLabels":{
    "alertname":"alert-test-1",
    "groups":"ops",
    "instance":"106.54.245.44:8080",
    "job":"springboot",
    "level":"critical",
    "name":"test-prometheus",
    "service":"SpringBoot"}
    ,
    "commonAnnotations":{
    "summary":"指标值大于5监控",
    "title":"spring_boot_prometheus_test指标值大于10"}
    ,
    "externalURL":"http://eb33993e377c:9093",
    "version":"4",
    "groupKey":"{}:{alertname="alert-test-1"}",
    "truncatedAlerts":0}

    3、启动alertmanager服务

    #指定9093端口,将上面新建的alertmanager.yml挂载到容器中
    docker run -d -p 9093:9093 -v /home/prometheus/alertmanager.yml:/etc/alertmanager/alertmanager.yml --name alertmanager prom/alertmanager

    4、查看alertmanager运行情况

    #查看docker容器列表
    docker ps
    #查看prometheus启动日志
    docker logs alertmanager

    在浏览器中输入http://ip:9093/#/status访问alertmanager,查看alertmanager配置是否生效

    e3aa3af873a613dbf70b1347e574c394.png

    Prometheus整合Alertmanager

    1、在/homt/prometheus/prometheus.yml文件中添加alert相关的配置

    global:
    scrape_interval: 15s #收集数据的时间间隔
    scrape_timeout: 10s #收集数据的超时时间
    evaluation_interval: 15s #估算规则的默认周期 每15秒计算一次规则
    scrape_configs: #抓取配置列表
    - job_name: prometheus
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: /metrics #抓取指标请求路径,请求地址:http://localhost:9090/metrics
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - localhost:9090 #localhost为服务器ip地址
    alerting: #告警配置
    alertmanagers:
    - static_configs:
    - targets: [localhost:9093]
    scheme: http

    2、重启prometheus,使配置生效

    #prometheus为docker容器名称
    docker restart prometheus

    访问http://ip:9090/config可查看配置是否生效

    f7e303d6e34ab33250687b50c4bb07d1.png

    SpringBoot自定义监控指标

    1、新建一个maven项目,使用SpringBoot框架完成java代码,pom文件添加prometheus的jar包,github代码仓库地址:https://github.com/ItGeneral/prometheus-demo

    <dependencies>
    <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
    <version>2.2.1.RELEASEversion>
    dependency>
    <dependency>
    <groupId>io.prometheusgroupId>
    <artifactId>simpleclient_servletartifactId>
    <version>0.9.0version>
    dependency>
    dependencies>

    2、新增MetricsRegister接口,生成一个名为spring_boot_prometheus_test的指标

    import io.prometheus.client.Gauge;
    import org.springframework.stereotype.Component;

    @Component
    public class MetricsRegister {

    private static final Gauge GAUGE = Gauge.build()
    .labelNames("name", "service")
    .name("spring_boot_prometheus_test").help("test").register();

    /**
    * 在内存中生成一个名为spring_boot_prometheus_test的指标
    * 标签有name和service
    */

    public void register(){
    GAUGE.labels("test-prometheus", "SpringBoot").set(10);
    }
    }

    3、添加入口类Application

    @SpringBootApplication
    public class PrometheusApplication {

    public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(PrometheusApplication.class, args);
    MetricsRegister metricsRegister = context.getBean(MetricsRegister.class);
    metricsRegister.register();
    }

    /**
    * 配置一个servlet,将服务中的生成的指标通过http://localhost:8080/{context-path}/metrics暴露出去
    * @return
    */

    @Bean
    public ServletRegistrationBeanservletRegistrationBean() {
    MetricsServlet metricsServlet = new MetricsServlet();
    return new ServletRegistrationBean<>(metricsServlet, "/metrics");
    }
    }

    4、配置application.yml文件

    server:
    servlet:
    context-path: /prometheus-demo
    port: 80

    启动项目,访问http://localhost:80/prometheus-demo/metrics,即可在页面上看到指标内容

    6f961b5962e80823bf0348bd252a10c2.png

    # HELP spring_boot_prometheus_test test
    # TYPE spring_boot_prometheus_test gauge
    spring_boot_prometheus_test{name="test-prometheus",service="SpringBoot",} 10.0

    Prometheus收集自定义指标

    1、修改/home/prometheus/prometheus.yml内容

    global:
    scrape_interval: 15s #收集数据的时间间隔
    scrape_timeout: 10s #收集数据的超时时间
    evaluation_interval: 15s #估算规则的默认周期 每15秒计算一次规则
    scrape_configs: #抓取配置列表
    - job_name: prometheus
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: /metrics #抓取指标请求路径,请求地址:http://localhost:9090/metrics
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - localhost:9090 #localhost为服务器ip地址
    - job_name: springboot #配置springboot自定义指标
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: /prometheus-demo/metrics #此处配置为/{context-path}/metrics,上述context-path为prometheus-demo
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - ip:80 #ip地址为SpringBoot项目运行的机器ip,80为SpringBoot服务端口

    需确保springboot服务机器和prometheus服务机器能相互ping通,否则将会采集不到对应的指标
    2、重启prometheus使配置生效

    docker restart prometheus

    访问http://ip:9090/config查看配置是否生效

    afd4fb5235422030602795064868aa65.png

    访问http://ip:9090/graph查看是否收集到名为spring_boot_prometheus_test的指标

    8e53733bcef2b6640015feff60e4139f.png

    配置告警规则

    1、在/home/prometheus目录下,添加alert_rule.yml文件

    groups:
    - name: alert-test #告警名称
    rules:
    - alert: alert-test
    expr: spring_boot_prometheus_test{name="test-prometheus",service="SpringBoot"} < 5
    for: 3m
    labels: #自定义label标签
    groups: ops
    level: warning
    annotations:
    summary: spring_boot_prometheus_test指标监控
    title: spring_boot_prometheus_test指标值小于5
    - name: alert-test-1
    rules:
    - alert: alert-test-1
    expr: spring_boot_prometheus_test{name="test-prometheus",service="SpringBoot"} >= 5
    for: 3m #每
    3分钟搜集一次
    labels:
    groups: ops
    level: critical
    annotations:
    summary: 指标值大于5监控
    title: spring_boot_prometheus_test指标值大于10

    2、修改/home/prometheus/prometheus.yml配置,添加规则文件

    global:
    scrape_interval: 15s #收集数据的时间间隔
    scrape_timeout: 10s #收集数据的超时时间
    evaluation_interval: 15s #估算规则的默认周期 每15秒计算一次规则
    scrape_configs: #抓取配置列表
    - job_name: prometheus
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: /metrics #抓取指标请求路径,请求地址:http://localhost:9090/metrics
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - localhost:9090 #localhost为服务器ip地址
    - job_name: springboot #配置springboot自定义指标
    scrape_interval: 15s
    scrape_timeout: 10s
    metrics_path: prometheus-demo/metrics #此处配置为/{context-path}/metrics,上述context-path为prometheus-demo
    scheme: http
    static_configs: #静态指定服务job地址
    - targets:
    - ip:80 #ip地址为SpringBoot项目运行的机器ip,80为SpringBoot服务端口
    rule_files:
    - "alert_rule.yml" #配置告警规则

    3、重新运行prometheus,使配置生效

    #停止当前正在运行的prometheus服务
    docker stop prometheus
    #删除名称为prometheus的服务,也可以不删,但是docker run时需要指定其他名称,不能再使用prometheus
    docker rm prometheus
    #运行prometheus,将alert_rule.yml也挂载到容器中
    docker run -d -p 9090:9090 -v /home/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml -v /home/prometheus/alert_rule.yml:/etc/prometheus/alert_rule.yml --name prometheus prom/prometheus

    访问http://ip:9090/rules查看规则文件配置是否生效

    50c998dedc2f1c297f286f3b0679ee28.png

    Alertmanager发送告警指标

    1、在上面的prometheus-demo服务中新增接口

    @RestController
    public class AlertController {
    @PostMapping(value = "/alert")
    public void receiveAlert(@RequestBody String json) {
    System.out.println(json);
    //此处可以根据接受到的告警信息,自定义通知操作,如发送邮件等
    }
    }

    prometheus-demo服务启动后,接口地址为:http://ip:80/prometheus-demo/alert/
    2、确保/home/prometheus/alertmanager.yml文件中配置正确的url地址,修改repeat_interval的值,使每1分钟发送一次告警

    global: #全局配置
    resolve_timeout: 5m #收集数据的超时时间
    route: #告警路由
    group_by: ['alertname'] #标签名称,多个标签需要确保唯一性
    group_wait: 10s #发送警报的等待时间
    group_interval: 10s
    repeat_interval: 1m #发送告警的时间间隔,默认4h发送一次告警
    receiver: 'web.hook' #接收者名称配置,对应下面receivers.name的值
    receivers: #告警接受者配置
    - name: 'web.hook' #接收者名称,可以随意配置
    webhook_configs: #采用请求接口的方式发送告警,将告警信息推送给具体的接口
    - url: 'http://ip:80/prometheus-demo/alert/' #配置正确的url地址

    3、重启alertmanager服务,使配置生效

    #alertmanager为docker容器名称
    docker restart alertmanager

    先访问http://ip:9090/alerts,查看prometheus是否根据告警规则收集到对应的告警内容

    5828e2ee62b39cb1425feca94d68fa9d.png

    在浏览器中输入http://ip:9093/#/status访问alertmanager,查看alertmanager配置是否生效

    0253dd4a0937df77a9c587547b128667.png

    4、查看告警推送结果

    05d486d798d5a842beca17c720fb191b.png

    推送结果请参考【docker部署alertmanager告警服务】中的json内容

    参考文献:

    https://prometheus.io/docs/prometheus/latest/configuration/configuration/

    展开全文
  • prometheus监控 指标是代表系统整体运行状况以及您认为对监视和警报或可观察性很重要的任何其他特定信息的主要方式 。 Prometheus是从2012年开始在SoundCloud上构建的领先的开源度量工具,收集和存储工具包。此后,...

    prometheus监控

    指标是代表系统整体运行状况以及您认为对监视和警报或可观察性很重要的任何其他特定信息的主要方式 Prometheus是从2012年开始在SoundCloud上构建的领先的开源度量工具,收集和存储工具包。此后,它从Cloud Native Computing Foundation 毕业 ,并成为Kubernetes监控的事实上的标准。 它已在以下内容中进行了详细介绍:

    但是,这些文章都没有集中讨论如何在Kubernetes上使用Prometheus。 本文:

    • 描述Prometheus架构和数据模型,以帮助您了解其工作原理和功能
    • 提供有关在Kubernetes集群中设置Prometheus以及如何使用它来监视集群和应用程序的教程

    建筑

    虽然了解Prometheus的工作原理对于有效使用它并不重要,但它可能会有所帮助,尤其是在您考虑将其用于生产时。 Prometheus文档提供了此图形以及有关Prometheus的基本元素以及各部分之间如何连接的详细信息。

    Prometheus architecture

    对于大多数用例,您应该了解Prometheus的三个主要组成部分:

    1. Prometheus 服务器抓取并存储指标。 请注意,它使用了持久层,该持久层是服务器的一部分,文档中未明确提及。 服务器的每个节点都是自治的,并且不依赖于分布式存储。 稍后,当我希望使用专用的时间序列数据库来存储Prometheus数据而不是依赖服务器本身时,将再次进行讨论。
    2. Web UI允许您访问,可视化和绘制存储数据的图表。 Prometheus提供了自己的UI,但是您也可以配置其他可视化工具,例如Grafana ,以使用PromQL(Prometheus查询语言)访问Prometheus服务器。
    3. Alertmanager从客户端应用程序(尤其是Prometheus服务器)发送警报。 它具有用于重复数据删除,分组和路由警报的高级功能,并且可以路由其他服务,例如PagerDuty和OpsGenie。

    理解Prometheus的关键是它从根本上依赖于从已定义的端点中刮取或拉取度量标准。 这意味着您的应用程序需要公开一个可以使用度量的端点,并指示Prometheus服务器如何对其进行爬网(下面的教程中对此进行了介绍)。 对于许多应用程序,有些导出器没有添加Web端点的简便方法,例如KafkaCassandra (使用JMX导出器)。

    资料模型

    Prometheus文档的“ 度量类型”部分。

    计数器和量规

    两种最简单的度量标准类型是countergauge 当开始使用Prometheus(或更一般地说是时间序列监视)时,这些是最容易理解的类型,因为很容易将它们连接到您可以想象的监视值,例如应用程序正在使用多少系统资源或多少事件。已处理。

    计数器是一个累积量度,代表一个单调递增的计数器,其值只能在重新启动时增加重置为零。例如,您可以使用计数器来代表已服务的请求数,已完成的任务或错误。”

    因为您不能减少计数器,所以它可以并且应该仅用于表示累积指标。

    量规是代表单个数值的指标,该数值可以任意地上下波动。量规通常用于测量值,例如[CPU]或当前内存使用情况,也用于可以上下波动的“计数”,例如并发请求数。”

    直方图和摘要

    Prometheus支持两种更复杂的度量标准类型: 直方图 摘要 由于它们都跟踪观察次数观察值的总和,因此这里有很多混淆的机会。 选择使用它们的原因之一是您需要计算观察值的平均值。 请注意,它们在数据库中创建了多个时间序列。 例如,它们各自创建带有_sum后缀的观测值的总和

    直方图对观测值(通常是请求持续时间或响应大小之类的东西)进行采样,并将其计数在可配置的存储桶中。它还提供所有观测值的总和。”

    这使它成为跟踪诸如延迟之类的事情的最佳人选,这些事情可能针对它定义了服务级别目标(SLO)。 文档中

    您可能有一个SLO在300毫秒内处理95%的请求。 在这种情况下,请将直方图配置为具有0.3秒上限的存储桶。 然后,您可以直接表示300毫秒内服务的相对请求数量,并在该值降至0.95以下时轻松发出警报。 以下表达式按作业为最近5分钟内服务的请求计算它。 请求持续时间是使用称为http_request_duration_seconds的直方图收集的。

    sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (job)
    /
    sum(rate(http_request_duration_seconds_count[5m])) by (job)

    返回定义:

    “类似于直方图, 摘要会采样观察值(通常是请求持续时间和响应大小之类的东西。虽然它还提供观察值的总数和所有观察值的总和,但它会在滑动时间窗口内计算可配置的分位数。”

    汇总和直方图之间的本质区别在于,汇总在客户端上计算流φ分位数并直接公开它们,而直方图则公开了桶式观察计数,而直方图桶中的分位数的计算则在服务器端使用histogram_quantile()函数。

    如果您仍然感到困惑,建议您采用以下方法:

    • 大部分时间都使用量规来获取简单的时间序列指标。
    • 将计数器用于您知道会单调增加的事物,例如,如果您要计算发生某事的次数。
    • 使用直方图通过简单的存储桶进行延迟测量,例如,一个存储桶用于“ SLO以下”,另一个存储桶用于“ SLO之上”。

    这对于绝大多数用例来说已经足够了,并且您应该依靠统计分析专家来帮助您解决更高级的情况。

    现在,您已经对Prometheus是什么,它如何工作以及可以收集和存储的数据类型有了基本的了解,现在就可以开始本教程了。

    Prometheus和Kubernetes动手教程

    本教程包括以下内容:

    • 在您的集群中安装Prometheus
    • 下载示例应用程序并查看代码
    • 构建和部署应用程序并为其生成负载
    • 访问Prometheus UI并查看基本指标

    本教程假定:

    • 您已经部署了Kubernetes集群。
    • 您已配置kubectl命令行实用程序进行访问。
    • 您具有集群管理员角色(或至少具有足够的特权来创建名称空间和部署应用程序)。
    • 您正在运行基于Bash的命令行界面。 如果您运行其他操作系统或外壳环境,请调整本教程。

    如果您尚未运行Kubernetes,则此Minikube教程是在笔记本电脑上进行设置的简便方法。

    如果您现在准备好了,那就走吧。

    安装Prometheus

    在本节中,您将克隆样本存储库并使用Kubernetes的配置文件将Prometheus部署到专用名称空间。

    1. 在本地克隆样本存储库,并将其用作您的工作目录:
      $ git clone https: // github.com / yuriatgoogle / prometheus-demo.git
      $ cd  prometheus-demo
      $ WORKDIR =$ ( pwd )
    2. 为Prometheus部署创建专用的名称空间:
       $  kubectl create namespace prometheus 
      
    3. 为您的名称空间提供群集读取器角色:
      $ kubectl apply -f $WORKDIR / kubernetes / clusterRole.yaml
      clusterrole.rbac.authorization.k8s.io / prometheus created
      clusterrolebinding.rbac.authorization.k8s.io / prometheus created
    4. 使用抓取和警报规则创建Kubernetes configmap:
      $ kubectl apply -f $WORKDIR / kubernetes / configMap.yaml -n prometheus
      configmap / prometheus-server-conf created
    5. 部署Prometheus:
      $ kubectl create -f prometheus-deployment.yaml -n prometheus
      deployment.extensions / prometheus-deployment created
    6. 验证Prometheus是否正在运行:
      $ kubectl get pods -n prometheus
      NAME                                     READY   STATUS    RESTARTS   AGE
      prometheus-deployment-78fb5694b4-lmz4r   1 / 1     Running   0          15s

    查看基本指标

    在本部分中,您将访问Prometheus UI并查看所收集的指标。

    1. 使用端口转发可在本地启用对Prometheus UI的Web访问:
      注意:您的prometheus-deployment名称将与此示例不同。 在上一个命令的输出中检查并替换吊舱的名称。
      $ kubectl port-forward prometheus-deployment-7ddb99dcb-fkz4d 8080 : 9090 -n prometheus
      Forwarding from 127.0.0.1: 8080 - > 9090
      Forwarding from [ :: 1 ] : 8080 - > 9090
    2. 在浏览器中转到http:// localhost:8080
      Prometheus console

      您现在可以查询Prometheus指标了!
    1. 一些基本的计算机指标(例如CPU内核和内存的数量)立即可用。 例如,在表达式字段中输入machine_memory_bytes ,切换到“图形”视图,然后单击“执行”以查看绘制的度量标准:
    Prometheus metric channel
    1. 集群中运行的容器也会被自动监视。 例如,输入rate(container_cpu_usage_seconds_total {container_name =“ prometheus”} [1m])作为表达式,然后单击执行以查看Prometheus的CPU使用率:
    CPU usage metric

    现在,您知道如何安装Prometheus并使用它来测量一些现成的指标,是时候进行一些实际的监视了。

    黄金信号

    Google SRE的“ 监视分布式系统 ”一章中所述:

    “监视的四个黄金信号是等待时间,流量,错误和饱和。如果您只能测量面向用户系统的四个指标,请关注这四个。”

    本书提供了对这四个方面的详尽描述,但是本教程重点介绍最容易充当用户幸福感的三个信号:

    • 流量:您收到了多少个请求
    • 错误率:您可以成功处理多少个请求
    • 延迟:您可以多快的时间处理成功的请求

    正如您现在可能已经意识到的那样,普罗米修斯(Prometheus)不会为您测量其中任何一个。 您必须对部署的所有应用程序进行检测以发出它们。 以下是示例实现。

    打开$ WORKDIR / node / golden_signals / app.js文件,该文件是用Node.js编写的示例应用程序(回想一下,我们克隆了yuriatgoogle / prometheus-demo并导出了$ WORKDIR )。 首先查看第一部分,其中定义了要记录的指标:

    // total requests - counter
    const nodeRequestsCounter = new prometheus. Counter ( {
        name : 'node_requests' ,
        help : 'total requests'
    } ) ;

    第一个指标是一个计数器,将针对每个请求递增; 这是请求总数的计数方式:

    // failed requests - counter
    const nodeFailedRequestsCounter = new prometheus. Counter ( {
        name : 'node_failed_requests' ,
        help : 'failed requests'
    } ) ;

    第二个指标是另一个计数器,该计数器针对每个错误递增,以跟踪失败的请求数:

    // latency - histogram
    const nodeLatenciesHistogram = new prometheus. Histogram ( {
        name : 'node_request_latency' ,
        help : 'request latency by path' ,
        labelNames : [ 'route' ] ,
        buckets : [ 100 , 400 ]
    } ) ;

    第三个指标是跟踪请求等待时间的直方图。 使用非常基本的假设(即SLO的延迟时间为100ms)工作,您将创建两个存储桶:一个存储桶为100ms,另一个存储桶为400ms延迟。

    下一节将处理传入的请求,为每个请求增加总请求度量,在出现(人为引起的)错误时增加失败的请求,并记录每个成功请求的延迟直方图值。 我选择不记录错误的等待时间; 实施细节由您决定。

    app. get ( '/' , ( req , res ) => {
        // start latency timer
        const requestReceived = new Date ( ) . getTime ( ) ;
        console. log ( 'request made' ) ;
        // increment total requests counter
        nodeRequestsCounter. inc ( ) ;
        // return an error 1% of the time
        if ( ( Math . floor ( Math . random ( ) * 100 ) ) == 100 ) {
            // increment error counter
            nodeFailedRequestsCounter. inc ( ) ;
            // return error code
            res. send ( "error!" , 500 ) ;
        }
        else {
            // delay for a bit
            sleep. msleep ( ( Math . floor ( Math . random ( ) * 1000 ) ) ) ;
            // record response latency
            const responseLatency = new Date ( ) . getTime ( ) - requestReceived ;
            nodeLatenciesHistogram
                . labels ( req. route . path )
                . observe ( responseLatency ) ;
            res. send ( "success in " + responseLatency + " ms" ) ;
        }
    } )

    本地测试

    既然您已经了解了如何实现Prometheus指标,那么请看运行应用程序时会发生什么。

    1. 安装所需的软件包:
      $ cd $WORKDIR / node / golden_signals
      $ npm install --save
    2. 启动应用程序:
       $  node app.js 
      
    3. 打开两个浏览器选项卡:一个到http:// localhost:8080 ,另一个到http:// localhost:8080 / metrics
    4. 转到/ metrics页面时,您可以看到每次重新加载主页时Prometheus度量标准正在收集和更新:
    Prometheus metrics being collected

    现在,您可以将示例应用程序部署到Kubernetes集群并测试监视了。

    在Kubernetes上将监视部署到Prometheus

    现在是时候通过以下方法查看如何在部署在集群中的Prometheus实例中记录和表示指标了:

    • 构建应用程序映像
    • 将其部署到您的集群
    • 针对应用程序生成负载
    • 观察记录的指标

    构建应用程序映像

    该示例应用程序提供了一个Dockerfile,您将使用它来构建映像。 本节假定您具有:

    • 在本地安装和配置Docker
    • Docker Hub帐户
    • 创建一个仓库

    如果您使用Google Kubernetes Engine运行集群,则可以改用Cloud Build和Google Container Registry。

    1. 切换到应用程序目录:
       $  cd $WORKDIR / node / golden_signals 
      
    2. 使用以下命令构建映像:
       $  docker build . --tag = < Docker username >/ prometheus-demo-node:latest 
      
    3. 确保您已登录Docker Hub:
       $  docker login 
      
    4. 使用以下命令将映像推送到Docker Hub:
       $  docker push < username >/ prometheus-demo-node:latest  
      
    5. 验证图像是否可用:
       $  docker images 
      

    部署应用

    现在,应用程序映像位于Docker Hub中,您可以将其部署到集群中并运行该应用程序。

    1. 修改$ WORKDIR / node / golden_signals / prometheus-demo-node.yaml文件,以从Docker Hub中提取图像:
      spec :
            containers
      :
            - image
      : docker.io/<Docker username>/prometheus-demo-node:latest
    2. 部署映像:
      $ kubectl apply -f $WORKDIR / node / golden_signals / prometheus-demo-node.yaml
      deployment.extensions / prometheus-demo-node created
    3. 验证该应用程序正在运行:
      $ kubectl get pods
      NAME                                    READY   STATUS    RESTARTS   AGE
      prometheus-demo-node-69688456d4-krqqr   1 / 1     Running   0          65s
    4. 使用负载平衡器公开应用程序:
      $ kubectl expose deployment prometheus-node-demo --type =LoadBalancer --name =prometheus-node-demo --port = 8080
      service / prometheus-demo-node exposed
    5. 确认您的服务具有外部IP地址:
      $ kubectl get services
      NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP      PORT ( S )          AGE
      kubernetes             ClusterIP      10.39.240.1     < none >           443 / TCP          23h
      prometheus-demo-node   LoadBalancer   10.39.248.129   35.199.186.110   8080 : 31743 / TCP   78m

    生成负载以测试监控

    现在您的服务已启动并正在运行,请使用Apache Bench对其产生一些负载。

    1. 获取您的服务的IP地址作为变量:
       $  export SERVICE_IP =$ ( kubectl get svc prometheus-demo-node -ojson | jq -r '.status.loadBalancer.ingress[].ip' ) 
      
    2. 使用ab产生一些负载。 您可能要在单独的终端窗口中运行它。
       $  ab -c 3 -n 1000 http: // ${SERVICE_IP} : 8080 / 
      

    查看指标

    在负载运行时,再次访问群集中的Prometheus UI,并确认正在收集“黄金信号”度量标准。

    1. 建立与Prometheus的连接:
      $ kubectl get pods -n prometheus
      NAME                                     READY   STATUS    RESTARTS   AGE
      prometheus-deployment-78fb5694b4-lmz4r   1 / 1     Running   0          15s

      $ kubectl port-forward prometheus-deployment-78fb5694b4-lmz4r 8080 : 9090 -n prometheus
      Forwarding from 127.0.0.1: 8080 - > 9090
      Forwarding from [ :: 1 ] : 8080 - > 9090

      注意:确保将第二个命令中的Pod名称替换为第一个命令的输出。

    2. 在浏览器中打开http:// localhost:8080
    Prometheus console
    1. 使用以下表达式衡量请求率:
       rate ( node_requests [ 1m ] ) 
      
    Measuring the request rate
    1. 使用以下表达式来衡量您的错误率:
       rate ( node_failed_requests [ 1m ] ) 
      
    Measuring the error rate
    1. 最后,使用此表达式来验证您的延迟SLO。 请记住,您设置了两个存储桶,分别为100ms和400ms。 此表达式返回满足SLO的请求的百分比:
       sum ( rate ( node_request_latency_bucket { le = "100" } [ 1h ] ) ) / sum ( rate ( node_request_latency_count [ 1h ] ) ) 
      
    SLO query graph

    大约10%的请求在SLO内。 这是您应该期望的,因为代码会在0到1,000之间随机Hibernate毫秒数。 这样,大约有10%的时间,它会在100毫秒内返回,并且此图表明您无法满足延迟SLO的要求。

    摘要

    恭喜你! 您已经完成了本教程,并希望对Prometheus的工作原理,如何使用自定义指标对应用程序进行检测以及如何使用它来衡量SLO遵从性有更好的了解。 本系列的下一篇文章将介绍使用OpenCensus的另一种度量工具方法。

    翻译自: https://opensource.com/article/19/11/introduction-monitoring-prometheus

    prometheus监控

    展开全文
  • 背景公司有几台测试服务器,由于公司运维也帮忙去做服务器报警,但是由于测试服务器本来性能和线上机器硬件就不一样,所以让运维老师去掉了测试服务器报警,我们自己使用prometheus监控几台测试服务器,当出现故障的时候...
  • 本文介绍Prometheus 监控及在k8s集群中使用node-exporter、prometheus、grafana对集群进行监控。实现原理类似ELK、EFK组合。node-exporter组件负责收集节点上的metrics监控数据,并将数据推送给prometheus, ...
  • prometheus监控平台

    2018-12-04 10:24:10
    prometheus监控平台,
  • Prometheus监控安装

    2021-01-09 05:03:37
    Prometheus监控 一 环境准备 例:Prometheus服务器(192.168.1.171),Agent被监控服务器(192.168.1.172) 二、安装Prometheus(192.168.1.171) 1.下载Prometheus安装包 wget ...
  • 之前在《Prometheus监控实践:Kubernetes集群监控》一本中总结了我们目前基于Prometheus对Kubernetes集群的监控,除了监控Kubernetes集群本身的关键指标之外,也对部署在Kubernetes集群上应用的状态做了监控。...
  • prometheus 监控 Prometheus是用于容器和微服务的开源监视和警报工具包。 该项目受到许多不同组织的欢迎,无论它们的规模或行业如何。 该工具包是高度可定制的,旨在提供丰富的指标,而不会影响系统性能。 基于已...
  • Prometheus监控Kafka

    2020-01-15 10:00:10
    Prometheus监控Kafka1.Prometheus监控Kafka,Docker方式 Kafka监控优秀博文: 简书:whaike:【监控】Kafka - 详细指标 CSDN:GeekXuShuo:Prometheus 监控之 kafka 1.Prometheus监控Kafka,Docker方式 Kafka_...
  • prometheus监控.ppt

    2019-06-16 09:23:18
    分享Prometheus监控,讲讲入门安装,服务器监控,容器监控,k8s监控等等,有兴趣可以下载
  • Prometheus监控系统专题一、简介安装使用.md一、Prometheus简介Prometheus是一个开源的系统监控和报警工具,特点是多维数据模型(时序列数据由metric名和一组key/value组成)在多维度上灵活的查询语言(PromQl)不依赖...
  • prometheus监控实战

    千次阅读 2020-01-02 11:27:27
    登录注册写文章首页下载APP《Prometheus监控实战》读书笔记潘晓华Michael关注赞赏支持《Prometheus监控实战》读书笔记潘晓华Michael关注72019.12.07 22:37:12字数 6,726阅读 1,863 《Prometheus监控实战》 ...
  • prometheus:用于Prometheus监控的docker-compose堆栈

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,893
精华内容 3,957
关键字:

prometheus监控