Skip to main content

Monitor in tempo reale - Prometheus ed altri oggetti.

Prometheus - Monitoring Tool - Centos7

Installazione di Prometheus Alertmonitor Grafana Node-exporter con docker come servizio e cartelle montate localmente per mantenere le configurazioni ed i dati dei servizi. La configurazione comprende anche l'uso di Telegram per le notifiche

Azioni

  • Prerequisiti (Docker Docker-Composer)
  • Installazione immagini (Docker Pull)
  • Configurazione avvio immagini
  • Configurazione servizi
  • Configurazione avvio servizi
  • Test (configurazione ed architettura)

Prerequisiti

  • docker
  • docker-compose

Riferimenti

installazione e configurazione di sistema
  • https://www.digitalocean.com/community/tutorials/how-to-install-prometheus-using-docker-on-centos-7
  • http://www.tutorialspoint.com/articles/how-to-install-and-configure-prometheus-using-docker-on-centos-7
  • https://www.shellhacks.com/prometheus-monitoring-install-docker-ubuntu-centos/
regole di alert e queryper Prometheus
  • https://awesome-prometheus-alerts.grep.to/rules.html
  • https://www.fabernovel.com/en/engineering/alerting-in-prometheus-or-how-i-can-sleep-well-at-night
  • https://www.robustperception.io/irate-graphs-are-better-graphs
integrazione con Telegram
  • https://sudonull.com/posts/194-Prometheus-Grafana-Node-Exporter-Docker-in-Azure-with-notifications-in-Telegram

Installazione immagini Docker

 $ sudo docker pull prom/prometheus
 $ sudo docker pull prom/alertmanager
 $ sudo docker pull prom/node-exporter
 $ sudo docker pull google/cadvisor # TODO
 $ sudo docker pull grafana/grafana 
 $ sudo docker pull metalmatze/alertmanager-bot

Configurazioni permessi sulle cartelle

Sono le cartelle che conterranno le configurazioni dei vari servizi in maniera permanente anche con un riavvio di Docker
# prometheus folder settings
$ mkdir /dati/prometheus/data
$ sudo chown 65534:65534 /dati/prometheus/data

# grafana folder setting
$ /dati/grafana
$ id # get the $uid number
$ sudo shown $uid:$uid  /dati/grafana/

# alertmanager-bot Telegram
$ mkdir /dati/prometheus/alertmanager-bot

Configurazione Prometheus

E' configurato per raccogliere i dati da diverse sorgenti (scrape_configs)
/dati/prometheus/conf/prometheus.yml
global:
  scrape_interval:     15s 
  external_labels:
    monitor: 'codelab-monitor'

# configurazione degli alert
rule_files:
  - 'alert.rules.yml'

alerting:
  alertmanagers:
  - scheme: http
    static_configs:
    - targets:
      - "HOST_ALERT_MANAGER:9093"

scrape_configs:
# sorgenti da cui recupera le metriche

  # controlla se stesso
  - job_name: 'prometheus-service'
    scrape_interval: 5s
    static_configs:
      - targets: ['IP_HOST_LOCALE:9090']

  # controlla una applicazione NodeJS in con swagger
  - job_name: 'swagger-SRS'
    scrape_interval: '10s'
    metrics_path: '/swagger-stats/metrics'
    static_configs:
      - targets: ['IP_NODE_SERVER:8010']

  # controlla l'host locale
  - job_name: 'localhost-stats'
    scrape_interval: '20s'
    static_configs:
      - targets: ['IP_HOST_LOCALE:9100']

  # controlla grafana TODO

Configurazione regole alerts in Prometheus

