Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-10-11T15:19:48Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}

{{BR}}
= Netzwerke und Systemintegration – Netzwerkdienste im Testsystem prüfen =

'''Kurzbeschreibung:''' Erreichbarkeit und erwartete Funktion.

[[Datei:Client-Server.png|500px|rahmenlos|center]]

{{BR}}
= 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 [[Fachinformatiker für Systemintegration|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.

{{BR}}
== Lernziele ==

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

{{BR}}
== Prüfkette auf einen Blick ==

{| class="wikitable" style="margin:auto; text-align:center"
! 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
|}

{{BR}}
== 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.

[[Datei:Server-based-network.svg|420px|rahmenlos|center]]

{{BR}}
= Ausbildungsfall =

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

{| class="wikitable"
! 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.'''

{{BR}}
= 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.

[[Datei:Ping_command_example.png|500px|rahmenlos|center]]

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

{{BR}}
== 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.

{{BR}}
= 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.

<syntaxhighlight lang="python">
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()
</syntaxhighlight>

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

<syntaxhighlight lang="bash">
python3 testdienst.py
</syntaxhighlight>

Unter Windows ist je nach Installation auch möglich:

<syntaxhighlight lang="powershell">
py testdienst.py
</syntaxhighlight>

'''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.

{{BR}}
= Kurze Lerneinheit 3: TCP-Port lokal testen =

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

<syntaxhighlight lang="python">
import socket

ziel = ("127.0.0.1", 8080)

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

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.

{{BR}}
== 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.

{{BR}}
= 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'''.

<syntaxhighlight lang="bash">
curl -i http://127.0.0.1:8080/health
</syntaxhighlight>

Nur den Antwortkörper anzeigen:

<syntaxhighlight lang="bash">
curl -s http://127.0.0.1:8080/health
</syntaxhighlight>

{{#ev:youtube| https://www.youtube.com/watch?v=98fSp15gE70 |500|center}}

{{BR}}
== Funktion automatisch bewerten ==

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

<syntaxhighlight lang="python">
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)
</syntaxhighlight>

{{BR}}
= 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.

[[Datei:DNS_schema.svg|500px|rahmenlos|center]]

{{#ev:youtube| https://www.youtube.com/watch?v=GxABmSNc780 |500|center}}

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

<syntaxhighlight lang="python">
import socket

print(socket.gethostbyname("localhost"))
</syntaxhighlight>

Für IPv4 ist dabei typischerweise '''127.0.0.1''' relevant.

{{BR}}
= Kurze Lerneinheit 6: Messdaten lesen =

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

{| class="wikitable"
! 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.

{{BR}}
== 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.

{{BR}}
= 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'''.

{{BR}}
== 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.

{{BR}}
= Quellen und Medienrechte =

Die fachliche Grundlage wurde mit Standards und verlässlichen Referenzen abgeglichen: [https://www.rfc-editor.org/info/rfc9293 RFC 9293 – TCP], [https://www.rfc-editor.org/info/rfc9110 RFC 9110 – HTTP Semantics], [https://www.rfc-editor.org/info/rfc1035 RFC 1035 – DNS] und [https://www.rfc-editor.org/info/rfc6761 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.

{{BR}}
= Interaktive Aufgaben =

{{BR}}
== Quiz: Teste Dein Wissen ==

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''Welcher HTTP-Statuscode entspricht im Ausbildungsfall der Sollvorgabe?'''
(200)
(!201)
(!204)
(!302)
{{E}}
<br>

{{MC}}
'''Welcher Pfad gehört im Ausbildungsfall zum lokalen Statusdienst?'''
(/health)
(!/login)
(!/customer)
(!/admin)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''Welche Daten werden in den praktischen Übungen verwendet?'''
(Fiktive Testdaten)
(!Echte Kundendaten)
(!Produktivkennwörter)
(!Private Zugangsdaten)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{MC}}
'''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)
{{E}}
<br>

{{BR}}
== Memory ==

<div class="memo-quiz">
{|
|-
| 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
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

<div class="lueckentext-quiz">
{| class="wikitable"
! 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
|}
{{E}}
<br>
<br />

{{BR}}
== Kreuzworträtsel ==

<div class="kreuzwort-quiz">
{|
|-
| 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?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Netzwerke+und+Systemintegration+–+Netzwerkdienste+im+Testsystem+prüfen </iframe>

{{BR}}
== Lückentext ==

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Für einen sicheren lokalen Test verwendest Du { localhost } oder die Loopback-Adresse. Ein erfolgreicher TCP-Verbindungsaufbau bestätigt zunächst die { Erreichbarkeit } des Ports. Danach prüfst Du das erwartete { Protokoll }. Im Ausbildungsfall soll der Pfad /health den Statuscode { 200 } liefern. Zusätzlich muss der Inhalt { TESTSYSTEM-OK } enthalten. Eine abweichende Anwendungsantwort trotz erreichbarem Port zeigt, dass Transport und { Funktion } getrennt bewertet werden müssen. DNS dient unter anderem der { Namensauflösung }. Alle praktischen Übungen verwenden ausschließlich fiktive Daten in einer { Testumgebung }.
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

{{BR}}
=== 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.

{{BR}}
=== 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.

{{BR}}
=== 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.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= 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.

<br>
<br>

{{BR}}
= 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.

<br>
<br>

{{BR}}
= OERs zum Thema =

<iframe> https://de.m.wikipedia.org/wiki/Netzwerkdienst </iframe>

<br>

{{BR}}
= Verknüpfte Lernbereiche =

{| align=center
{{:D-Tab}}
'''[[Netzwerkdienste prüfen]]'''
# [[Netzwerkdienst]]
# [[TCP]]
# [[HTTP]]
# [[DNS]]
# [[Localhost]]
# [[Portnummer]]
# [[Diagnose]]
# [[Testprotokoll]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Netzwerktechnik]]
[[Kategorie:Systemintegration]]
[[Kategorie:Fachinformatiker]]
[[Kategorie:Ausbildung]]
[[Kategorie:IT-Sicherheit]]
[[Kategorie:Netzwerkdienst]]
[[Kategorie:AI_MOOC]]

{{BR}}
= aiMOOC-Projekte =
[[Kategorie:AI_MOOC]] [[Kategorie:GPT aiMOOC]]
{{MT}}

Netzwerke und Systemintegration – Netzwerkdienste im Testsystem prüfen - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt