check_mk_DEV_EG400_P001 - itnett/FTD02H-N GitHub Wiki

v4.3.3.20

For å lage et komplett skript som sjekker alle relevante aspekter av routeren din og håndterer utfordringer som pålogging, flere URL-forsøk, logging, og crawl for fremtidig etablering av overvåkning i Checkmk, kan vi bruke Python med requests-biblioteket for HTTP-forespørsler og logging-biblioteket for logging.

Skriptet vil:

Logge inn på routerens webgrensesnitt.
Hente data fra ulike relevante URL-er.
Håndtere feil, inkludert påloggingsproblemer og behovet for å sende URL-er flere ganger.
Logge all aktivitet og resultater.
Generere en rapport med data som kan brukes i Checkmk for videre overvåkning.

Komplett Python-skript:

import requests
import logging
from time import sleep

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

# Router URL-er og innloggingsinformasjon
base_url = "http://192.168.1.1"
login_url = f"{base_url}/login"
status_urls = [
    "/#!/status-system",
    "/#!/status-system-processes",
    "/#!/network-devices",
]

# Autentisering - Brukernavn og passord
auth = {
    'username': 'admin',  # Endre til ditt brukernavn
    'password': 'admin'   # Endre til ditt passord
}

# Session for å håndtere innlogging og holde cookies
session = requests.Session()

def login_to_router():
    """
    Logger inn på routeren og returnerer om innloggingen var vellykket.
    """
    try:
        response = session.post(login_url, data=auth)
        if response.status_code == 200:
            logging.info('Login successful')
            return True
        else:
            logging.error(f'Login failed: Status code {response.status_code}')
            return False
    except requests.exceptions.RequestException as e:
        logging.error(f'Error during login: {e}')
        return False

def fetch_data(url):
    """
    Henter data fra en gitt URL og returnerer innholdet hvis vellykket.
    Håndterer feil og prøver flere ganger hvis nødvendig.
    """
    full_url = base_url + url
    for attempt in range(3):  # Forsøk opp til 3 ganger
        try:
            response = session.get(full_url)
            if response.status_code == 200:
                logging.info(f'Successfully fetched data from {full_url}')
                return response.text
            else:
                logging.warning(f'Attempt {attempt + 1}: Failed to fetch {full_url} - Status code {response.status_code}')
                sleep(2)  # Vent litt før du prøver igjen
        except requests.exceptions.RequestException as e:
            logging.error(f'Attempt {attempt + 1}: Error fetching {full_url}: {e}')
            sleep(2)
    return None

def crawl_router():
    """
    Logger inn på routeren, henter data fra relevante URL-er, og logger resultatene.
    """
    if not login_to_router():
        logging.error('Login failed. Cannot proceed with data fetching.')
        return
    
    data_collected = {}
    for url in status_urls:
        data = fetch_data(url)
        if data:
            data_collected[url] = data
            logging.info(f'Data collected from {url}: {len(data)} characters')
        else:
            logging.error(f'Failed to collect data from {url}')
    
    # Lagre resultatene til en fil for fremtidig bruk i Checkmk
    with open('router_data_report.txt', 'w') as report_file:
        for url, content in data_collected.items():
            report_file.write(f"URL: {url}\n{'-'*40}\n{content}\n\n")
    
    logging.info('Data collection completed and saved to router_data_report.txt')

if __name__ == "__main__":
    crawl_router()

Forklaring av skriptet:

Logging: Skriptet bruker logging-biblioteket for å logge informasjon om innlogging, datainnhenting, og eventuelle feil som oppstår. Loggfilen lagres som router_monitoring.log.
Innlogging: Funksjonen login_to_router() prøver å logge inn på routeren ved å sende brukernavn og passord til innloggings-URL-en. Den returnerer True hvis innloggingen lykkes, ellers False.
Datainnhenting: Funksjonen fetch_data(url) henter data fra en gitt URL. Den håndterer HTTP-feil og prøver opptil tre ganger før den gir opp.
Crawling: Funksjonen crawl_router() kaller innloggingsfunksjonen, henter data fra de relevante URL-ene, og lagrer resultatene i en fil (router_data_report.txt) som kan brukes til videre oppsett i Checkmk.
Feilhåndtering: Skriptet håndterer nettverksfeil, påloggingsproblemer, og forsøk på å sende forespørsler flere ganger før det gir opp.

Hvordan bruke dette skriptet:

Installer avhengigheter:
- Sørg for at Python er installert, og installer requests-biblioteket hvis du ikke allerede har det:
```
pip install requests
```
Konfigurer skriptet:
- Endre auth-variabelen til riktig brukernavn og passord for routeren din.
Kjør skriptet:
- Kjør skriptet fra kommandolinjen:
```
python router_monitoring.py
```
Analyser resultater:
- Sjekk router_data_report.txt for innsamlede data som kan brukes til å sette opp overvåkning i Checkmk.

Neste steg:

Bruk de innsamlede dataene til å definere spesifikke sjekker i Checkmk som overvåker de relevante aspektene ved routerens status og ytelse.
Tilpass skriptet etter behov for å hente flere data eller integrere med andre verktøy og systemer.

Hvis du har flere spørsmål eller trenger hjelp med noe spesielt, bare gi beskjed!

For å sette opp overvåkning av routeren din med Checkmk, må du konfigurere Checkmk til å overvåke routerens tilstand og ytelse via tilgjengelige metoder som HTTP, SNMP, eller API-er, avhengig av hva routeren støtter. La oss gå gjennom trinnene for hvordan du kan sette dette opp.

Trinn-for-trinn veiledning for å konfigurere overvåkning av routeren din med Checkmk:

1. Bestem overvåkningsmetoden

HTTP- eller HTTPS-basert overvåkning: Hvis routeren din har et webgrensesnitt, kan du bruke Checkmk til å sjekke spesifikke URL-er og overvåke responsstatus, lastetid, og spesifikke innholdselementer.
SNMP-basert overvåkning: SNMP (Simple Network Management Protocol) er en standard protokoll for nettverksadministrasjon og overvåkning. Hvis routeren din støtter SNMP, kan du bruke Checkmk til å hente ut detaljerte nettverksdata, som CPU-bruk, minnebruk, trafikkstatistikk, etc.
API-basert overvåkning: Hvis routeren din støtter et API (f.eks., REST eller SOAP), kan du bruke Checkmk til å sende API-forespørsler for å hente spesifikke data.

2. Konfigurer SNMP-overvåkning

Hvis routeren støtter SNMP, gjør følgende:

Aktiver SNMP på routeren:
- Logg inn på routerens administrasjonsgrensesnitt (vanligvis via http://192.168.1.1 eller en annen adresse).
- Gå til SNMP-innstillingene, og aktiver SNMP. Konfigurer SNMP-versjon (v1, v2c, eller v3), og legg inn nødvendige detaljer som fellesnavn (community string) og tilgangsnivå.
Konfigurer Checkmk til å overvåke SNMP:
- Gå til Checkmk-webgrensesnittet.
- Gå til Setup → Hosts → Add Host.
- Legg til routeren som en ny vert (host). Sett IP-adressen til routeren (192.168.1.1 eller hva det måtte være).
- Under "SNMP Credentials", velg riktig SNMP-versjon, og legg inn fellesnavnet (community string).
- Lagre og bruk endringene.

3. Konfigurer HTTP-basert overvåkning

Hvis routeren ikke støtter SNMP, men har et webgrensesnitt:

Opprett en HTTP-sjekk:
- Gå til Setup → Services → HTTP, TCP, Email, DNS.
- Velg Check HTTP service.
- Angi URL-en til routerens webgrensesnitt, f.eks. http://192.168.1.1.
- Konfigurer autentisering hvis nødvendig ved å legge inn brukernavn og passord.
- Sett opp innholdssjekker eller terskler basert på hva du ønsker å overvåke, som responskode, lastetid, spesifikke ord i innholdet, osv.
- Lagre og bruk endringene.

4. Konfigurer API-basert overvåkning

Hvis routeren din støtter et API:

Sett opp et script for API-forespørsel:

Lag et Python- eller Bash-script som sender forespørsler til routerens API for å hente ønsket informasjon.

Eksempel på et Python-script som henter CPU-bruk via REST API:

import requests

# URL til API-endepunktet
url = "http://192.168.1.1/api/v1/system/status"

# Legg til autentisering hvis nødvendig
response = requests.get(url, auth=('username', 'password'))

# Sjekk responsen og skriv ut nødvendig data
if response.status_code == 200:
    data = response.json()
    print(f"CPU Usage: {data['cpu_usage']}")
else:
    print("Failed to fetch data from API.")

Integrer scriptet i Checkmk:
- Gå til Setup → Integrations → Local Checks.
- Last opp scriptet og definer hvordan resultatene skal tolkes i Checkmk.
- Sett opp terskler og varsler for ulike metrikker (f.eks., CPU-bruk over 80%).

5. Lagre og bruk endringer

Når du har konfigurert ønskede sjekker, lagre endringene og bruk dem i Checkmk.
Sjekk at dataene blir hentet korrekt fra routeren, og sett opp varslinger basert på dine preferanser.

Ekstra tips:

Dokumenter innstillingene: Hold en logg over innstillinger og endringer som gjøres på routeren og Checkmk for feilsøking i fremtiden.
Sjekk routerens dokumentasjon: Hvis noe ikke fungerer som forventet, se i routerens manual (som du har lastet opp) for flere detaljer om funksjoner og kompatibilitet.

Hvis du trenger mer spesifikk hjelp eller detaljer om noen av trinnene, gi beskjed!

API-er (Application Programming Interfaces) gir en standardisert måte for programmer å kommunisere med hverandre over et nettverk, og dette er svært relevant når det gjelder overvåkning av nettverksutstyr som routere.

API-typer brukt i overvåkning:

SOAP API:
- SOAP (Simple Object Access Protocol) er en protokoll for utveksling av strukturerte informasjoner i et XML-format. Den er streng og krever at all data er strukturert i henhold til W3C-standarder.
- Fordel: Passer godt for komplekse integrasjoner hvor sikkerhet og transaksjonsstøtte er viktig.
- Ulempe: Kan være mer komplisert og tungvint sammenlignet med REST.
REST API:
- REST (Representational State Transfer) er et enklere og mer fleksibelt alternativ som vanligvis bruker HTTP-protokollen. Her sendes parameterne som en del av URI eller som forespørselsparametere, ofte i JSON- eller XML-format.
- Fordel: Lett å bruke, raskt og fleksibelt, med mindre overhead enn SOAP.
- Ulempe: Mindre formell standardisering enn SOAP.

Hvordan bruke API-er for å overvåke routeren:

Hvis routeren din støtter et API, kan du bruke enten SOAP- eller REST-forespørsler til å hente informasjon om nettverksenheter, prosesser, systemstatus osv. Checkmk kan integreres med API-er ved å lage skript eller kommandoer som kjører API-forespørsler og analyserer responsen for relevante data.

Eksempel på REST API-overvåkning med Checkmk:

Definer en REST-sjekk i Checkmk:
- Gå til Setup → Services → HTTP, TCP, Email, DNS.
- Velg Check HTTP service og spesifiser detaljene for REST API-endepunktet (f.eks., http://192.168.1.1/api/v1/system/status).
Autentisering:
- Hvis API-et krever autentisering, konfigurer nødvendige autentiseringsdetaljer (Basic Auth, token-baserte systemer, etc.).
Behandle responsen:
- Skriv regler for å analysere responsen fra API-et, som å sjekke statuskoder eller spesifikke verdier i JSON-responsen for CPU-bruk, minnebruk, nettverksdata osv.

Neste steg:

Sjekk dokumentasjonen for routeren din for å se om den støtter API-er, og hvilke operasjoner (GET, POST, etc.) den tillater.
Sjekk hvordan du kan integrere disse API-ene med Checkmk for å forbedre overvåkningen av nettverksinfrastrukturen din.

Dersom du trenger hjelp med et spesifikt API eller integrering, er det bare å spørre!

For å overvåke en enhet som ikke sender logger automatisk, kan du bruke skreddersydde webkall til enhetens API eller webgrensesnitt for å hente nødvendig informasjon. Her er en fremgangsmåte for å sette opp overvåkning ved å lage skreddersydde webkall ved hjelp av et Python-skript og integrere dette med Checkmk.

1. Lage et Skript for Skreddersydde Webkall

For å overvåke enheten din, kan du bruke Python med requests-biblioteket til å sende HTTP-forespørsler til enhetens webgrensesnitt eller API. Skriptet vil utføre følgende trinn:

Logge inn på enheten om nødvendig.
Hente relevante data ved å gjøre HTTP GET- eller POST-forespørsler.
Analysere svarene for å avgjøre enhetens status.
Generere resultater som kan brukes i Checkmk for videre overvåkning.

Eksempel på Python-skript:

import requests
import logging
from time import sleep

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

# Enhetsinformasjon
base_url = "http://your-device-ip"  # Erstatt med enhetens IP-adresse eller URL
login_url = f"{base_url}/login"
status_urls = [
    "/status",  # URL-er som må sjekkes for å hente status
    "/metrics",
]

# Autentisering - Brukernavn og passord for innlogging
auth_data = {
    'username': 'admin',  # Erstatt med riktig brukernavn
    'password': 'admin'   # Erstatt med riktig passord
}

# Session for å håndtere innlogging og holde cookies
session = requests.Session()

def login_to_device():
    """
    Logger inn på enheten og returnerer om innloggingen var vellykket.
    """
    try:
        response = session.post(login_url, data=auth_data)
        if response.status_code == 200:
            logging.info('Login successful')
            return True
        else:
            logging.error(f'Login failed: Status code {response.status_code}')
            return False
    except requests.exceptions.RequestException as e:
        logging.error(f'Error during login: {e}')
        return False

def fetch_data(url):
    """
    Henter data fra en gitt URL og returnerer innholdet hvis vellykket.
    Håndterer feil og prøver flere ganger hvis nødvendig.
    """
    full_url = base_url + url
    for attempt in range(3):  # Forsøk opp til 3 ganger
        try:
            response = session.get(full_url)
            if response.status_code == 200:
                logging.info(f'Successfully fetched data from {full_url}')
                return response.text
            else:
                logging.warning(f'Attempt {attempt + 1}: Failed to fetch {full_url} - Status code {response.status_code}')
                sleep(2)  # Vent litt før du prøver igjen
        except requests.exceptions.RequestException as e:
            logging.error(f'Attempt {attempt + 1}: Error fetching {full_url}: {e}')
            sleep(2)
    return None

def crawl_device():
    """
    Logger inn på enheten, henter data fra relevante URL-er, og logger resultatene.
    """
    if not login_to_device():
        logging.error('Login failed. Cannot proceed with data fetching.')
        return
    
    data_collected = {}
    for url in status_urls:
        data = fetch_data(url)
        if data:
            data_collected[url] = data
            logging.info(f'Data collected from {url}: {len(data)} characters')
        else:
            logging.error(f'Failed to collect data from {url}')
    
    # Lagre resultatene til en fil for fremtidig bruk i Checkmk
    with open('device_data_report.txt', 'w') as report_file:
        for url, content in data_collected.items():
            report_file.write(f"URL: {url}\n{'-'*40}\n{content}\n\n")
    
    logging.info('Data collection completed and saved to device_data_report.txt')

if __name__ == "__main__":
    crawl_device()

2. Integrere Skriptet med Checkmk

Når du har opprettet et skript for å hente data fra enheten din, kan du integrere dette med Checkmk ved å bruke en lokal sjekk. Følg disse trinnene:

Opprett en lokal sjekk i Checkmk:

På Checkmk-serveren, gå til katalogen for lokale sjekker:
```
cd /usr/lib/check_mk_agent/local/
```
Opprett et nytt skript i denne katalogen, for eksempel device_check.sh:
```
nano device_check.sh
```

Lim inn følgende innhold i filen:

#!/bin/bash

python /path/to/your/script.py  # Endre til riktig sti til Python-skriptet ditt

# Les data fra rapportfilen og generer output for Checkmk
if grep -q "Failed" device_data_report.txt; then
    echo "2 Device_Status - Enheten har problemer - se loggfil"
else
    echo "0 Device_Status - Enheten fungerer som forventet"
fi

Lagre filen og gjør den kjørbar:
```
chmod +x device_check.sh
```

Konfigurer Checkmk til å oppdage den lokale sjekken:
- Gå til Checkmk-webgrensesnittet, velg verten der du la til den lokale sjekken, og klikk "Save & Apply".
Sjekk statusen til enheten:
- Etter at konfigurasjonen er brukt, vil den lokale sjekken kjøre på planlagte intervaller, og du kan se statusen i Checkmk-grensesnittet.

3. Neste Trinn

Utvid skriptet: Legg til flere URL-er eller API-kall for å hente mer detaljert informasjon fra enheten.
Automatiser varsler: Konfigurer varsler i Checkmk basert på resultatene fra den lokale sjekken.
Logganalyse: Bruk Nagios Log Server eller Checkmk's logganalysefunksjoner for å analysere loggene generert av skriptet for enda dypere innsikt.

Dersom du trenger hjelp med spesifikke API-kall eller ytterligere tilpasning, gi meg beskjed!

Based on the content from the documents you provided, here's a plan for creating a script that makes HTTP requests to every available page and tab of the router's web interface to gather relevant information for monitoring purposes.

Comprehensive Python Script for Monitoring All Pages and Tabs of the Router

The goal is to create a Python script that navigates through all the relevant pages and tabs listed in the documentation to gather status data. The script will handle logging in, fetching data from each page, and logging the results.

Key Pages and Tabs to Monitor

The script should cover the following pages and tabs based on the router's web interface sections:

Overview
Device Network Map
Status Panels
WIFI (2.4GHz and 5GHz)
LAN (General, Client Overview, Static DHCP, etc.)
WAN (General, Physical Settings, Advanced)
USB, Voice, DECT Radio, and SIP Settings
Firewall, Port Forwarding, Parental Control
Realtime Graphs (WiFi, Load, Traffic)
Advanced Settings (SIP, Number Blocking, etc.)
Network (Devices, Ethernet, VLAN, etc.)
Diagnostic Tools (Ping, Trace, Speed Test)

Python Script

import requests
import logging
from time import sleep

# Configure logging
logging.basicConfig(filename='router_full_monitoring.log', level=logging.INFO, 
                    format='%(asctime)s - %(levelname)s - %(message)s')

# Base URL for the router
base_url = "http://192.168.1.1"  # Replace with your router's IP
login_url = f"{base_url}/login"
status_urls = [
    "/overview",
    "/device-network-map",
    "/status-panels",
    "/wifi",
    "/wifi-2.4GHz",
    "/wifi-5GHz",
    "/lan",
    "/lan-settings",
    "/static-dhcp",
    "/wan",
    "/wan-physical-settings",
    "/wan-advanced",
    "/usb",
    "/voice",
    "/dect-radio",
    "/sip-settings",
    "/firewall",
    "/port-forwarding",
    "/parental-control",
    "/realtime-graphs",
    "/realtime-graphs-wifi",
    "/realtime-graphs-load",
    "/realtime-graphs-traffic",
    "/advanced-settings-sip",
    "/number-blocking",
    "/network-devices",
    "/network-ethernet",
    "/network-vlan",
    "/diagnostics",
    "/ping",
    "/trace",
    "/speed-test"
]

# Authentication data (replace with your credentials)
auth_data = {
    'username': 'admin',  # Replace with actual username
    'password': 'admin'   # Replace with actual password
}

# Session to handle login and maintain cookies
session = requests.Session()

def login_to_router():
    """
    Logs in to the router and returns whether login was successful.
    """
    try:
        response = session.post(login_url, data=auth_data)
        if response.status_code == 200:
            logging.info('Login successful')
            return True
        else:
            logging.error(f'Login failed: Status code {response.status_code}')
            return False
    except requests.exceptions.RequestException as e:
        logging.error(f'Error during login: {e}')
        return False

def fetch_data(url):
    """
    Fetches data from a given URL and returns the content if successful.
    Handles errors and retries multiple times if necessary.
    """
    full_url = base_url + url
    for attempt in range(3):  # Try up to 3 times
        try:
            response = session.get(full_url)
            if response.status_code == 200:
                logging.info(f'Successfully fetched data from {full_url}')
                return response.text
            else:
                logging.warning(f'Attempt {attempt + 1}: Failed to fetch {full_url} - Status code {response.status_code}')
                sleep(2)  # Wait before retrying
        except requests.exceptions.RequestException as e:
            logging.error(f'Attempt {attempt + 1}: Error fetching {full_url}: {e}')
            sleep(2)
    return None

def crawl_router():
    """
    Logs in to the router, fetches data from all relevant URLs, and logs the results.
    """
    if not login_to_router():
        logging.error('Login failed. Cannot proceed with data fetching.')
        return
    
    data_collected = {}
    for url in status_urls:
        data = fetch_data(url)
        if data:
            data_collected[url] = data
            logging.info(f'Data collected from {url}: {len(data)} characters')
        else:
            logging.error(f'Failed to collect data from {url}')
    
    # Save the results to a file for future use in Checkmk
    with open('router_full_data_report.txt', 'w') as report_file:
        for url, content in data_collected.items():
            report_file.write(f"URL: {url}\n{'-'*40}\n{content}\n\n")
    
    logging.info('Data collection completed and saved to router_full_data_report.txt')

if __name__ == "__main__":
    crawl_router()

Explanation of the Script

Logging Configuration: The script sets up a log file (router_full_monitoring.log) to record all actions, successes, and errors.
Login Function: login_to_router() handles authentication to the router.
Data Fetching Function: fetch_data(url) makes HTTP GET requests to each URL, with retries for handling errors.
Main Crawling Function: crawl_router() logs in, fetches data from all specified URLs, and saves the collected data to router_full_data_report.txt.

How to Use This Script

Set Up Python Environment:
- Install Python and the requests library if not already installed:
```
pip install requests
```
Customize the Script:
- Replace the base_url and auth_data with your router's IP address and login credentials.
Run the Script:
- Execute the script from the command line:
```
python router_monitoring.py
```
Review Results:
- Check the router_full_data_report.txt file for all collected data.
- Use this data to configure specific checks in Checkmk.

Next Steps

Integrate with Checkmk: Use the collected data to define checks in Checkmk for monitoring key parameters.
Automate the Script: Set up a cron job or a scheduled task to run this script periodically.
Enhance Error Handling: Expand error handling to manage more specific errors or edge cases related to network issues.

Would you like any further customization or help with a specific part of this integration?