aiMOOC

Netzwerke und Systemintegration – Netzwerkdienste im Testsystem prüfen

QR-Code

Netzwerke und Systemintegration – Netzwerkdienste im Testsystem prüfen

Kurzbeschreibung: Erreichbarkeit und erwartete Funktion.

Einleitung

Ein Netzwerkdienst ist sinnvoll geprüft, wenn Du zwei Fragen getrennt beantwortest: Ist der Dienst erreichbar? und liefert er die erwartete Funktion? Ein offener TCP-Port allein beweist noch nicht, dass eine Anwendung fachlich korrekt antwortet. In diesem Lernkurs arbeitest Du deshalb mit der Prüfkette Adresse → Port → Protokoll → Inhalt/Funktion.

Der Kurs richtet sich an Auszubildende, besonders an angehende Fachinformatikerinnen und Fachinformatiker für Systemintegration. Alle praktischen Übungen verwenden ausschließlich localhost, die Loopback-Adresse 127.0.0.1 oder eine ausdrücklich freigegebene, isolierte Testumgebung mit fiktiven Daten.

Sicherheitsregel: Übertrage die gezeigten Befehle nicht ungefragt auf fremde Netze, Produktivsysteme, Kundensysteme oder öffentliche IP-Adressen. Verwende keine echten Zugangsdaten oder Kundendaten.

Lernziele

Nach dem Kurs kannst Du Erreichbarkeit und Funktion eines Netzwerkdienstes unterscheiden, lokale Testdienste starten, erwartete Antworten definieren, Messergebnisse auswerten und Abweichungen systematisch einordnen.

Prüfkette auf einen Blick

Prüfschritt	Leitfrage	Lokales Werkzeug	Beispiel
Adresse	Wird das richtige Ziel verwendet?	localhost / 127.0.0.1	127.0.0.1
Transport	Ist der TCP-Port erreichbar?	Python socket	8080/tcp
Protokoll	Antwortet HTTP formal?	curl	Statuscode 200
Funktion	Ist der erwartete Inhalt vorhanden?	curl + Vergleich	TESTSYSTEM-OK

Warum localhost?

localhost bezeichnet den eigenen Rechner. Für IPv4 wird typischerweise die Loopback-Adresse 127.0.0.1 verwendet, für IPv6 ::1. Dadurch kann ein Netzwerkdienst lokal getestet werden, ohne Pakete in ein fremdes Netz zu senden.

Fehler beim Erstellen des Vorschaubildes:

Ausbildungsfall

Du arbeitest im internen Ausbildungs-Testlabor der fiktiven Firma Beispielwerk GmbH. Für eine Übung soll ein kleiner Statusdienst geprüft werden.

Vorgabe	Erwarteter Wert
Ziel	127.0.0.1
TCP-Port	8080
Protokoll	HTTP
Pfad	/health
Statuscode	200
Inhalt	TESTSYSTEM-OK

Dein Auftrag lautet: Beweise nachvollziehbar, ob der Dienst erreichbar ist und ob er die erwartete Funktion liefert.

Kurze Lerneinheit 1: Erreichbarkeit und Funktion

Ein erfolgreicher Verbindungsaufbau zeigt, dass an einer Adresse und einem Port ein Prozess Verbindungen annimmt. Erst eine protokollgerechte Anfrage mit einer erwarteten Antwort prüft die Funktion.

Merksatz: Ein erfolgreicher Ping beweist nicht die Funktion eines Webdienstes. Prüfe deshalb den Dienst selbst.

Mini-Aufgabe Basis

Ein Test ergibt: TCP-Port 8080 ist erreichbar, die Webanwendung liefert aber nicht die erwartete Antwort. Ist der Netzwerkdienst vollständig funktionsfähig?

Feedback: Nein. Die Transportschicht ist erreichbar, die Anwendung erfüllt jedoch die festgelegte Sollvorgabe nicht. Die Prüfung muss deshalb bis zur Anwendungsebene gehen.

Kurze Lerneinheit 2: Lokalen Testdienst starten

Das folgende Beispiel verwendet nur die Python-Standardbibliothek und bindet den Dienst ausdrücklich an 127.0.0.1. Es werden keine Daten an fremde Systeme übertragen.

from http.server import BaseHTTPRequestHandler, HTTPServer
import json

HOST = "127.0.0.1"
PORT = 8080

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/health":
            body = json.dumps({
                "status": "TESTSYSTEM-OK",
                "system": "ausbildungs-lab"
            }).encode("utf-8")
            self.send_response(200)
            self.send_header("Content-Type", "application/json; charset=utf-8")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
        else:
            self.send_response(404)
            self.end_headers()

    def log_message(self, format, *args):
        pass

HTTPServer((HOST, PORT), Handler).serve_forever()

Speichere den Code als testdienst.py und starte ihn lokal:

python3 testdienst.py

Unter Windows ist je nach Installation auch möglich:

py testdienst.py

Gestufte Hilfe:

Hilfe 1: Prüfe zuerst, ob Python läuft und ob Port 8080 frei ist.
Hilfe 2: Der Dienst muss im Terminal weiterlaufen, während Du in einem zweiten Terminal testest.
Hilfe 3: Verwende als Ziel ausschließlich http://127.0.0.1:8080/health.

Kurze Lerneinheit 3: TCP-Port lokal testen

Mit Python kannst Du ohne zusätzliches Werkzeug prüfen, ob der lokale TCP-Port Verbindungen annimmt:

import socket

ziel = ("127.0.0.1", 8080)

with socket.create_connection(ziel, timeout=2):
    print("TCP erreichbar")

Der Test bewertet ausschließlich den lokalen TCP-Verbindungsaufbau.

Wichtig: Dieser Test sagt noch nichts darüber aus, ob unter dem Port tatsächlich die erwartete HTTP-Funktion verfügbar ist.

Mini-Aufgabe Anwendung

Starte den lokalen Dienst. Führe zuerst den TCP-Test aus. Ändere danach im Client testweise den Port von 8080 auf 8081.

Feedback: Auf 8080 sollte bei laufendem Testdienst die TCP-Verbindung gelingen. Auf 8081 gibt es nur dann eine erfolgreiche Verbindung, wenn dort ebenfalls ein lokaler Dienst lauscht. So erkennst Du den Unterschied zwischen einem erwarteten und einem anderen Endpunkt.

Kurze Lerneinheit 4: HTTP-Funktion prüfen

HTTP ist ein Anfrage-Antwort-Protokoll. Für den Ausbildungsfall reicht deshalb nicht die Aussage „Port offen“. Erwartet werden der Statuscode 200 und der Inhalt TESTSYSTEM-OK.

curl -i http://127.0.0.1:8080/health

Nur den Antwortkörper anzeigen:

curl -s http://127.0.0.1:8080/health

Funktion automatisch bewerten

Dieses lokale Prüfskript kontrolliert Statuscode und erwarteten Inhalt. Es verwendet nur 127.0.0.1.

import json
import urllib.request

URL = "http://127.0.0.1:8080/health"

with urllib.request.urlopen(URL, timeout=2) as response:
    daten = json.loads(response.read().decode("utf-8"))
    status_ok = response.status == 200
    inhalt_ok = daten.get("status") == "TESTSYSTEM-OK"
    print(status_ok and inhalt_ok)

Kurze Lerneinheit 5: DNS als Netzwerkdienst

DNS ordnet Namen Informationen zu, unter anderem IP-Adressen. Für eine systematische Prüfung ist wichtig, Namensauflösung und Erreichbarkeit getrennt zu betrachten.

Fehler beim Erstellen des Vorschaubildes:

Im sicheren lokalen Kurs verwenden wir keine fremden DNS-Ziele. Für localhost ist die Loopback-Verwendung standardisiert.

import socket

