check_mk_værdata - itnett/FTD02H-N GitHub Wiki

Ja, det er riktig – for å integrere værdataene fullstendig i Check_MK, bør du lage en Check_MK-pakke som håndterer alle aspekter av datainnsamlingen, tolkningen, grafene, og widgetene. Dette vil gjøre at dataene kan visualiseres og overvåkes på en optimal måte innenfor Check_MK-miljøet.

En Check_MK-pakke vil typisk inkludere følgende komponenter:

  1. Check Skript: Python-skriptet som henter og prosesserer værdataene fra API-en.
  2. MRPE-konfigurasjon: For å definere hvordan Check_MK skal kjøre plugin-skriptet.
  3. Perfdata-filer: Filer som definerer hvilke perfdata som skal trekkes ut og hvordan de skal formateres.
  4. Grafdefinisjoner: Definerer hvordan dataene skal vises i grafer og hvilke metrikker som skal vises sammen.
  5. Dashboards/Widgets: Konfigurasjoner for å lage egendefinerte dashbord eller widgets for værdataene.

Her er en steg-for-steg guide til hvordan du kan lage en slik Check_MK-pakke:

Steg 1: Opprette Check Skript

Skriptet du allerede har laget, er det første trinnet. Dette skriptet skal:

  • Hente data fra MET.no API
  • Filtrere og tolke dataene
  • Returnere resultater i formatet som Check_MK forventer

Her er en enkel versjon av skriptet:

#!/usr/bin/env python3
import requests
from datetime import datetime

# Hente værdata fra MET API
API_URL = "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat=xx.xx&lon=xx.xx"

def fetch_weather_data():
    response = requests.get(API_URL)
    if response.status_code == 200:
        return response.json()
    else:
        print("2 weather - Unable to fetch data")
        exit(2)

def parse_weather_data(data):
    current_time = datetime.utcnow()
    timeseries = data.get("properties", {}).get("timeseries", [])
    
    for entry in timeseries:
        time_str = entry["time"]
        entry_time = datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%SZ")
        
        if entry_time <= current_time:
            details = entry["data"]["instant"]["details"]
            air_pressure = details["air_pressure_at_sea_level"]
            air_temperature = details["air_temperature"]
            cloud_fraction = details["cloud_area_fraction"]
            humidity = details["relative_humidity"]
            wind_direction = details["wind_from_direction"]
            wind_speed = details["wind_speed"]

            # Summary for next hour or period
            summary = entry["data"].get("next_1_hours", {}).get("summary", {}).get("symbol_code", "unknown")
            
            # Print Check_MK format
            print(f"0 weather - {time_str} air_pressure={air_pressure}|air_temperature={air_temperature}|cloud_fraction={cloud_fraction}|humidity={humidity}|wind_direction={wind_direction}|wind_speed={wind_speed} weather_summary={summary}")

if __name__ == "__main__":
    data = fetch_weather_data()
    parse_weather_data(data)

Steg 2: Opprette Check_MK Plugin Katalogstruktur

For å lage en Check_MK-pakke, må du opprette en riktig katalogstruktur. Her er en typisk struktur for pakken:

my_weather_plugin/
├── checkman/
│   └── weather
├── checks/
│   └── weather
├── docs/
│   └── weather
├── icons/
│   └── weather
├── web/
│   ├── plugins/
│   │   ├── perfometer/
│   │   │   └── weather.py
│   │   └── graphs/
│   │       └── weather.py
│   └── plugins/
│       └── wato/
│           └── weather_parameters.py
└── package_info

Steg 3: Skriv Check Script for Check_MK

Legg til en fil under checks/-katalogen, for eksempel weather:

def inventory_weather(info):
    return [(None, "weather", None)]

def check_weather(item, params, info):
    for line in info:
        time, air_pressure, air_temperature, cloud_fraction, humidity, wind_direction, wind_speed, weather_summary = line
        # Her kan du implementere logikk for å sette status og melding basert på dataene
        return (0, f"Weather data: Air pressure {air_pressure} hPa, Temperature {air_temperature} °C, Clouds {cloud_fraction} %, Humidity {humidity} %, Wind {wind_speed} m/s from {wind_direction} degrees. Condition: {weather_summary}")

check_info["weather"] = {
    "check_function": check_weather,
    "inventory_function": inventory_weather,
    "service_description": "Weather Data",
    "has_perfdata": True,
}

