Linux-netwerken en TCP/IP voor ontwikkelaars · Les

UDP-client-serversockets

Ontwikkel verbindingsloze, op datagrammen gebaseerde communicatie met UDP-sockets voor applicaties waarbij snelheid belangrijker is dan betrouwbaarheid.

Les 3 van 412 stappen

UDP-client-serversockets is een gratis Linux-netwerken en TCP/IP voor ontwikkelaars-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Linux-netwerken en TCP/IP voor ontwikkelaars. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Linux-netwerken en TCP/IP voor ontwikkelaars bevat in totaal 4 lessen.

Wat is UDP?

Welkom bij UDP! Terwijl TCP zich richt op betrouwbare, verbindingsgerichte communicatie, biedt UDP (User Datagram Protocol) een andere aanpak: verbindingsloos en onbetrouwbaar.

Je kunt UDP vergelijken met het versturen van een ansichtkaart. Je schrijft het bericht en verstuurt het, maar je weet niet of het is aangekomen, in welke volgorde, of dat het verloren is gegaan. Het is snel, maar niets wordt gegarandeerd.

UDP versus TCP: belangrijkste verschillen

Als je wilt weten wanneer je UDP gebruikt, moet je de belangrijkste verschillen met TCP kennen:

Verbindingsloos: er is geen handshake nodig voordat je gegevens verzendt.
Onbetrouwbaar: aflevering, volgorde en bescherming tegen duplicaten worden niet gegarandeerd.
Sneller: er is minder overhead doordat er geen verbinding hoeft te worden opgezet en er geen betrouwbaarheidscontroles zijn.
Datagrams: gegevens worden verzonden in onafhankelijke pakketten die datagrams worden genoemd.

UDP is ideaal voor toepassingen waarbij snelheid belangrijker is dan gegarandeerde aflevering.

Wanneer gebruik je UDP?

UDP komt goed tot zijn recht in situaties waarin enig gegevensverlies acceptabel is of waarin toepassingen de betrouwbaarheid zelf afhandelen. Veelvoorkomende toepassingen zijn:

Onlinegames: snelheid is cruciaal voor realtimeactie.
Spraak- en videostreaming: korte vertragingen zijn beter dan opnieuw verzenden.
DNS (Domain Name System): snelle zoekopdrachten krijgen prioriteit.
SNMP (Simple Network Management Protocol): netwerkapparaten bewaken.

Deze toepassingen geven prioriteit aan lage latentie boven absolute gegevensintegriteit.

De Python-module `socket` voor UDP

De Python-module socket is je gereedschap voor netwerkprogrammering, waaronder UDP. Om een UDP-socket te maken, geef je de adresfamilie en het sockettype op.

socket.AF_INET: voor IPv4-adressen.
socket.SOCK_DGRAM: geeft een UDP-socket aan (datagramsocket).

Laten we bekijken hoe je er een maakt.

Een UDP-socket maken

Zo maak je een eenvoudige UDP-socket. Let op: dit lijkt sterk op TCP, maar gebruikt SOCK_DGRAM.

Voer deze code uit om te zien hoe een UDP-socket wordt geïnitialiseerd en vervolgens gesloten.

import socket

def main():
    # AF_INET for IPv4, SOCK_DGRAM for UDP
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    print("UDP socket created successfully!")
    udp_socket.close()
    print("Socket closed.")

if __name__ == "__main__":
    main()

UDP-server: binden aan een adres

Een UDP-server moet bind() gebruiken voor een specifiek IP-adres en een specifieke poort om naar binnenkomende datagrammen te luisteren. Hiermee geef je het besturingssysteem aan waar de server gegevens verwacht te ontvangen.

In tegenstelling tot TCP heeft UDP geen listen() of accept(), omdat het verbindingsloos is. De server wacht gewoon op ontvangst.

import socket

HOST = '127.0.0.1' # Localhost
PORT = 12345       # Port to listen on

def main():
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    udp_socket.bind((HOST, PORT))
    print(f"UDP server bound to {HOST}:{PORT}")
    udp_socket.close()

if __name__ == "__main__":
    main()

UDP-server: gegevens ontvangen

De methode recvfrom() wordt door een UDP-server gebruikt om gegevens te ontvangen. Deze methode retourneert zowel de gegevens als het adres van de afzender.

De onderstaande server wacht op één bericht, drukt het af en wordt daarna afgesloten. Probeer deze uit te voeren en voer daarna de clientcode in de volgende scène uit!

import socket

HOST = '127.0.0.1'
PORT = 12345