print(socket.gethostbyname("localhost"))

Für IPv4 ist dabei typischerweise 127.0.0.1 relevant.

Kurze Lerneinheit 6: Messdaten lesen

Bei einer Funktionsprüfung können mehrere Messwerte zusammengehören. Das folgende Beispiel nutzt ausschließlich fiktive lokale Testdaten.

Testlauf	TCP	HTTP	Inhalt	Antwortzeit	Visualisierung
A	erreichbar	200	korrekt	12 ms	███
B	erreichbar	200	korrekt	18 ms	████
C	erreichbar	abweichend	abweichend	15 ms	███
D	keine Verbindung	–	–	–

Auswertung: Lauf C zeigt, warum Erreichbarkeit und erwartete Funktion getrennt geprüft werden müssen. Der Transport funktioniert, die Anwendung erfüllt die Sollvorgabe jedoch nicht. Lauf D endet bereits auf der Transportebene.

Mini-Aufgabe Transfer

Ein Kollege dokumentiert nur „Port 8080 offen = Dienst OK“. Formuliere eine bessere Prüfaussage.

Feedback: Eine belastbare Aussage nennt mindestens Ziel, Port, Protokoll und erwartete Anwendungseigenschaft. Beispiel: „127.0.0.1:8080 ist per TCP erreichbar; GET /health liefert Statuscode 200 und den erwarteten Status TESTSYSTEM-OK.“ So ist erkennbar, was tatsächlich geprüft wurde.

Interaktive Testumgebung: Abweichungen gezielt erzeugen

Verändere in Deiner lokalen Kopie von testdienst.py jeweils genau einen Wert und beobachte die Auswirkung.

Ändere den Port des Servers auf 8081, aber nicht den Client.
Ändere den Pfad im Client von /health auf /status.
Ändere im Server den Inhalt TESTSYSTEM-OK auf TESTSYSTEM-WARN.
Ändere den Statuscode testweise von 200 auf 201.

Für jeden Fall notierst Du: Erreichbarkeit, Protokollantwort, Funktionserwartung und Ursache.

Gestufte Hilfen zur Diagnose

Stufe 1 – Ziel prüfen: Stimmen Host, Port und Pfad mit der Vorgabe überein?
Stufe 2 – Transport prüfen: Kann eine TCP-Verbindung aufgebaut werden?
Stufe 3 – Protokoll prüfen: Kommt eine formal auswertbare HTTP-Antwort zurück?
Stufe 4 – Funktion prüfen: Stimmen Statuscode und Nutzdaten mit der Sollvorgabe überein?
Stufe 5 – Dokumentieren: Trenne Beobachtung, Erwartung und Schlussfolgerung.

Quellen und Medienrechte

Die fachliche Grundlage wurde mit Standards und verlässlichen Referenzen abgeglichen: RFC 9293 – TCP, RFC 9110 – HTTP Semantics, RFC 1035 – DNS und RFC 6761 – Special-Use Domain Names. Ergänzend: Netzwerkdienst, Localhost und die IANA-Registry für Dienstnamen und Portnummern.

Die eingebundenen Bilder stammen von Wikimedia Commons. Die Dateien Client-Server.png, DNS schema.svg und Ping command example.png stehen laut ihren Commons-Dateibeschreibungen unter freien Lizenzen; Server-based-network.svg ist als frei lizenzierte Grafik veröffentlicht. Die YouTube-Videos werden ausschließlich über die Plattform eingebettet und nicht kopiert oder neu veröffentlicht.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was prüfst Du mit einem erfolgreichen TCP-Verbindungsaufbau zuerst? (Die Erreichbarkeit des Zielports) (!Die fachliche Korrektheit aller Anwendungsdaten) (!Die Qualität der Benutzeroberfläche) (!Die Vollständigkeit der Dokumentation)

Welche Adresse eignet sich für den isolierten lokalen IPv4-Test? (127.0.0.1) (!8.8.8.8) (!203.0.113.10) (!192.0.2.20)

Was muss zusätzlich geprüft werden, wenn Port 8080 erreichbar ist? (Die erwartete Funktion des Dienstes) (!Nur die Bildschirmauflösung) (!Nur der Rechnername) (!Nur die Uhrzeit)

Welcher HTTP-Statuscode entspricht im Ausbildungsfall der Sollvorgabe? (200) (!201) (!204) (!302)

Welcher Pfad gehört im Ausbildungsfall zum lokalen Statusdienst? (/health) (!/login) (!/customer) (!/admin)

Welche Aussage zu Ping ist fachlich richtig? (Ping allein beweist nicht die Funktion eines HTTP-Dienstes) (!Ping prüft automatisch jede Webanwendung) (!Ping liefert immer einen HTTP-Statuscode) (!Ping prüft den Inhalt einer JSON-Antwort)

Welche Daten werden in den praktischen Übungen verwendet? (Fiktive Testdaten) (!Echte Kundendaten) (!Produktivkennwörter) (!Private Zugangsdaten)

Welche Reihenfolge unterstützt eine systematische Dienstprüfung? (Adresse dann Port dann Protokoll dann Funktion) (!Funktion dann Passwort dann Bildschirm dann Drucker) (!Port dann Kundendaten dann Internet dann Funktion) (!Protokoll dann Produktion dann Fremdnetz dann Adresse)

Was zeigt eine abweichende Anwendungsantwort trotz erreichbarem TCP-Port? (Transport und Anwendung müssen getrennt bewertet werden) (!Der Bildschirm ist zu klein) (!Die Tastatur ist nicht verbunden) (!Die Uhrzeit ist falsch)

Warum wird der lokale Server an 127.0.0.1 gebunden? (Damit die Übung auf den eigenen Rechner begrenzt bleibt) (!Damit fremde Server automatisch geprüft werden) (!Damit Kundennetze erreichbar werden) (!Damit Zugangsdaten übertragen werden)

Memory

localhost	lokaler Rechner
TCP	verbindungsorientierter Transport
HTTP	Anfrage und Antwort
Statuscode 200	erwartete erfolgreiche HTTP-Antwort
Port 8080	lokaler Übungsendpunkt
/health	Pfad der Funktionsprüfung
TESTSYSTEM-OK	erwarteter Testinhalt
DNS	Namensauflösung

Drag and Drop

Ordne die richtigen Begriffe zu.	Thema
Zieladresse	Prüfschritt Adresse
TCP-Port	Prüfschritt Transport
HTTP-Antwort	Prüfschritt Protokoll
TESTSYSTEM-OK	Prüfschritt Funktion
Dokumentation	Prüfschritt Bewertung

Kreuzworträtsel

Localhost	Welcher Name bezeichnet in der Übung den lokalen Rechner?
Erreichbarkeit	Welche Eigenschaft wird vor der Anwendungsfunktion geprüft?
Protokoll	Welche Regelmenge strukturiert die Kommunikation eines Dienstes?
Statuscode	Wie heißt bei HTTP die numerische Bewertung einer Antwort?
Loopback	Wie heißt die lokale Rückführung des Netzwerkverkehrs?
Funktion	Was muss zusätzlich zur Erreichbarkeit geprüft werden?

LearningApps

Lückentext

Für einen sicheren lokalen Test verwendest Du

oder die Loopback-Adresse. Ein erfolgreicher TCP-Verbindungsaufbau bestätigt zunächst die

des Ports. Danach prüfst Du das erwartete

. Im Ausbildungsfall soll der Pfad /health den Statuscode

liefern. Zusätzlich muss der Inhalt

enthalten. Eine abweichende Anwendungsantwort trotz erreichbarem Port zeigt, dass Transport und

getrennt bewertet werden müssen. DNS dient unter anderem der

. Alle praktischen Übungen verwenden ausschließlich fiktive Daten in einer

.

Offene Aufgaben