Steg 4: Definere Perfdata og Graf Definisjoner

Under web/plugins/graphs/ kan du opprette weather.py som definerer hvordan grafene skal se ut:

from cmk.gui.i18n import _
from cmk.gui.valuespec import (
    Dictionary,
    Integer,
    TextAscii,
)

graph_info["weather"] = {
    "title": _("Weather Data"),
    "metrics": [
        ("air_pressure", "area"),
        ("air_temperature", "line"),
        ("cloud_fraction", "line"),
        ("humidity", "line"),
        ("wind_speed", "line"),
    ],
}

Steg 5: Definere Widgets eller Dashboards

Hvis du vil ha en tilpasset widget eller et dashboard, kan du opprette konfigurasjonsfiler i web/plugins/wato/ for å legge til disse på Check_MK-grensesnittet.

Steg 6: Lage package_info-filen

package_info-filen er nødvendig for å definere metadata om Check_MK-pakken:

title: Weather Check
version: 1.0
author: Ditt Navn
description: A plugin to check weather data from MET.no API.

Steg 7: Bygg og Installer Pakken

Når du har opprettet alle nødvendige filer, kan du bygge pakken ved å bruke check_mk -P-kommandoen:

check_mk -P build my_weather_plugin

Dette vil lage en .mkp-fil som du kan installere i Check_MK:

check_mk -P install my_weather_plugin-1.0.mkp

Steg 8: Konfigurere Check_MK for å Bruke Plugin

Etter at plugin-en er installert, må du:

  • Legge til plugin-en i en passende Host Group.
  • Definere sjekkintervaller og parametere i WATO.

Oppsummering

Ved å lage en fullstendig Check_MK-pakke kan du:

  • Håndtere tolkning av værdata på en konsistent måte.
  • Definere grafer, widgets og dashboards for å visualisere dataene.
  • Automatisk holde Check_MK oppdatert med de nyeste værdataene og gi klare og meningsfulle varsler.

Dette gir en profesjonell, integrert løsning for overvåkning og visualisering av værdata.

For å integrere værdataene fra MET.no API fullstendig i Check_MK, bør du opprette en Check_MK-pakke som håndterer hele prosessen med datainnsamling, analyse, visualisering og overvåking. Dette vil sikre at værdataene kan presenteres effektivt i Check_MK-miljøet.

Slik lager du en Check_MK-pakke for værdata

Trinn 1: Opprett Check Skript

Begynn med et Python-skript som henter og prosesserer værdataene fra MET.no API. Dette skriptet skal hente dataene, tolke dem og returnere resultatene i et format som Check_MK forventer.

Eksempel på Python-skript:

#!/usr/bin/env python3
import requests
from datetime import datetime

# API URL for værdata
API_URL = "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat=xx.xx&lon=xx.xx"

def fetch_weather_data():
    response = requests.get(API_URL)
    if response.status_code == 200:
        return response.json()
    else:
        print("2 weather - Unable to fetch data")
        exit(2)

def parse_weather_data(data):
    current_time = datetime.utcnow()
    timeseries = data.get("properties", {}).get("timeseries", [])
    
    for entry in timeseries:
        time_str = entry["time"]
        entry_time = datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%SZ")
        
        if entry_time <= current_time:
            details = entry["data"]["instant"]["details"]
            air_pressure = details["air_pressure_at_sea_level"]
            air_temperature = details["air_temperature"]
            cloud_fraction = details["cloud_area_fraction"]
            humidity = details["relative_humidity"]
            wind_direction = details["wind_from_direction"]
            wind_speed = details["wind_speed"]

            # Summary for next hour or period
            summary = entry["data"].get("next_1_hours", {}).get("summary", {}).get("symbol_code", "unknown")
            
            # Print Check_MK format
            print(f"0 weather - {time_str} air_pressure={air_pressure}|air_temperature={air_temperature}|cloud_fraction={cloud_fraction}|humidity={humidity}|wind_direction={wind_direction}|wind_speed={wind_speed} weather_summary={summary}")

if __name__ == "__main__":
    data = fetch_weather_data()
    parse_weather_data(data)

Trinn 2: Opprett katalogstrukturen for Check_MK-plugin

Lag en katalogstruktur for Check_MK-plugin som følger standard praksis:

