Netzwerkprogrammierung

Kurz gesagt: Netzwerkprogrammierung heißt, dass zwei Programme über das Netzwerk miteinander sprechen: Der Server wartet auf einer IP-Adresse und einem Port, der Client verbindet sich, und Sockets senden die Daten über TCP oder UDP.

Problem

Die Kasse und das Lager

Die Kasse im Shop muss das Lager fragen, wie viel Kaffee noch da ist, und das Lagerprogramm läuft auf einem anderen Computer. Eine Datei hilft nicht: Die beiden Programme sehen die Festplatten des anderen nicht. Eins muss fragen und das andere antworten, sofort, über das Netzwerk.

So funktioniert fast alles um dich herum: Der Browser fragt den Server nach einer Seite, die Banking-App fragt die Bank nach deinem Kontostand, ein Spiel schickt deine Züge an die anderen Spieler.

Die Idee

Adresse, Port und zwei Arten zu senden

Damit Daten ein Programm auf einem anderen Computer erreichen, brauchst du zwei Dinge:

• Eine IP-Adresse: die Nummer des Computers im Netzwerk, zum Beispiel 192.168.1.20 oder 142.250.185.78. Dein eigener Computer ist immer 127.0.0.1, mit dem Namen localhost.
• Einen Port: eine Zahl von 0 bis 65 535 für das Programm auf diesem Computer. Die Adresse ist das Gebäude, der Port ist die Wohnung. HTTPS nutzt 443, und wir nutzen 5961 und höher.

Das Programm, das darauf wartet, dass man es erreicht, ist der Server. Das Programm, das ihn erreicht, ist der Client. Wie die Daten reisen, entscheidet das Protokoll:

	TCP	UDP
Verbindung	erst verbinden sie sich, dann sprechen sie	keine Verbindung, jedes Paket ist ein eigener Brief
Zustellung	alles kommt an, in derselben Reihenfolge, oder du erfährst, dass es nicht geklappt hat	ein Paket kann verloren gehen oder in anderer Reihenfolge ankommen
Geschwindigkeit	langsamer	schneller
Wofür	Web, E-Mail, Zahlungen, Dateien	Sprache und Video live, Spiele, Sensoren

Die Endpunkte einer Verbindung heißen Sockets. In Python erstellt sie das Modul socket.

Genauer, für Neugierige

• Das Netzwerk wird in Schichten beschrieben. Das OSI-Modell hat sieben: Bitübertragung (Bits über das Kabel oder die Luft), Sicherung (die Verbindung zum nächsten Gerät), Vermittlung (IP-Adressen und Routen), Transport (TCP, UDP), Sitzung, Darstellung und Anwendung (HTTP, E-Mail). In der Praxis nutzt das Internet das einfachere TCP/IP-Modell mit vier Schichten. Dein Programm arbeitet auf der obersten: Um alles darunter kümmern sich Python und das Betriebssystem.
• IP liefert einzelne Pakete an eine Adresse, verspricht aber nicht, dass sie ankommen. TCP baut auf IP auf und nummeriert die Pakete, damit es sie ordnen und die verlorenen noch einmal anfordern kann.
• Protokolle, denen du begegnen wirst: HTTP und HTTPS (das Web; HTTPS ist HTTP, verschlüsselt mit TLS, dessen älterer Name SSL ist), WebSocket (eine Verbindung in beide Richtungen für Chat und Benachrichtigungen im Browser), FTP (Dateien), SSH (sicherer Zugriff auf einen entfernten Computer).

Sieh es dir an

Der Server

Der Lagerserver bekommt den Namen eines Produkts und antwortet mit seinem Preis:

PRICES = {"Kaffee": 7.50, "Tee": 3.20}

def serve(server):
    client, address = server.accept()
    with client, client.makefile(encoding="utf-8") as reader:
        product = reader.readline().rstrip("\n")
        print("Server erhielt:", product)
        price = PRICES.get(product)
        answer = "unbekanntes Produkt" if price is None else f"{product}: {price} €"
        client.sendall(f"{answer}\n".encode())