def main():
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    udp_socket.bind((HOST, PORT))
    print(f"UDP server listening on {HOST}:{PORT}")

    print("Waiting for message...")
    data, addr = udp_socket.recvfrom(1024) # Buffer size 1024 bytes
    print(f"Received '{data.decode()}' from {addr}")
    udp_socket.close()

if __name__ == "__main__":
    main()

UDP-client: gegevens verzenden

Een UDP-client gebruikt de methode sendto() om gegevens te verzenden. Deze methode ontvangt de gegevens (als bytes) en het bestemmingsadres (IP-adres en poort) als argumenten.

De client hoeft zich niet aan een specifieke poort te binden, tenzij deze een antwoord op die poort verwacht. Er wordt automatisch een tijdelijke poort toegewezen.

Voer deze client uit nadat je de server uit de vorige scène hebt gestart!

import socket

SERVER_HOST = '127.0.0.1'
SERVER_PORT = 12345

def main():
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    message = "Hello UDP Server!"
    udp_socket.sendto(message.encode(), (SERVER_HOST, SERVER_PORT))
    print(f"Sent '{message}' to {SERVER_HOST}:{SERVER_PORT}")
    udp_socket.close()

if __name__ == "__main__":
    main()

Volledige UDP-echo-server en -client

Laten we een eenvoudige UDP-echo-server maken die een bericht ontvangt en terugstuurt naar de client, en een client die een bericht verzendt en op de echo wacht.

Voer eerst de server uit. Voer daarna de client uit in een afzonderlijke terminal of uitvoeringsomgeving.

import socket

# --- UDP Echo Server ---
HOST = '127.0.0.1'
PORT = 12345

def run_server():
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    udp_socket.bind((HOST, PORT))
    print(f"Server listening on {HOST}:{PORT}")

    try:
        while True:
            data, addr = udp_socket.recvfrom(1024)
            print(f"Received '{data.decode()}' from {addr}")
            # Echo back to the client
            udp_socket.sendto(b"Echo: " + data, addr)
            print(f"Echoed back to {addr}")
    except KeyboardInterrupt:
        print("Server shutting down.")
    finally:
        udp_socket.close()

if __name__ == "__main__":
    run_server()

Volledige UDP-echoclient

Voer nu deze clientcode uit. De client stuurt een bericht naar de actieve server en wacht vervolgens op het teruggestuurde antwoord.

Dit laat een volledige, eenvoudige UDP-communicatielus zien.

import socket

# --- UDP Echo Client ---
SERVER_HOST = '127.0.0.1'
SERVER_PORT = 12345

def run_client():
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    message = "Hello from UDP Client!"
    
    udp_socket.sendto(message.encode(), (SERVER_HOST, SERVER_PORT))
    print(f"Sent '{message}' to {SERVER_HOST}:{SERVER_PORT}")

    print("Waiting for echo...")
    data, addr = udp_socket.recvfrom(1024)
    print(f"Received echo '{data.decode()}' from {addr}")
    udp_socket.close()

if __name__ == "__main__":
    run_client()

Controle van UDP-client en -server

Welke van de volgende uitspraken over UDP-sockets is WAAR?

Beantwoord dit in de interactieve les

Samenvatting: UDP-sockets

In deze les heb je UDP-sockets verkend en de belangrijkste verschillen met TCP leren begrijpen.

UDP is verbindingsloos en onbetrouwbaar en geeft prioriteit aan snelheid.
UDP gebruikt datagrammen voor communicatie.
Met de Python-module socket en SOCK_DGRAM maak je UDP-sockets.
Servers gebruiken bind() en recvfrom().
Clients gebruiken sendto().

Nu kun je het juiste protocol kiezen voor de behoeften van je toepassing!

Gratis beginnen

Leer Linux-netwerken en TCP/IP voor ontwikkelaars met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “UDP-client-serversockets” gratis?

Ja — de volledige tekst van “UDP-client-serversockets” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Linux-netwerken en TCP/IP voor ontwikkelaars wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Linux-netwerken en TCP/IP voor ontwikkelaars bevat in totaal 4 lessen.

Wat leer ik in “UDP-client-serversockets”?

Ontwikkel verbindingsloze, op datagrammen gebaseerde communicatie met UDP-sockets voor applicaties waarbij snelheid belangrijker is dan betrouwbaarheid. Je oefent met Linux-netwerken en TCP/IP voor ontwikkelaars door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Linux-netwerken en TCP/IP voor ontwikkelaars te beginnen?

Ervaring vooraf is niet nodig. Linux-netwerken en TCP/IP voor ontwikkelaars op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “UDP-client-serversockets”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Linux-netwerken en TCP/IP voor ontwikkelaars?

Ja. Elke les over Linux-netwerken en TCP/IP voor ontwikkelaars bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Linux-netwerken en TCP/IP voor ontwikkelaars