Unifi WAN IP Änderung: So einfach erhältst Du Benachrichtigungen – Snippets aus der Praxis

Snippets aus der Praxis – Unifi WAN IP Änderung

Ausgangslage: Ich nutze kein DynDNS, möchte aber dennoch per Remote/VPN auf meinen Raspberry oder andere Geräte zugreifen können.
Weiterhin betreibe ich diverse Teststages, auf die sonst niemand zugreifen soll. Daher erlaube ich dort unter anderem nur “meiner” IP Adresse den Zugriff. Und mein ISP stellt mir in meinem Tarif nur eine dynamische IP Adresse zur Verfügung.

Problemchen: Meine Teststages müsste ich, nach einer WAN IP Änderung, jedes mal im Backend manuell aktualisieren.
Außerdem hätte ich mit meiner “alten” IP dann keinen Zugriff mehr via VPN/Remote und müsste immer erst die neue IP herausfinden.

Gedanken: Ich bin faul und möchte nicht so viel manuell ändern müssen. Daher sollte dies ein Skript für mich übernehmen. Dieses muss ohne einen weiteren Dienst auskommen, also auch keinen cURL an irgendeine Seite senden.
Damit ich, sollte ich unterwegs sein, auch nach einem IP-Adressen Wechsel direkt wieder Zugriff auf meine Geräte habe, müsste mir das Skript die neue IP per E-Mail senden.

Was ich will: Mhhh.. habe ich ja schon irgendwie bei den Gedanken geschrieben. Also ein Skript, das bei einer WAN IP Änderung mir diverse Arbeit abnimmt und mich per E-Mail informiert.

Unifi WAN IP Änderung – Vorgehensweise

Die Idee – oder der Bedarf – wurde geboren und muss jetzt nur noch umgesetzt werden.
Da ich bereits eine ziemlich klare Vorstellung davon habe, was das Skript erledigen soll und welche Vorrausetzungen vorhanden sind, kann ich mir mein eigenes kleines Brainstorming sparen.

Eine kurze Zusammenfassung:

• Skript muss die WAN-IP auslesen (keinen cURL, keinen Dienst nutzen)
• Dafür muss mein Router/Modem/Gateway eine API anbieten (Unifi Ubiquiti Gateway)
• Vergleichen der Alten mit der Neuen WAN IP
• Bei Änderung Mail senden und ein weiteres Skript aufrufen welches die IP in diversen Dateien ändert
• Das ganze auf einem Raspberry per crontab laufen lassen

Werbung