• server ist ein Socket, der auf einem Port lauscht (wir öffnen ihn in der nächsten Karte). server.accept() wartet, bis sich ein Client verbindet, und gibt ein Paar zurück: einen Socket für die Verbindung mit ihm und seine Adresse.
• client.makefile(encoding="utf-8") gibt dir eine Datei zum Lesen aus dem Socket, wie bei Dateien: readline() liest eine Zeile, zusammen mit dem "\n" am Ende. rstrip("\n") entfernt es.
• client.sendall(bytes) sendet. Über das Netzwerk reisen Bytes, deshalb wird der Text mit .encode() in Bytes umgewandelt (in UTF-8). Das "\n" am Ende sagt der anderen Seite, dass die Zeile zu Ende ist. Du wirst gleich sehen, warum das wichtig ist.
• with schließt am Ende die Verbindung und die Datei.

Sieh es dir an

Der Client

Der Client verbindet sich mit socket.create_connection((address, port)) und nutzt dieselben makefile und sendall. Hier sind Server und Client in einem Programm: Der Server läuft in seinem eigenen Thread, und das Hauptprogramm ist der Client. So kannst du beide ohne zweiten Computer ausprobieren:

server = socket.create_server(("localhost", 5961))
threading.Thread(target=serve, args=(server,)).start()

with (
    socket.create_connection(("localhost", 5961)) as sock,
    sock.makefile(encoding="utf-8") as reader,
):
    sock.sendall("Kaffee\n".encode())
    print("Client erhielt:", reader.readline().rstrip("\n"))
server.close()

Ausgabe

Server erhielt: Kaffee
Client erhielt: Kaffee: 7.5 €

Der Port wird mit socket.create_server(("localhost", 5961)) im Hauptprogramm geöffnet, bevor der Thread startet. So lauscht der Server schon, wenn sich der Client verbindet. Die Klammern nach with erlauben zwei Ressourcen auf getrennten Zeilen.

Die beiden Seiten wechseln sich ab: Der Client schreibt eine Zeile und wartet mit readline() auf eine Antwort, und der Server liest die Zeile und antwortet. Wenn sie die Rollen tauschen und beide darauf warten, etwas zu lesen, warten sie ewig.

server = socket.create_server(("localhost", 5961))
threading.Thread(target=serve, args=(server,)).start()

with (
    socket.create_connection(("localhost", 5961)) as sock,
    sock.makefile(encoding="utf-8") as reader,
):
    sock.sendall("Kaffee\n".encode())
    print("Client erhielt:", reader.readline().rstrip("\n"))
server.close()

Schritt für Schritt, in Worten

1. Der Server öffnet Port 5961 und beginnt zu lauschen.
2. In seinem eigenen Thread ruft der Server accept() auf und wartet auf einen Client.
3. Der Client verbindet sich. accept() gibt einen Socket zurück, und beide Seiten können schreiben und lesen.
4. Der Client schreibt eine Zeile: „Kaffee“. Sie wandert über die Verbindung zum Server.
5. Der Client wartet in readline(). Der Server liest die Zeile und gibt sie aus.
6. Der Server findet den Preis und schreibt zurück: „Kaffee: 7.5 €“.
7. readline() gibt dem Client die Antwort zurück, und der Client gibt sie aus.
8. with schließt den Socket, und server.close() schließt den Port.

Genauer, für Neugierige

• Das ganze Programm, mit den imports:

prices.py

import socket
import threading


PRICES = {"Kaffee": 7.50, "Tee": 3.20}


def serve(server):
    client, address = server.accept()
    with client, client.makefile(encoding="utf-8") as reader:
        product = reader.readline().rstrip("\n")
        print("Server erhielt:", product)
        price = PRICES.get(product)
        answer = "unbekanntes Produkt" if price is None else f"{product}: {price} €"
        client.sendall(f"{answer}\n".encode())


server = socket.create_server(("localhost", 5961))
threading.Thread(target=serve, args=(server,)).start()