my_weather_plugin/
├── checkman/
│   └── weather
├── checks/
│   └── weather
├── docs/
│   └── weather
├── icons/
│   └── weather
├── web/
│   ├── plugins/
│   │   ├── perfometer/
│   │   │   └── weather.py
│   │   └── graphs/
│   │       └── weather.py
│   └── plugins/
│       └── wato/
│           └── weather_parameters.py
└── package_info

Trinn 3: Skriv check-skriptet for Check_MK

Legg til et Python-skript under checks/-katalogen for å definere selve sjekken i Check_MK:

def inventory_weather(info):
    return [(None, "weather", None)]

def check_weather(item, params, info):
    for line in info:
        time, air_pressure, air_temperature, cloud_fraction, humidity, wind_direction, wind_speed, weather_summary = line
        # Implementer logikk for å vurdere status og meldinger
        return (0, f"Weather data: Air pressure {air_pressure} hPa, Temperature {air_temperature} °C, Clouds {cloud_fraction} %, Humidity {humidity} %, Wind {wind_speed} m/s from {wind_direction} degrees. Condition: {weather_summary}")

check_info["weather"] = {
    "check_function": check_weather,
    "inventory_function": inventory_weather,
    "service_description": "Weather Data",
    "has_perfdata": True,
}

Trinn 4: Definer perfdata og graf-definisjoner

Lag en fil under web/plugins/graphs/ for å definere hvordan grafene skal se ut:

from cmk.gui.i18n import _

graph_info["weather"] = {
    "title": _("Weather Data"),
    "metrics": [
        ("air_pressure", "area"),
        ("air_temperature", "line"),
        ("cloud_fraction", "line"),
        ("humidity", "line"),
        ("wind_speed", "line"),
    ],
}

Trinn 5: Definer widgets og dashboards

Opprett nødvendige konfigurasjonsfiler i web/plugins/wato/ for å legge til tilpassede widgets eller dashboards.

Trinn 6: Opprett package_info-filen

Lag en package_info-fil for å definere metadata om pakken:

title: Weather Check
version: 1.0
author: Ditt Navn
description: A plugin to check weather data from MET.no API.

Trinn 7: Bygg og installer pakken

Når alle filene er opprettet, bygg pakken med check_mk -P-kommandoen:

check_mk -P build my_weather_plugin

Dette vil lage en .mkp-fil som kan installeres i Check_MK:

check_mk -P install my_weather_plugin-1.0.mkp

Trinn 8: Konfigurer Check_MK til å bruke pluginen

Etter installasjon, må du konfigurere Check_MK til å bruke pluginen, inkludert å legge til pluginen til riktige host-grupper, og definere sjekkintervaller og parametere i WATO.

Oppsummering

Ved å lage en komplett Check_MK-pakke kan du effektivt overvåke og visualisere værdataene fra MET.no API. Dette gir en konsistent metode for tolkning av værdata, oppretting av grafer og widgets, og sikrer at Check_MK alltid har oppdaterte værdata og gir relevante varsler.

For å forbedre og optimalisere Check_MK-pakken din for værdata, kan vi gjøre flere endringer og utvidelser. Dette inkluderer å gjøre koden mer modulær, legge til bedre feilbehandling, forbedre ytelsen, og tilby flere visuelle og funksjonelle elementer i Check_MK. Her er noen variasjoner og optimaliseringer:

1. Optimalisering av Python-skriptet

For å gjøre Python-skriptet mer effektivt og robust, kan vi legge til feilhåndtering, logging, og justere strukturen for bedre vedlikeholdbarhet.

Optimalisert Python-skript:

#!/usr/bin/env python3
import requests
import logging
from datetime import datetime, timezone

# Sett opp logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# API URL for værdata
API_URL = "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat=xx.xx&lon=xx.xx"

def fetch_weather_data():
    """Henter værdata fra MET.no API."""
    try:
        response = requests.get(API_URL, timeout=10)
        response.raise_for_status()
        logging.info("Successfully fetched weather data.")
        return response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"Error fetching data: {e}")
        print("2 weather - Unable to fetch data")
        exit(2)