Leicht

Erreichbarkeit: Erkläre in drei Sätzen den Unterschied zwischen „Port erreichbar“ und „Dienst funktioniert“.
Localhost: Erstelle eine kleine Skizze, die Client und lokalen Testserver auf demselben Rechner zeigt.
HTTP: Markiere in einer selbst erzeugten Beispielantwort Statuscode, Header und Nutzdaten.
Dokumentation: Formuliere eine Sollvorgabe für einen fiktiven lokalen Netzwerkdienst mit Host, Port, Pfad und erwartetem Ergebnis.

Standard

TCP: Starte den lokalen Testdienst und dokumentiere einen passenden sowie einen abweichenden Porttest.
Diagnose: Erzeuge lokal einen anderen Pfad und leite aus dem Ergebnis eine Ursache ab.
Testprotokoll: Entwickle eine Tabelle mit Sollwert, Istwert, Bewertung und Begründung für mindestens vier Prüfschritte.
Datenvisualisierung: Erzeuge mit fiktiven Messwerten eine eigene kleine Balkendarstellung für fünf lokale Antwortzeiten und erkläre, welche Aussage daraus zulässig ist.

Schwer

Automatisierung: Erweitere das lokale Python-Prüfskript so, dass es Statuscode und Inhalt jeweils getrennt bewertet.
Testdesign: Entwirf drei lokale Negativtests, bei denen jeweils nur eine Ursache verändert wird.
Transfer: Vergleiche einen reinen Portcheck mit einer fachlichen Funktionsprüfung und begründe, wann beide nacheinander nötig sind.
Ausbildungsprojekt: Produziere ein kurzes Bildschirmvideo aus einer isolierten lokalen Umgebung, in dem Du eine Abweichung erzeugst, systematisch eingrenzt und die Lösung begründest.

Lernkontrolle

Diagnosestrategie: Ein Dienst ist per TCP erreichbar, liefert aber nicht den erwarteten Inhalt. Entwickle eine begründete Reihenfolge der nächsten Prüfschritte.
Soll-Ist-Vergleich: Gegeben sind Ziel 127.0.0.1, Port 8080, Statuscode 200 und TESTSYSTEM-OK. Erkläre, welche Abweichung jeweils auf Transport-, Protokoll- oder Funktionsebene hinweist.
Abweichungsisolation: Zwei Testläufe unterscheiden sich nur im URL-Pfad. Einer erfüllt die Sollvorgabe, der andere nicht. Begründe, welche Ursachen dadurch wahrscheinlicher oder unwahrscheinlicher werden.
Testqualität: Bewerte die Aussage „Ping erfolgreich, also Dienst in Ordnung“ und formuliere eine fachlich belastbarere Alternative.
Transfer in den Betrieb: Beschreibe, welche zusätzlichen Freigaben, Datenschutzregeln und Dokumentationsschritte nötig wären, bevor eine vergleichbare Methode in einer autorisierten betrieblichen Testumgebung eingesetzt wird.
Messdateninterpretation: Ein lokaler Dienst antwortet mehrfach korrekt und einmal abweichend. Begründe, warum ein einzelner erfolgreicher Test nicht genügt, um Zuverlässigkeit zu belegen.

Lernnachweis

Für einen Lernnachweis solltest Du zeigen, dass Du eine Sollvorgabe in prüfbare Kriterien übersetzen kannst, Erreichbarkeit von Funktion unterscheidest, einen lokalen Testdienst sicher betreibst, Ergebnisse reproduzierbar dokumentierst, Abweichungen schrittweise isolierst und aus Messwerten nachvollziehbare Schlussfolgerungen ableitest.

Ein geeigneter praktischer Lernnachweis enthält einen fiktiven lokalen Dienst, mindestens einen passenden Testlauf, mindestens zwei kontrolliert erzeugte Abweichungsfälle, eine Soll-Ist-Tabelle sowie eine kurze Begründung Deiner Diagnose.