with (
    socket.create_connection(("localhost", 5961)) as sock,
    sock.makefile(encoding="utf-8") as reader,
):
    sock.sendall("Kaffee\n".encode())
    print("Client erhielt:", reader.readline().rstrip("\n"))
server.close()

• In zwei getrennten Dateien und zwei Terminals ist es dasselbe: Du startest zuerst den Server, dann den Client. Wenn auf dem Port kein Server ist, wirft create_connection ConnectionRefusedError. Wenn der Port schon von einem anderen Programm belegt ist, wirft create_server OSError: [Errno 98] Address already in use.
• Text reist als Bytes über das Netzwerk. .encode() und makefile(encoding="utf-8") nutzen UTF-8, deshalb kommen Umlaute wie ü und das Zeichen € unversehrt an.

Probier es aus

Auf einen Client warten

Welche Methode wartet, bis sich ein Client verbindet?

server = socket.create_server(("localhost", 5961))
client, address = server.()

Prüfen

Die Idee

Viele Clients gleichzeitig

Während der Server mit einem Client spricht, wird accept() nicht aufgerufen, und die anderen warten. Deshalb läuft ein echter Server in einer Endlosschleife: Er nimmt einen Client an, gibt ihn an einen neuen Thread und kehrt sofort zu accept() zurück:

def accept_all(server):
    number = 0
    while True:
        try:
            client, address = server.accept()
        except OSError:
            return
        number += 1
        threading.Thread(target=handle, args=(client, number)).start()

def handle(client, number):
    with client, client.makefile(encoding="utf-8") as reader:
        for line in reader:
            line = line.rstrip("\n")
            print(f"Client {number}: {line}")
            client.sendall(f"Echo: {line}\n".encode())

handle beantwortet jede Zeile, bis der Client die Verbindung schließt: Dann endet for line in reader. Zwei Clients nacheinander:

server = socket.create_server(("localhost", 5962))
threading.Thread(target=accept_all, args=(server,), daemon=True).start()

for order in ["Tisch 4: zwei Kaffee", "Tisch 7: die Rechnung"]:
    with (
        socket.create_connection(("localhost", 5962)) as sock,
        sock.makefile(encoding="utf-8") as reader,
    ):
        sock.sendall(f"{order}\n".encode())
        print(reader.readline().rstrip("\n"))
server.close()

Ausgabe

Client 1: Tisch 4: zwei Kaffee
Echo: Tisch 4: zwei Kaffee
Client 2: Tisch 7: die Rechnung
Echo: Tisch 7: die Rechnung

Genauer, für Neugierige

• daemon=True macht den Thread zu einem „Hintergrund“-Thread: Das Programm endet, wenn das Hauptprogramm endet, ohne auf die Endlosschleife zu warten. Ein echter Server macht ihn nicht zum Hintergrund-Thread: Er muss laufen, bis du ihn stoppst.
• with client, … schließt den schon vorhandenen Socket am Ende.
• Bei Tausenden von Clients ist ein Thread für jeden teuer. Dann gibt die Annahmeschleife die Clients an einen Thread-Pool aus der vorigen Lektion: pool.submit(handle, client, number).

Probier es aus

Beide warten

Der Client sendet „Kaffee“ und wartet auf eine Antwort. Der Server ist derselbe, aber das Programm hängt und gibt nichts aus. In welcher Zeile ist der Fehler?

Wähle die Zeile mit dem Fehler.

1with (2 socket.create_connection(("localhost", 5961)) as sock,3 sock.makefile(encoding="utf-8") as reader,4):5 sock.sendall("Kaffee".encode())6 print("Client erhielt:", reader.readline().rstrip("\n"))

Prüfen

Die Idee

UDP: Briefe ohne Verbindung

Die Sensoren im Shop senden jede Minute die Temperatur. Wenn ein Messwert verloren geht, kommt der nächste eine Minute später, deshalb passt UDP hier gut. Es gibt keine Verbindung und kein makefile: Du sendest Bytes an eine Adresse und einen Port über einen Socket vom Typ SOCK_DGRAM (Datagramm, ein einzelnes Paket):