Sono configurati due alert standard. Il primo si aziona se qualsiasi sorgente non è up per più di 30 sec. Il secondo se il carico dell'host supera 0.5
/dati/prometheus/alert.rules.yml
groups:
- name: example
  rules:

  # Alert for any instance that is unreachable for >2 minutes.
  - alert: service_down
    expr: up == 0
    for: 30s
    labels:
      severity: page
    annotations:
      summary: "Instance {{ $labels.instance }} down"
      description: "{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 2 minutes."

  - alert: high_load
    expr: node_load1 > 0.5
    for: 2m
    labels:
      severity: page
    annotations:
      summary: "Instance {{ $labels.instance }} under high load"
      description: "{{ $labels.instance }} of job {{ $labels.job }} is under high load."


# Alert too many 500 api error on rate
 - alert: SRSHttpErrors5xx
    expr: sum(rate(api_request_total{code=~"^5.."}[1m])) / sum(rate(api_request_total[1m])) * 100 > 5
    for: 30s
    labels:
      severity: error
    annotations:
      summary: "HTTP errors 5xx (instance {{ $labels.instance }}) for 30 sec."
      description: "Too many HTTP requests with status 5xx (> 5%)\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"

Configurazione AlertManager

Per tutti gli alert è configurato un unico destinatario via email o Telegram
global:
  smtp_smarthost: 'smtp.__.__.it:25'
  smtp_from: 'alertmanager@:__.__.it'
  smtp_require_tls: false

route:
  group_by: ['alertname','priority','example']
  # Send all notifications to me.
  receiver: email-me
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 10m

  routes:
    - receiver: "email-me"
      group_wait: 10s
      match_re:
        severity: error|warning
      continue: true

    - receiver: "alertmanager-bot"
      group_wait: 10s
      match_re:
        severity: error
      continue: true

receivers:
  - name: email-me
    email_configs:
    - to: alert.destination@__.__.it

 - name: alertmanager-bot
    webhook_configs:
    - send_resolved: true
      url: 'http://hostname.it:8088'

Configurazione Docker compose per avvio servizi

Viene configurato l'avvio dei vari container docker con il mount delle cartelle. Per Grafana sono impostati diversi parametri di avvio.
/dati/prometheus/docker-compose.yml 
version: '3'
services:
   prometheus:
      image: prom/prometheus:latest
      container_name: prometheus
      volumes:
         - /dati/prometheus/conf:/etc/prometheus
         - /dati/prometheus/data:/prometheus
      command:
         - '--config.file=/etc/prometheus/prometheus.yml'
         - '--storage.tsdb.path=/prometheus'
      ports:
         - '9090:9090'
# restart: always
   node-exporter:
      container_name: prometheus-node-exporter
      image: prom/node-exporter
      ports:
         - '9100:9100'
   alertmanager:
      container_name: prometheus-alertmanager
      image: prom/alertmanager
      volumes:
         - /dati/prometheus/conf/alertmanager.yml:/alertmanager.yml
      command:
         - '--config.file=/alertmanager.yml'
      ports:
         - '9093:9093'
   grafana:
      container_name: grafana-service
      image: grafana/grafana
      user: # $uid es: '140'
      volumes:
         - /dati/grafana:/var/lib/grafana
      environment:
         - GF_SECURITY_ADMIN_PASSWORD=password
         - https_proxy=https://proxy.__.__.it:8080
         - http_proxy=http://proxy.__.__.it:8080
         - GF_SMTP_ENABLED=true
         - GF_SMTP_HOST=smtp.__.__.it:25
         - GF_SMTP_FROM_ADDRESS=grafana-alert@__.__.it
      ports:
         - '3000:3000'
# TODO google/cadvisor 
# telegram bot alert
   alertmanager-bot:
      image: metalmatze/alertmanager-bot
      environment:
         - ALERTMANAGER_URL=http://hostname:9093
         - https_proxy=http://proxy._._.it:8080
         - http_proxy=http://proxy._._.it:8080
         - LISTEN_ADDR=0.0.0.0:8088
         - BOLT_PATH=/data/bot.db
         - STORE=bolt
         - TELEGRAM_ADMIN=99999
         - TELEGRAM_TOKEN=999999:QQ__QQ
         - TEMPLATE_PATHS=/templates/default.tmpl
      volumes:
         - /dati/prometheus/alertmanager-bot:/data
      ports:
         - '8088:8088'