def parse_weather_data(data):
    """Parser værdata og formaterer for Check_MK."""
    current_time = datetime.now(timezone.utc)
    timeseries = data.get("properties", {}).get("timeseries", [])

    # Søk etter den siste tilgjengelige datapunktet
    for entry in timeseries:
        time_str = entry["time"]
        entry_time = datetime.fromisoformat(time_str[:-1] + '+00:00')

        if entry_time <= current_time:
            details = entry["data"]["instant"]["details"]
            air_pressure = details.get("air_pressure_at_sea_level", "N/A")
            air_temperature = details.get("air_temperature", "N/A")
            cloud_fraction = details.get("cloud_area_fraction", "N/A")
            humidity = details.get("relative_humidity", "N/A")
            wind_direction = details.get("wind_from_direction", "N/A")
            wind_speed = details.get("wind_speed", "N/A")

            # Hent værforholdet for neste time
            summary = entry["data"].get("next_1_hours", {}).get("summary", {}).get("symbol_code", "unknown")

            # Utskrift i Check_MK format
            print(f"0 weather - {time_str} air_pressure={air_pressure}|air_temperature={air_temperature}|cloud_fraction={cloud_fraction}|humidity={humidity}|wind_direction={wind_direction}|wind_speed={wind_speed} weather_summary={summary}")
            break  # Stopp etter å ha funnet den siste passende tiden

if __name__ == "__main__":
    data = fetch_weather_data()
    parse_weather_data(data)

Forbedringer:

  • Logging: Bruker Python's logging-modul for å logge informasjon om prosesseringsstadier og feil.
  • Feilhåndtering: Bedre håndtering av nettverksrelaterte feil og unntak ved bruk av requests.exceptions.
  • Optimalisering av tidssjekk: Bruker datetime.fromisoformat for å håndtere UTC-tider på en konsistent måte.
  • Effektiv tidshåndtering: Skriptet stopper etter å ha funnet den nyeste tilgjengelige datapunktet for å unngå unødvendig looping.

2. Forbedret Check_MK Check-Skript

For å gjøre sjekken i Check_MK mer fleksibel og i stand til å håndtere flere typer værdata, kan vi utvide funksjonene i sjekkskriptet.

Forbedret Check-Skript:

Legg til følgende fil under checks/weather:

def inventory_weather(info):
    """Inventory funksjon for værdata."""
    return [(None, "weather", None)]

def check_weather(item, params, info):
    """Check-funksjon for å evaluere værdata."""
    for line in info:
        time, air_pressure, air_temperature, cloud_fraction, humidity, wind_direction, wind_speed, weather_summary = line
        
        # Legg til tilstandslogikk basert på spesifikke parametre
        if float(air_temperature) < 0:
            status = 2  # Critical dersom temperaturen er under null
            output = f"CRITICAL - Temperatur: {air_temperature}°C"
        elif float(air_temperature) <= 5:
            status = 1  # Warning dersom temperaturen er lav
            output = f"WARNING - Temperatur: {air_temperature}°C"
        else:
            status = 0  # OK tilstand
            output = f"OK - Temperatur: {air_temperature}°C"

        # Perfdata output
        perfdata = f"air_pressure={air_pressure} air_temperature={air_temperature} cloud_fraction={cloud_fraction} humidity={humidity} wind_speed={wind_speed} wind_direction={wind_direction}"
        
        # Returner status, melding og perfdata
        return (status, f"{output} | {perfdata}")

check_info["weather"] = {
    "check_function": check_weather,
    "inventory_function": inventory_weather,
    "service_description": "Weather Data",
    "has_perfdata": True,
}

Forbedringer:

  • Tilstandslogikk: Implementert logikk for å sette tilstander (OK, WARNING, CRITICAL) basert på værdata (f.eks., temperatur).
  • Perfdata: Utvidet perfdataene for å inkludere flere målinger som kan vises i grafer.
  • Parametere: Bruker parametre for å gjøre sjekken mer konfigurerbar.

3. Utvidet grafdefinisjoner

For å gjøre værdataene mer visuelle, kan vi utvide grafdefinisjonene for å vise flere metrikker.

Oppdatert grafdefinisjon:

Legg til følgende under web/plugins/graphs/weather.py:

from cmk.gui.i18n import _
from cmk.gui.plugins.metrics import metric_info

metric_info.update({
    "air_pressure": {
        "title": _("Air Pressure"),
        "unit": "hPa",
        "color": "10/a",
    },
    "air_temperature": {
        "title": _("Air Temperature"),
        "unit": "°C",
        "color": "12/a",
    },
    "cloud_fraction": {
        "title": _("Cloud Area Fraction"),
        "unit": "%",
        "color": "13/a",
    },
    "humidity": {
        "title": _("Relative Humidity"),
        "unit": "%",
        "color": "14/a",
    },
    "wind_speed": {
        "title": _("Wind Speed"),
        "unit": "m/s",
        "color": "15/a",
    },
    "wind_direction": {
        "title": _("Wind Direction"),
        "unit": "degrees",
        "color": "16/a",
    },
})