receiver = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
receiver.bind(("localhost", 5963))

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sensor:
    for reading in ["Küche 21.5", "Lager 4.0", "Kühlschrank 3.2"]:
        sensor.sendto(reading.encode(), ("localhost", 5963))

for i in range(3):
    data, address = receiver.recvfrom(256)
    print(f"Temperatur: {data.decode()} °C")
receiver.close()

Ausgabe

Temperatur: Küche 21.5 °C
Temperatur: Lager 4.0 °C
Temperatur: Kühlschrank 3.2 °C

• Der Empfänger lauscht auf Port 5963 mit bind(("localhost", 5963)). Der Sender ruft bind nicht auf: Das System gibt ihm einen freien Port.
• sendto(bytes, (address, port)) sendet ein Paket. recvfrom(256) wartet auf ein Paket von bis zu 256 Bytes und gibt die Bytes und die Adresse des Senders zurück.
• Niemand bestätigt, dass das Paket angekommen ist. Auf localhost gehen keine verloren, in einem echten Netzwerk kann das passieren.

Genauer, für Neugierige

Wenn der Empfänger antworten muss, sendet er ein neues Paket an die Adresse, die recvfrom zurückgegeben hat: receiver.sendto(answer, address). Ein Paket hat eine Größengrenze (unter 64 KB, und über das Internet bleibt man sinnvollerweise bei etwa 1 400 Bytes), deshalb taugt UDP nicht für Dateien.

Die Idee

HTTP: die Sprache des Webs

Wenn du eine Seite öffnest, baut der Browser eine TCP-Verbindung zum Server auf und sendet eine textbasierte HTTP-Anfrage (Request): „gib mir /“. Der Server schickt eine Antwort (Response) zurück: einen Status, Header und einen Body (HTML, JSON, ein Bild). In Python macht das urllib.request:

import urllib.request

with urllib.request.urlopen("https://example.com") as response:
    print("Status:", response.status)
    print("Typ:", response.headers["content-type"])
    body = response.read().decode()
    print("Titel:", body[body.index("<title>") + 7 : body.index("</title>")])

Ausgabe (mit Internet)

Status: 200
Typ: text/html; charset=utf-8
Titel: Example Domain

• urlopen(address) sendet eine GET-Anfrage und wartet auf die Antwort. with schließt am Ende die Verbindung.
• response.read() gibt dir den Body als Bytes, und .decode() macht daraus Text.
• Der Status sagt dir, wie es gelaufen ist: 200 ist Erfolg, 404 heißt, dass es keine solche Seite gibt, 500 ist ein Fehler auf dem Server. Bei einem Status 4xx oder 5xx wirft urlopen urllib.error.HTTPError.

Die Codeprüfung der Website läuft ohne Internet, deshalb wird dieses Programm mit der Ausgabe eines Laufs mit Netzwerk gezeigt. Ohne Netzwerk wirft urlopen urllib.error.URLError.

Genauer, für Neugierige

Python selbst hat auch einen HTTP-Server (http.server). So kannst du urlopen auch ohne Internet ausprobieren, auf localhost:

class Stock(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/stock":
            self.send_error(404)
            return
        answer = "Kaffee: 12 Stk.".encode()
        self.send_response(200)
        self.send_header("Content-Length", str(len(answer)))
        self.end_headers()
        self.wfile.write(answer)

    def log_message(self, format, *args):
        pass  # keine Zeile in der Konsole für jede Anfrage


server = HTTPServer(("localhost", 5964), Stock)
threading.Thread(target=server.serve_forever, daemon=True).start()

for path in ["/stock", "/prices"]:
    try:
        with urllib.request.urlopen(f"http://localhost:5964{path}") as response:
            print(path, "->", response.status, response.read().decode())
    except urllib.error.HTTPError as e:
        print(path, "->", e.code, e.reason)
server.shutdown()

Ausgabe

/stock -> 200 Kaffee: 12 Stk.
/prices -> 404 Not Found

Für jede GET-Anfrage ruft der Server do_GET auf. Für /prices gibt er mit send_error 404 zurück, und urlopen wirft das als HTTPError. log_message ist leer, damit der Server nicht für jede Anfrage eine Zeile ausgibt. In echten Projekten baut man Webserver mit Bibliotheken wie Flask, Django oder FastAPI. Sie bauen auf denselben Sockets auf.

Übung

Server auf localhost

Löse die Aufgaben in deinem Editor. Server und Client können in einem Programm sein (der Server in einem Thread) oder in zwei getrennten, die du in zwei Terminals startest.

1. Echo-Server. Der Server schickt jede Zeile mit „Echo: “ davor zurück, bis er „ende“ bekommt. Dann antwortet er „Auf Wiedersehen“ und schließt die Verbindung. Der Client sendet „hallo“, „wie geht es dir“ und „ende“ und gibt die Antworten aus:

Ausgabe

Echo: hallo
Echo: wie geht es dir
Auf Wiedersehen

2. Ein Server mit Befehlen. GROSS Text gibt den Text in Großbuchstaben zurück, ZEIT gibt die aktuelle Uhrzeit als 14:05 zurück (datetime.now().strftime("%H:%M")), und alles andere gibt „Unbekannter Befehl: “ und den Befehl zurück. Die Uhrzeit ändert sich, deshalb prüft der Client nur ihre Form mit einem regulären Ausdruck:

Ausgabe

BESTELLUNG 42 IST FERTIG
Die Uhrzeit hat die Form HH:MM: True
Unbekannter Befehl: UHRZEIT

3. Ein Chat für zwei. Anna öffnet den Server auf Port 5967, Jonas verbindet sich. Jeder ist in seinem eigenen Thread und sendet seine vorbereiteten Zeilen, wobei er nach jeder auf eine Antwort wartet:

Ausgabe

Jonas erhielt: Hallo Jonas! Hast du um 18 Uhr Zeit?
Anna erhielt: Ja, ich komme.
Jonas erhielt: Super, bis gleich.
Anna erhielt: Tschüss!

Dann mach es echt: zwei Programme, jedes mit zwei Threads. Ein Thread liest von der Tastatur und sendet, der andere liest vom Socket und gibt aus. So kannst du tippen, während du auf eine Antwort wartest.

Test

Teste dich

1. Worauf zeigt der Port?

Auf die Geschwindigkeit der VerbindungAuf das Programm auf dem Computer, zu dem die Daten gehenAuf den Computer im Netzwerk

2. Wann ist UDP die bessere Wahl als TCP?

NieWenn jedes Byte ankommen muss, zum Beispiel bei einer ZahlungWenn es auf Geschwindigkeit ankommt und ein verlorenes Paket kein Drama ist: Sprache, Video, Messwerte eines Sensors

3. Was macht server.accept()?

Es wartet, bis sich ein Client verbindet, und gibt einen Socket für ihn und seine Adresse zurückEs sendet dem Client eine AntwortEs schließt den Server

4. Der Client sendet sock.sendall("Kaffee".encode()), und der Server liest mit readline(). Beide warten. Warum?

Das "\n" fehlt: Der Server wartet auf das Ende der Zeile, und der Client wartet auf eine AntwortDer falsche PortDer Server ist auf einem anderen Computer

5. urlopen wirft HTTPError, und e.code ist 404. Was bedeutet das?

Es gibt kein InternetAlles ist in OrdnungDer Server hat keine solche Adresse (die Seite wurde nicht gefunden)

Prüfen

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Listen: append, remove und sort · dict und set · Lambdas · Threads
• Geht weiter in: Nicht vertrauenswürdige Eingaben · Sitzungen, Cookies und CSRF · JWT und seine Fallen · API-Design: Vertrag, Versionen, wiederholte Anfragen
• Aufgaben zum Thema: Programme in der echten Welt