Vorschau	Produkt	Preis
	Ubiquiti Next-Generation Gateway Pro (UXG-PRO), schwarz	523,82 EUR	Bei Amazon kaufen
	Ubiquiti UniFi Dream Machine All-in-One Router (With 2…	310,75 EUR 300,79 EUR	Bei Amazon kaufen
	Python 3: Das umfassende Handbuch: Über 1.000 Seiten…	44,90 EUR	Bei Amazon kaufen
	Python 3: Lernen und professionell anwenden. Das…	49,99 EUR	Bei Amazon kaufen

Letzte Aktualisierung am 26.04.2024 (Preise können abweichen) / Infos zu Affiliate Links / Bilder von der Amazon Product Advertising API

Affiliate – Links

DarkWolfCave.de ist Teilnehmer des Amazon-Partnerprogramm, das zur Bereitstellung eines Mediums für Webseiten konzipiert wurde, mittels dessen durch die Platzierung von Partner-Links zu Amazon.de Entgelte verdient werden können.

Weitere Infos zu Affiliate-Links

Dann mal los – bauen wir uns ein Python Skript

Die Entscheidung ob ich ein Shell oder Python Skript erstellen werde, wurde mir von meinem Gateway/Router abgenommen.
Dieser bietet eine Schnittstelle (API) an, die ich sehr gut über Python ansteuern kann.
Es gibt dazu sogar diverse fertige client classes für Python und PHP, allerdings benötige ich diese ganzen Funktionen nicht.
Daher bastle ich mir eine eigene kleine Funktion, die dann die WAN-IP aus meinem Unifi Gateway USG auslesen kann.
Danach wird automatisch geprüft ob es eine Änderung gab und im positive Fall eine Benachrichtigung per E-Mail versendet.

Bei mir läuft, wie immer, alles auf einem Raspberry Pi. Dort soll dann auch das neue Skript liegen. Daher verbinde ich mich per SSH und suche mir ein schönes Verzeichnis um es dort anzulegen.
Dazu empfehle ich weiterhin MobaXterm.

Jetzt soll das ganze ja ein Python Skript werden. Und wer schon einmal mit Python gearbeitet hat, wird wissen dass das “Einrücken” sehr wichtig ist.
Ich persönlich bin mit vi oder nano dann immer ein wenig auf Kriegspfad und nutze daher schon länger PyCharm lokal auf meinem PC.
Im Prinzip erstelle ich am PC erst das File und lade es danach dann auf den Raspberry. Du kannst aber natürlich auch direkt per Remote auf deinem Raspberry das File erstellen.

Auf meinem Raspberry lege ich mir eine Ordnerstruktur an: /tutorials/unifi_tut/checkip_2023
Dort wird dann wan_ip_change_check.py gespeichert.

Unifi WAN IP Änderung Benachrichtigung – Grobe Erklärung

Eins vorweg: In dieser Version speichere ich alle Zugangsdaten direkt in dem Python Skript. Zum testen und für den privaten Gebrauch ist das mehr oder weniger ok.

Fangen wir an und importieren die notwendigen Bibliotheken:

import smtplib  # für Connection zu einem smtp-Server
from email.mime.text import MIMEText
import requests
import json
import urllib3
import paramiko # für ssh
import os
import datetime

Da wir später im Skript HTTPS Anfragen an eine unsichere Seite senden werden (im lokalen Netz hab ich kein Zertifikat…) müssen wir noch entsprechende Warnmeldungen blockieren:

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

Weiterhin benötigen wir Zugriff auf die unifi API. Solltest du einen anderen Router benutzen, dann wird dieses Skript bei dir so nicht funktionieren. Selbst innerhalb der unifi Geräte gibt es Unterschiede in der genutzten API.
Ich habe es lediglich für meine Ansprüche mit einem Unifi Gateway USG getestet.

Als User kannst du deinen Admin – den du in der Controller-Software eingerichtet hast – nehmen, oder dir einen neuen dort anlegen. Da er nichts ändern soll, würde ein readonly Zugang ausreichen.

• gateway = hier muss die IP und der Port hinein wo dein unifi Controller läuft
• headers = wir wollen in einem json Format etwas senden
• loginUrl = Endpoint zum einloggen
• url = hier bauen wir die gesamte URL einfach nur zusammen
• auth = dein unifi Controller User mit Passwort

# Zugänge zum unifi Gateway
gateway = {"ip": "192.168.1.36", "port": "8443"}
headers = {"Accept": "application/json", "Content-Type": "application/json"}
loginUrl = 'api/login'
url = f"https://{gateway['ip']}:{gateway['port']}/{loginUrl}"
auth = {"username": "UNIFI-Controller-USER", "password": "DEIN PASSWORT"}

Als nächstes erstelle ich eine Funktion um eine SSH-Verbindung zu einem anderen Server aufzubauen. Diese benötige ich später um dort ein weiteres Skript zu starten, welches dann die IP Adresse in diversen Dateien ändert.

Weiterhin nutze ich dafür Daten, die auf dem Raspberry unter dem entsprechendem User in .ssh/config eingerichtet sind. Mehr dazu findest du in dem entsprechenden Artikel.
Alle weiteren Erklärungen findest du in dem Sourcecode als Kommentar:

def ssh_command(host_name, command):
    # Lese SSH-Konfiguration aus der .ssh/config-Datei
    ssh_config_file = os.path.expanduser('~/.ssh/config')  # Pfade können je nach System variieren
    ssh_config = paramiko.SSHConfig()
    ssh_config.parse(open(ssh_config_file))

    # Hole die Verbindungsinformationen für den angegebenen Host aus der Konfiguration
    host_config = ssh_config.lookup(host_name)

    # Stelle eine SSH-Verbindung her
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

    try:
        # Verbinde dich mit den Informationen aus der Konfiguration
        ssh.connect(
            host_config['hostname'],
            username=host_config.get('user', None),
            port=int(host_config.get('port', 22)),  # Standard-Port, wenn nicht in der Konfiguration angegeben
            key_filename=host_config.get('identityfile', None)  # SSH-Schlüssel, wenn in der Konfiguration angegeben
        )

        # Befehl ausführen
        stdin, stdout, stderr = ssh.exec_command(command)

        # Befehlausgabe lesen
        output = stdout.read().decode('utf-8')
        error = stderr.read().decode('utf-8')

        # Befehlausgabe ausgeben
        print('Befehlausgabe:')
        print(output)

        # Fehlerausgabe ausgeben
        if error:
            print('Fehler:')
            print(error)
    except Exception as e:
        print(f'Fehler bei der SSH-Verbindung: {str(e)}')
    finally:
        # SSH-Verbindung schließen, unabhängig vom Erfolg oder Fehler
        ssh.close()

Damit wir die unifi API nutzen können, müssen wir eine Session starten.
Innerhalb dieser “bewegen” wir uns dann. Zu erkennen an dem session. vor jedem weiteren Befehl:

session = requests.Session()
response = session.post(url, headers=headers, data=json.dumps(auth), verify=False)

Starten wir den Verbindungsversuch mit der Überprüfung ob es auch geklappt hat:

# Überprüfe die erfolgreiche Anmeldung
if response.status_code != 200:
    print(f"Fehler bei der Anmeldung: {response.status_code}")
    exit()

Im Fehlerfall wird das Skript beendet. Ansonsten geht es lustig weiter und wir rufen die aktuelle WAN IP ab:

# Rufe die WAN-IP-Adresse ab
wan_ip_url = f"https://{gateway['ip']}:{gateway['port']}/api/s/default/stat/health"
data = session.get(wan_ip_url).json()

if "wan_ip" in data["data"][1]:
    wan_ip = data["data"][1]["wan_ip"]
    print(f'Deine WAN-IP-Adresse ist: {wan_ip}')

Jetzt wollen wir die aktuelle WAN IP mit der zuletzt gespeicherten vergleichen. Damit bei dem allerersten Durchlauf – bei dem ja noch keine Textdatei mit einer IP vorhanden ist – kein Fehler ausgegeben wird, werden wir diesen entsprechend abfangen.

# Lese die vorherige WAN-IP-Adresse aus der Textdatei
    try:
        # Versuche, die vorherige WAN-IP-Adresse aus der Textdatei zu lesen
        with open('wan_ip.txt', 'r') as file:
            previous_ip = file.read()
    except FileNotFoundError:
        # Wenn die Datei nicht gefunden wird, erstelle sie und speichere die aktuelle WAN-IP
        with open('wan_ip.txt', 'w') as file:
            file.write(wan_ip)
            print('Textdatei "wan_ip.txt" wurde erstellt.')
            previous_ip = wan_ip

    # Vergleiche die aktuelle WAN-IP mit der vorherigen WAN-IP
    if wan_ip == previous_ip:
        print("Die WAN-IP hat sich nicht geändert.")

Kommen wir jetzt zu der “else:”. In diesem Block definieren wir, was geschehen soll wenn sich die WAN IP von der zuletzt gespeicherten verändert hat.

Ich gebe das aktuelle Datum und die Uhrzeit aus, dieses wird später per crontab in ein Log geschrieben. So kann ich nachvollziehen wann es eine WAN IP Änderung gegeben hat.

Danach rufe ich die ssh_command Funktion auf und übergebe an ein Skript die neue IP Adresse. Ich nutze dafür ein ähnliches Skript wie ich es unter Webseite nur für eine IP freigeben – Snippets aus der Praxis verwendet habe.
Zu beachten wären folgende Werte, hier muss zum einen der Host-Name, wie du ihn in deiner .ssh/config Datei benannt hast, hinein.
Und zum anderen der Pfad auf dem Remote-Server zu dem entsprechenden Skript, welches aufgerufen werden soll:

• host_name = ‘DER NAME IN DER .ssh/config Datei!’
• command_to_execute = ‘/PFAD zum anderen Skript/dwc-test.sh ‘ + wan_ip

    else:

        # Aktuelles Datum und Uhrzeit abrufen
        aktuelles_datum_uhrzeit = datetime.datetime.now()

        # Ausgabe des aktuellen Datum und Uhrzeit im gewünschten Format
        formatiertes_datum_uhrzeit = aktuelles_datum_uhrzeit.strftime("%d-%m-%Y %H:%M:%S")
        print("Aktuelles Datum und Uhrzeit:", formatiertes_datum_uhrzeit)
        print(f'Die WAN-IP hat sich geändert.\nAlte: {previous_ip}\nNeue: {wan_ip}\nAktualisiere die Textdatei und ändere .htaccess.')
        # Verbindung zum Server und Aufruf eines SH-Skripts
        # zum Ändern der IP in den .htaccess Dateien
        host_name = 'DER NAME IN DER .ssh/config Datei!'
        command_to_execute = '/PFAD zum anderen Skript/dwc-test.sh ' + wan_ip
        ssh_command(host_name, command_to_execute)

Danach soll eine E-Mail an mich versendet werden. So kann ich auch von unterwegs mit der neuen WAN IP direkt wieder eine Remote Verbindung herstellen. Außerdem ist es immer gut zu wissen wenn sich die IP ändert.

Hier sind dann einige Änderungen/Anpassung von dir notwendig:

• smtplib.SMTP = smtp und Port von deinem Mail-Anbieter (oder Mail-Server)
• server.login = Zugangsdaten zu deinem E-Mail Konto
• msg[‘Subject’] = Betreff der EMail festlegen
• msg[‘From’] = Der Absender
• msg[‘To’] = Empfänger

Am Ende wird dann die neue WAN IP in die Textdatei geschrieben:

server = smtplib.SMTP('smtp.DEIN-ANBIETER', 587)
        server.starttls()
        server.login("USERNAME", "PASSWORT")
        value = "Alte WAN IP: " + previous_ip+"\n \n Neue WAN IP: " + wan_ip
        msg = MIMEText(value)
        msg['Subject'] = "[WICHTIG!] NEUE WAN IP " + wan_ip
        msg['From'] = "DEINE EMAIL als Absender"
        msg['To'] = "EMAIL WOHIN gesendet werden soll"
        server.sendmail(msg['From'], msg['To'], msg.as_string())
        server.quit()
        # Aktualisiere die Textdatei mit der neuen WAN-IP
        with open('wan_ip.txt', 'w') as file:
            file.write(wan_ip)

Final noch angeben was passieren soll wenn wir die WAN IP nicht abfragen konnten und das Logout/Beenden der Unifi-API-Verbindung:

else:
    print('WAN-IP-Adresse konnte nicht abgerufen werden.')

# Abmelden von der UniFi API
logout_url = f"https://{gateway['ip']}:{gateway['port']}/api/logout"
session.get(logout_url)

Herzlichen Glückwunsch – das war auch schon alles in dem Skript. Jetzt lade ich es auf meinem Raspberry (da ich es lokal mit PyCharm erstellt habe) und füge einen neuen Eintrag in crontab hinzu der alle 15 Minuten ausgeführt wird und die “print” Ausgaben in eine LogDatei umleitet:

*/15 * * * * /PFAD-ZUM-SKRIPT/checkip_2023/wan_ip_change_check.py >> /PFAD-ZU-LOGS/checkip.log 2>&1

Unifi WAN IP Änderung – Der komplette Sourcecode

#!/usr/bin/python
# -*- coding: utf-8 -*-
#-----------------------------------------#
# DarkWolfCave.de  Tutorials und Snippets #
#                                         #
# Unifi WAN IP CHANGE Information         #
# Version 0.1 - only for private use      #
#-----------------------------------------#

import smtplib  # für Connection zu einem smtp-Server
from email.mime.text import MIMEText
import requests
import json
import urllib3
import paramiko # für ssh
import os
import datetime

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Zugänge zum unifi Gateway
gateway = {"ip": "192.168.1.36", "port": "8443"}
headers = {"Accept": "application/json", "Content-Type": "application/json"}
loginUrl = 'api/login'
url = f"https://{gateway['ip']}:{gateway['port']}/{loginUrl}"
auth = {"username": "UNIFI-Controller-USER", "password": "DEIN PASSWORT"}

def ssh_command(host_name, command):
    # Lese SSH-Konfiguration aus der .ssh/config-Datei
    ssh_config_file = os.path.expanduser('~/.ssh/config')  # Pfade können je nach System variieren
    ssh_config = paramiko.SSHConfig()
    ssh_config.parse(open(ssh_config_file))

    # Hole die Verbindungsinformationen für den angegebenen Host aus der Konfiguration
    host_config = ssh_config.lookup(host_name)

    # Stelle eine SSH-Verbindung her
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

    try:
        # Verbinde dich mit den Informationen aus der Konfiguration
        ssh.connect(
            host_config['hostname'],
            username=host_config.get('user', None),
            port=int(host_config.get('port', 22)),  # Standard-Port, wenn nicht in der Konfiguration angegeben
            key_filename=host_config.get('identityfile', None)  # SSH-Schlüssel, wenn in der Konfiguration angegeben
        )

        # Befehl ausführen
        stdin, stdout, stderr = ssh.exec_command(command)

        # Befehlausgabe lesen
        output = stdout.read().decode('utf-8')
        error = stderr.read().decode('utf-8')

        # Befehlausgabe ausgeben
        print('Befehlausgabe:')
        print(output)

        # Fehlerausgabe ausgeben
        if error:
            print('Fehler:')
            print(error)
    except Exception as e:
        print(f'Fehler bei der SSH-Verbindung: {str(e)}')
    finally:
        # SSH-Verbindung schließen, unabhängig vom Erfolg oder Fehler
        ssh.close()


session = requests.Session()
response = session.post(url, headers=headers, data=json.dumps(auth), verify=False)

# Überprüfe die erfolgreiche Anmeldung
if response.status_code != 200:
    print(f"Fehler bei der Anmeldung: {response.status_code}")
    exit()

# Rufe die WAN-IP-Adresse ab
wan_ip_url = f"https://{gateway['ip']}:{gateway['port']}/api/s/default/stat/health"
data = session.get(wan_ip_url).json()

if "wan_ip" in data["data"][1]:
    wan_ip = data["data"][1]["wan_ip"]
    print(f'Deine WAN-IP-Adresse ist: {wan_ip}')
# Lese die vorherige WAN-IP-Adresse aus der Textdatei
    try:
        # Versuche, die vorherige WAN-IP-Adresse aus der Textdatei zu lesen
        with open('wan_ip.txt', 'r') as file:
            previous_ip = file.read()
    except FileNotFoundError:
        # Wenn die Datei nicht gefunden wird, erstelle sie und speichere die aktuelle WAN-IP
        with open('wan_ip.txt', 'w') as file:
            file.write(wan_ip)
            print('Textdatei "wan_ip.txt" wurde erstellt.')
            previous_ip = wan_ip

    # Vergleiche die aktuelle WAN-IP mit der vorherigen WAN-IP
    if wan_ip == previous_ip:
        print("Die WAN-IP hat sich nicht geändert.")
    else:

        # Aktuelles Datum und Uhrzeit abrufen
        aktuelles_datum_uhrzeit = datetime.datetime.now()

        # Ausgabe des aktuellen Datum und Uhrzeit im gewünschten Format
        formatiertes_datum_uhrzeit = aktuelles_datum_uhrzeit.strftime("%d-%m-%Y %H:%M:%S")
        print("Aktuelles Datum und Uhrzeit:", formatiertes_datum_uhrzeit)
        print(f'Die WAN-IP hat sich geändert.\nAlte: {previous_ip}\nNeue: {wan_ip}\nAktualisiere die Textdatei und ändere .htaccess.')
        # Verbindung zum Server und Aufruf eines SH-Skripts
        # zum Ändern der IP in den .htaccess Dateien
        host_name = 'DER NAME IN DER .ssh/config Datei!'
        command_to_execute = '/PFAD zum anderen Skript/dwc-test.sh ' + wan_ip
        ssh_command(host_name, command_to_execute)

        server = smtplib.SMTP('smtp.DEIN-ANBIETER', 587)
        server.starttls()
        server.login("USERNAME", "PASSWORT")
        value = "Alte WAN IP: " + previous_ip+"\n \n Neue WAN IP: " + wan_ip
        msg = MIMEText(value)
        msg['Subject'] = "[WICHTIG!] NEUE WAN IP " + wan_ip
        msg['From'] = "DEINE EMAIL als Absender"
        msg['To'] = "EMAIL WOHIN gesendet werden soll"
        server.sendmail(msg['From'], msg['To'], msg.as_string())
        server.quit()
        # Aktualisiere die Textdatei mit der neuen WAN-IP
        with open('wan_ip.txt', 'w') as file:
            file.write(wan_ip)
else:
    print('WAN-IP-Adresse konnte nicht abgerufen werden.')

# Abmelden von der UniFi API
logout_url = f"https://{gateway['ip']}:{gateway['port']}/api/logout"
session.get(logout_url)

FAQ´s

Was ist das Thema der Blog-Reihe “Snippets aus der Praxis”?

In meiner Blog-Reihe “Snippets aus der Praxis” gewähre ich Einblicke in meinen technikbegeisterten Alltag. Dabei zeige ich, wie ich spezifische Herausforderungen angehe und löse. Das heutige Thema beschäftigt sich mit der Unifi WAN IP Änderung und wie du Benachrichtigungen erhalten kannst, um die Kontrolle über dein Netzwerk zu behalten.

Warum ist die Benachrichtigung bei einer WAN IP-Änderung wichtig?

Die WAN IP-Adresse in deinem Unifi-Netzwerk kann sich ändern, was Auswirkungen auf wichtige Aspekte der Netzwerkkommunikation haben kann, wie zum Beispiel den Remote-Zugriff. In diesem Artikel erfährst du, wie du Benachrichtigungen über solche Änderungen erhalten kannst, um die Kontrolle über dein Netzwerk zu behalten.

Warum sollte ich ein solches Skript nutzen?

Ein Skript für die Unifi WAN IP Änderung bietet eine effiziente Lösung, um automatisch über IP-Änderungen informiert zu werden und gleichzeitig entsprechende Anpassungen vorzunehmen. Dies ist besonders nützlich, wenn du Remote- oder VPN-Zugriff auf deine Geräte möchtest und dabei auf eine dynamische IP-Adresse deines Internet Service Providers (ISP) angewiesen bist.

Gibt es Sicherheitshinweise für die Nutzung dieses Skripts?

Ja, es ist wichtig zu beachten, dass dieses Skript für den privaten Gebrauch gedacht ist und keine top professionellen Lösungen bietet. Sicherheitsaspekte, insbesondere in Bezug auf die Speicherung von Zugangsdaten im Skript, sollten individuell betrachtet und angepasst werden. Es dient primär als Anregung für eine schnelle Lösungsfindung im privaten Umfeld.

Kannst du mir alles detailliert und komplett persönlich erklären?

Natürlich! Über eine entsprechende Patreon-Mitgliedschaft biete ich dir einen exklusiven und persönlichen Zugang in Discord an.
Hier stehe ich dir dann für deine Fragen zur Verfügung.
Gerne können wir auch in einem Discord-Call direkt an deinem PC alles Schritt für Schritt durchgehen.
Wenn du also detaillierte Einblicke in meine Blog-Reihe “Snippets aus der Praxis” oder spezifische Fragen zu WordPress, Webentwicklung oder anderen Themen hast, stehe ich dir über die entsprechende Patreon-Mitgliedschaft persönlich zur Verfügung.

Meine Frage steht hier nicht!

Du hast weitere Fragen oder benötigst Hilfe? Gerne versuche ich im Rahmen meiner Möglichkeiten dich zu unterstützen. Dafür kannst du hier die Kommentar-Sektion (nicht vergessen Antworten zu abonnieren) nutzen oder du schaust auf meinem Discord-Kanal vorbei.