graph_info["weather"] = {
    "title": _("Weather Data"),
    "metrics": [
        ("air_pressure", "area"),
        ("air_temperature", "line"),
        ("cloud_fraction", "line"),
        ("humidity", "line"),
        ("wind_speed", "line"),
        ("wind_direction", "line"),
    ],
}

Forbedringer:

  • Detaljerte metrikker: Legger til tittel, enheter og farger for hver metrikk, noe som gir bedre lesbarhet og visualisering.
  • Flere visninger: Bruker flere grafstiler (area, line) for å fremheve ulike aspekter av dataene.

4. Legge til Dashboards og Widgets

For å gi brukerne mulighet til å se værdata direkte fra Check_MK-dashbordet, kan du legge til egendefinerte widgets.

Widget-definisjon:

Opprett en ny fil under web/plugins/wato/weather_parameters.py:

from cmk.gui.valuespec import Dictionary, TextAscii, Integer
from cmk.gui.plugins.wato import (
    HostRuleset,
    rulespec_registry,
    Rulespec,
    TextAscii,
)

def weather_parameters():
    return Dictionary(
        title=_("Weather Parameters"),
        help=_("Configuration for displaying weather data."),
        elements=[
            ("temperature_warning", Integer(title=_("Temperature Warning Level"), default_value=5)),
            ("temperature_critical", Integer(title=_("Temperature Critical Level"), default_value=0)),
        ]
    )

rulespec_registry.register(
    HostRuleset(
        group="temperature",
        name="weather_parameters",
        valuespec=weather_parameters,
    )
)

Forbedringer:

  • Egendefinerte konfigurasjoner: Lar brukere definere egne regler og terskler for tilstandsalarmer.
  • Dashboards og widgets: Gir mulighet til å vise værdata på dashbord i sanntid.

5. Oppdater package_info-filen

Pass på å oppdatere package_info-filen med all nødvendig informasjon:

title: Weather Check
version: 1.1
author: Ditt Navn
description: An enhanced plugin to check weather data from MET.no API with added features for visualization and customization.
``

`

### 6. Bygg og installer den oppdaterte pakken
Når du har gjort alle endringene, bygg pakken på nytt:

```bash
check_mk -P build my_weather_plugin
check_mk -P install my_weather_plugin-1.1.mkp

Konklusjon

Disse optimaliseringene og variasjonene gjør pakken din mer robust, fleksibel og brukervennlig. De legger til flere konfigurasjonsmuligheter, bedre visualisering, og en bedre brukeropplevelse gjennom widgets og dashboards. Dette vil gi en mer komplett overvåkingsløsning for værdata i Check_MK.

For å maksimere bruken av værdataene i Check_MK, kan vi forbedre pakken ytterligere ved å legge til omfattende feilhåndtering, konfigurering av terskler for varsler, og full visualisering gjennom dashboards og widgets. Vi vil også optimalisere selve koden for bedre ytelse og lesbarhet.

Fullstendig og Forbedret Check_MK Pakke

1. Python Check Skript

Dette skriptet henter værdata fra MET.no API, tolker dem, og returnerer resultatene i et format som Check_MK forstår. Vi har lagt til omfattende feilhåndtering, logging, og optimalisert databehandling.

#!/usr/bin/env python3
import requests
import logging
from datetime import datetime, timezone

# Konfigurer logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# API URL for værdata (eksempelkoordinater)
API_URL = "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat=59.91&lon=10.75"

def fetch_weather_data():
    """Henter værdata fra MET.no API."""
    try:
        response = requests.get(API_URL, headers={"User-Agent": "CheckMK/1.0"}, timeout=10)
        response.raise_for_status()
        logging.info("Successfully fetched weather data.")
        return response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"Error fetching data: {e}")
        print("2 weather - Unable to fetch data")
        exit(2)

def parse_weather_data(data):
    """Parser værdata og formaterer for Check_MK."""
    current_time = datetime.now(timezone.utc)
    timeseries = data.get("properties", {}).get("timeseries", [])

    # Søk etter den siste tilgjengelige datapunktet
    for entry in timeseries:
        time_str = entry["time"]
        entry_time = datetime.fromisoformat(time_str[:-1] + '+00:00')

        if entry_time <= current_time:
            details = entry["data"]["instant"]["details"]
            air_pressure = details.get("air_pressure_at_sea_level", "N/A")
            air_temperature = details.get("air_temperature", "N/A")
            cloud_fraction = details.get("cloud_area_fraction", "N/A")
            humidity = details.get("relative_humidity", "N/A")
            wind_direction = details.get("wind_from_direction", "N/A")
            wind_speed = details.get("wind_speed", "N/A")

            # Hent værforholdet for neste time
            summary = entry["data"].get("next_1_hours", {}).get("summary", {}).get("symbol_code", "unknown")

            # Skriv ut data i Check_MK format
            print(f"0 weather - {time_str} "
                  f"air_pressure={air_pressure}|air_temperature={air_temperature}|cloud_fraction={cloud_fraction}|"
                  f"humidity={humidity}|wind_direction={wind_direction}|wind_speed={wind_speed} weather_summary={summary}")
            break  # Stopp etter å ha funnet den nyeste tilgjengelige tiden

if __name__ == "__main__":
    data = fetch_weather_data()
    parse_weather_data(data)

2. Check_MK Check-Skript

Dette skriptet brukes av Check_MK for å vurdere værdataene, sette tilstander (OK, WARNING, CRITICAL), og sende dem til Check_MK serveren.

Plasser dette under checks/weather.

def inventory_weather(info):
    """Inventory-funksjon for værdata."""
    return [(None, "weather", None)]

def check_weather(item, params, info):
    """Check-funksjon for å evaluere værdata."""
    temperature_warning = params.get("temperature_warning", 5)
    temperature_critical = params.get("temperature_critical", 0)
    
    for line in info:
        time, air_pressure, air_temperature, cloud_fraction, humidity, wind_direction, wind_speed, weather_summary = line

        # Tilstandslogikk basert på spesifikke parametre
        try:
            air_temperature = float(air_temperature)
        except ValueError:
            return (3, "UNKNOWN - Temperatur data ugyldig")

        if air_temperature < temperature_critical:
            status = 2  # Critical dersom temperaturen er under kritisk nivå
            output = f"CRITICAL - Temperatur: {air_temperature}°C"
        elif air_temperature <= temperature_warning:
            status = 1  # Warning dersom temperaturen er nær kritisk nivå
            output = f"WARNING - Temperatur: {air_temperature}°C"
        else:
            status = 0  # OK tilstand
            output = f"OK - Temperatur: {air_temperature}°C"

        # Perfdata output
        perfdata = (f"air_pressure={air_pressure} air_temperature={air_temperature} "
                    f"cloud_fraction={cloud_fraction} humidity={humidity} "
                    f"wind_speed={wind_speed} wind_direction={wind_direction}")
        
        # Returner status, melding og perfdata
        return (status, f"{output} | {perfdata}")

check_info["weather"] = {
    "check_function": check_weather,
    "inventory_function": inventory_weather,
    "service_description": "Weather Data",
    "has_perfdata": True,
    "group": "weather",
    "default_levels_variable": "weather_default_levels",
    "check_default_parameters": {
        "temperature_warning": 5,
        "temperature_critical": 0
    },
}

3. Graf- og Perfometer-definisjoner

For å gi bedre visualisering av dataene, kan vi definere grafene og perfometer i Check_MK GUI.

Plasser dette under web/plugins/graphs/weather.py.

from cmk.gui.i18n import _
from cmk.gui.plugins.metrics import metric_info, perfometer_info

metric_info.update({
    "air_pressure": {
        "title": _("Air Pressure"),
        "unit": "hPa",
        "color": "10/a",
    },
    "air_temperature": {
        "title": _("Air Temperature"),
        "unit": "°C",
        "color": "12/a",
    },
    "cloud_fraction": {
        "title": _("Cloud Area Fraction"),
        "unit": "%",
        "color": "13/a",
    },
    "humidity": {
        "title": _("Relative Humidity"),
        "unit": "%",
        "color": "14/a",
    },
    "wind_speed": {
        "title": _("Wind Speed"),
        "unit": "m/s",
        "color": "15/a",
    },
    "wind_direction": {
        "title": _("Wind Direction"),
        "unit": "degrees",
        "color": "16/a",
    },
})