Per verificare che il file sia correttamente digitato eseguire:
$ docker-compose up -d

Configurazione come servizio di sistema

/etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus monitoring docker container
After=docker.service
BindsTo=docker.service

[Service]
Restart=always
WorkingDirectory=/dati/prometheus/

# Ubuntu
ExecStart=/usr/local/bin/docker-compose up
ExecStop=/usr/local/bin/docker-compose down

# CentOS
#ExecStart=/usr/bin/docker-compose up
#ExecStop=/usr/bin/docker-compose down

[Install]
WantedBy=multi-user.target
Impostazione e controllo funzionamento come servizio di sistema ed analisi avvio
# impostazione
$ sudo systemctl daemon-reload
$ sudo systemctl enable prometheus
# controllo servizi
$ sudo systemctl start prometheus
$ sudo systemctl stop prometheus
$ sudo systemctl restart prometheus
Analisi avvio dei container docker (esempio)
# lista dei container
$ sudo docker ps -a

CONTAINER ID        IMAGE                                COMMAND                  CREATED              STATUS                       PORTS                    NAMES
1abc1e837fa3        prom/node-exporter                   "/bin/node_exporter"     About a minute ago   Up About a minute            0.0.0.0:9100->9100/tcp   prometheus-node-exporter
becfde05313f        prom/prometheus:latest               "/bin/prometheus -..."   About a minute ago   Up About a minute            0.0.0.0:9090->9090/tcp   prometheus
53b3323e7d52        prom/alertmanager                    "/bin/alertmanager..."   About a minute ago   Up About a minute            0.0.0.0:9093->9093/tcp   prometheus-alertmanager
75e610620c07        prom/prometheus                      "/bin/prometheus -..."   25 hours ago         Exited (2) 25 hours ago    

# ATTENZIONE il container 75e610620c07 è in stato "Exited" i logs sono da verificare
$ sudo docker logs 75e610620c07

Configurazione Grafana

TODO - TODO

Ambiente a runtime

Console Prometheus
  • http://IP_HOST:9090
Console AlertManager
  • http://IP_HOST:9093
Console NodeExporter
  • http://IP_HOST:9100
Console Grafana
  • http://IP_HOST:3000
TODO - Configurazione Aler swagger stats / node-explorer / ecc. ecc.

Tutorial per PromQL per creazioni alert (note rate e irate)

Regola "too many 5xx error" legata ad una finestra temporale
# rapporto fra il "burst" delle chiamate con errore (5xx) e le chiamate totali
# l'alert si attiva se la % è maggiore di 5 (ovvero se gli numero di errori 
# sono più del 5% delle chiamate totali nell'ultimo minuto

sum(rate(api_request_total{code=~"^5.."}[1m])) / sum(rate(api_request_total[1m])) * 100 > 5
rate() ritorna per secondo la media del cambiamento sul tuo intervallo usando il primo e l'ultimo punto dell'intervallo qualsiasi esso sia e qualsiasi timestamp abbia, può nascondere degli spikes (picchi di attività)
irate() come rate() ma è calcolato sugli ultimi due data point
Suggerimento : intervallo minimo è doppio di quello si scrape ad esempio
scrape : 20sec interval : 1m
Sidebar: The minimum range interval versus the minimum query step Suppose that you have a continuously updating metric that Prometheus scrapes every fifteen seconds. To do a rate() or irate() of this, you need at least two metric points and thus a range interval of thirty seconds (at least; in practice you need a somewhat larger interval). However, you get a new metric value roughly every fifteen seconds and thus a potentially new rate of change every fifteen seconds as well (due to your new metric point). This means it's reasonable to look at a graph with a query step of fifteen seconds and an interval of thirty seconds.
FINE DOCUMENTO

Comments

Post a Comment

Popular posts from this blog