graph_info["weather"] = {
    "title": _("Weather Data"),
    "metrics": [
        ("air_pressure", "area"),
        ("air_temperature", "line"),
        ("cloud_fraction", "line"),
        ("humidity", "line"),
        ("wind_speed", "line"),
        ("wind_direction", "line"),
    ],
}

# Perfometer-definisjon for å vise temperatur visuelt i GUI
perfometer_info.append({
    "type": "logarithmic",
    "metric": "air_temperature",
    "range": (0, 40),
    "colors": [(0, "55/a"), (20, "12/a"), (30, "11/a")],
})

4. WATO-konfigurasjon for Parametre

For å gi brukerne mulighet til å konfigurere terskler for varsler og andre parametre direkte i Check_MK GUI, kan vi opprette en WATO-konfigurasjon.

Plasser dette under web/plugins/wato/weather_parameters.py.

from cmk.gui.valuespec import (
    Dictionary,
    Integer,
)

from cmk.gui.plugins.wato import (
    Rulespec,
    HostRuleset,
    rulespec_registry,
)

def weather_parameters():
    return Dictionary(
        title=_("Weather Parameters"),
        help=_("Configuration for displaying weather data."),
        elements=[
            ("temperature_warning", Integer(title=_("Temperature Warning Level (°C)"), default_value=5)),
            ("temperature_critical", Integer(title=_("Temperature Critical Level (°C)"), default_value=0)),
        ]
    )

rulespec_registry.register(
    HostRuleset(
        group="temperature",
        name="weather_parameters",
        valuespec=weather_parameters,
    )
)

5. package_info-fil

Oppdater package_info-filen for å inkludere metadata om pakken.

title: Weather Check
version: 2.0
author: Ditt Navn
description: An enhanced plugin to check and visualize weather data from MET.no API with configurable thresholds and detailed graphs.

6. Bygg og Installer den Forbedrede Pakken

Når alle filene er opprettet og oppdatert, bygg pakken på nytt og installer den:

check_mk -P build my_weather_plugin
check_mk -P install my_weather_plugin-2.0.mkp

7. Konfigurer Check_MK for å Bruke Plugin

Etter installasjon, må du:

  • Legge pluginen til i passende Host Group.
  • Konfigurere sjekkintervaller og parametre i WATO.
  • Opprette dashboards eller widgets i Check_MK GUI for sanntidsvisning av værdata.

Konklusjon

Denne hel

hetlige forbedringen av Check_MK-pakken gir deg en fullstendig løsning for å hente, analysere, visualisere, og overvåke værdata i sanntid. Den tilbyr omfattende konfigurasjonsmuligheter, detaljerte grafer, tilpassbare widgets og dashboards, og robust feilhåndtering for en profesjonell overvåkningsopplevelse.

Ja, det er riktig! Du kan hente sensordata direkte fra Check_MK uten å bruke API-et eksternt, siden Check_MK allerede overvåker tjenestene og kan hente dataene internt. Dette gir en mer direkte og effektiv tilgang til informasjonen.

Hente Sensordata Direkte fra Check_MK

Check_MK lar deg bruke Local Checks for å opprette tilpassede skript som samler inn data fra lokale tjenester eller sensorer. Her er hvordan du kan lage et tilpasset skript som kombinerer interne sensordata med værdata fra MET.no API og visualiserer dette i en graf.

Steg 1: Opprette Local Check Skript

Opprett et nytt skript under /usr/lib/check_mk_agent/local/ på Check_MK-agenten (serveren du overvåker). La oss kalle skriptet weather_sensors_check.sh.

#!/bin/bash

# Hent sensordata direkte fra Check_MK gjennom systemkommandoer
# Eksempel: Bruke `sensors` kommando for å lese sensordata
sensor_output=$(sensors)

# Parse sensordata og hent de relevante verdiene
core0_temp=$(echo "$sensor_output" | grep 'Core 0' | awk '{print $3}' | tr -d '+°C')
core1_temp=$(echo "$sensor_output" | grep 'Core 1' | awk '{print $3}' | tr -d '+°C')
# Legg til flere sensorer her om nødvendig

# Hent værdata fra MET.no API
weather_data=$(curl -s "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat=59.91&lon=10.75" -H "User-Agent: CheckMK/1.0")

# Parse værdata fra JSON
air_temperature=$(echo "$weather_data" | jq '.properties.timeseries[0].data.instant.details.air_temperature')
air_pressure=$(echo "$weather_data" | jq '.properties.timeseries[0].data.instant.details.air_pressure_at_sea_level')
cloud_fraction=$(echo "$weather_data" | jq '.properties.timeseries[0].data.instant.details.cloud_area_fraction')
humidity=$(echo "$weather_data" | jq '.properties.timeseries[0].data.instant.details.relative_humidity')
wind_speed=$(echo "$weather_data" | jq '.properties.timeseries[0].data.instant.details.wind_speed')

# Output for Check_MK
echo "0 WeatherSensors temperature=air_temperature=$air_temperature air_pressure=$air_pressure cloud_fraction=$cloud_fraction humidity=$humidity wind_speed=$wind_speed core0_temp=$core0_temp core1_temp=$core1_temp"

Forklaring av Skriptet:

  • sensors kommando: Brukes for å hente temperaturmålinger fra systemets sensorer.
  • curl kommando: Henter værdata fra MET.no API.
  • jq verktøy: Brukes til å parse JSON-data fra API-svaret.
  • Output: Formateres slik at Check_MK kan lese det som en lokal sjekk. 0 foran indikerer at sjekken er OK (ingen feil), etterfulgt av målingene.

Steg 2: Gjør Skriptet Kjørbart

Kjør følgende kommando for å gjøre skriptet kjørbart:

chmod +x /usr/lib/check_mk_agent/local/weather_sensors_check.sh

Steg 3: Konfigurere Check_MK for å Bruke Local Check

  1. Distribuer endringer: Hvis Check_MK-agenten din allerede er konfigurert til å kjøre lokale sjekker, vil den automatisk hente utdata fra skriptet ved neste sjekk.
  2. Verifiser sjekkene: Gå til Check_MK webgrensesnitt og se etter den nye "WeatherSensors" tjenesten som vises under verten.

Steg 4: Opprette en Tilpasset Graf i Check_MK

Bruk grafdefinisjonen vi lagde tidligere til å opprette en graf som kombinerer værdata og systemtemperaturer. Plasser dette under web/plugins/graphs/weather_sensors.py.

from cmk.gui.i18n import _
from cmk.gui.plugins.metrics import metric_info

# Definer metrikker for sensordata
metric_info.update({
    "air_temperature": {
        "title": _("Air Temperature"),
        "unit": "°C",
        "color": "12/a",
    },
    "air_pressure": {
        "title": _("Air Pressure"),
        "unit": "hPa",
        "color": "10/a",
    },
    "cloud_fraction": {
        "title": _("Cloud Area Fraction"),
        "unit": "%",
        "color": "13/a",
    },
    "humidity": {
        "title": _("Relative Humidity"),
        "unit": "%",
        "color": "14/a",
    },
    "wind_speed": {
        "title": _("Wind Speed"),
        "unit": "m/s",
        "color": "15/a",
    },
    "core0_temp": {
        "title": _("Core 0 Temperature"),
        "unit": "°C",
        "color": "20/a",
    },
    "core1_temp": {
        "title": _("Core 1 Temperature"),
        "unit": "°C",
        "color": "21/a",
    },
})

graph_info["weather_sensors"] = {
    "title": _("Weather and System Temperature Data"),
    "metrics": [
        ("air_temperature", "line"),
        ("air_pressure", "line"),
        ("cloud_fraction", "area"),
        ("humidity", "line"),
        ("wind_speed", "line"),
        ("core0_temp", "line"),
        ("core1_temp", "line"),
    ],
}

Fordeler med Denne Tilnærmingen

  1. Ingen eksterne API-kall nødvendig: All data hentes internt i Check_MK, noe som reduserer avhengigheter og potensielle feil.
  2. Sanntidsdata: Skriptet gir umiddelbare oppdateringer av både værdata og sensordata.
  3. Optimalisering: Dette er en lettvektsmetode som ikke krever bruk av eksterne programmeringsgrensesnitt.

Oppsummering

Ved å bruke Local Checks i Check_MK kan du hente inn sanntidsdata fra systemets sensorer og eksterne værkilder, og visualisere dem i en tilpasset graf. Dette gir en helhetlig oversikt over hvordan eksterne faktorer påvirker temperaturene i systemet ditt.