Linux Networking & TCP/IP for Developers · Lektion

UDP-Client-Server-Sockets

Entwickeln Sie verbindungslose, Datagramm-basierte Kommunikation mit UDP-Sockets für Anwendungen, bei denen Geschwindigkeit wichtiger als Zuverlässigkeit ist.

UDP-Client-Server-Sockets ist eine kostenlose Linux Networking & TCP/IP for Developers-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Linux Networking & TCP/IP for Developers-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Linux Networking & TCP/IP for Developers-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What is UDP?

Welcome to UDP! While TCP focused on reliable, connection-oriented communication, UDP (User Datagram Protocol) offers a different approach: connectionless and unreliable.

Think of UDP like sending a postcard. You write the message and send it, but you don't know if it arrived, or in what order, or if it got lost. It's fast, but there's no guarantee.

UDP vs. TCP: Key Differences

Understanding when to use UDP means knowing its core differences from TCP:

Connectionless: No handshake needed before sending data.
Unreliable: No guaranteed delivery, ordering, or duplicate protection.
Faster: Less overhead due to no connection setup or reliability checks.
Datagrams: Data is sent in independent packets called datagrams.

UDP is perfect for applications where speed is more critical than guaranteed delivery.

When to Use UDP

UDP shines in scenarios where some data loss is acceptable, or where applications handle reliability themselves. Common uses include:

Online Gaming: Speed is crucial for real-time action.
Voice/Video Streaming: Small delays are better than retransmissions.
DNS (Domain Name System): Quick lookups are prioritized.
SNMP (Simple Network Management Protocol): Monitoring network devices.

These applications prioritize low latency over absolute data integrity.

The Python `socket` Module for UDP

Python's socket module is your toolkit for network programming, including UDP. To create a UDP socket, you specify the address family and socket type.

socket.AF_INET: For IPv4 addresses.
socket.SOCK_DGRAM: Specifies a UDP socket (datagram socket).

Let's see how to create one.

Creating a UDP Socket

Here's how to create a basic UDP socket. Notice it's very similar to TCP, but with SOCK_DGRAM.

Run this code to see a UDP socket being initialized and then closed.

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: Binding to an Address

A UDP server needs to bind() to a specific IP address and port to listen for incoming datagrams. This tells the operating system where the server expects to receive data.

Unlike TCP, there's no listen() or accept() for UDP as it's connectionless. The server just waits to receive.

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: Receiving Data

The recvfrom() method is used by a UDP server to receive data. It returns both the data and the address of the sender.

The server below will wait for one message, print it, and then close. Try running it and then run the client code in the next scene!

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: Sending Data

A UDP client uses the sendto() method to send data. It takes the data (as bytes) and the destination address (IP and port) as arguments.

The client doesn't need to bind to a specific port unless it expects to receive a reply on that port. An ephemeral port is assigned automatically.

Run this client after starting the server from the previous scene!

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()

Full UDP Echo Server & Client

Let's create a simple UDP echo server that receives a message and sends it back to the client, and a client that sends a message and waits for the echo.

First, run the server. Then, run the client in a separate terminal or execution environment.

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()

Full UDP Echo Client

Now, run this client code. It will send a message to the running server and then wait to receive the echoed response.

This demonstrates a complete, simple UDP communication loop.

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()

UDP Client-Server Check

Which of the following statements about UDP sockets is TRUE?

Recap: UDP Sockets

In this lesson, you've explored the world of UDP sockets, understanding their fundamental differences from TCP.

UDP is connectionless and unreliable, prioritizing speed.
It uses datagrams for communication.
Python's socket module with SOCK_DGRAM creates UDP sockets.
Servers use bind() and recvfrom().
Clients use sendto().

Now you can choose the right protocol for your application's needs!

Häufig gestellte Fragen

Ist die Lektion „UDP-Client-Server-Sockets“ kostenlos?

Ja — der vollständige Text von „UDP-Client-Server-Sockets“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Linux Networking & TCP/IP for Developers-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Linux Networking & TCP/IP for Developers-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „UDP-Client-Server-Sockets“?

Entwickeln Sie verbindungslose, Datagramm-basierte Kommunikation mit UDP-Sockets für Anwendungen, bei denen Geschwindigkeit wichtiger als Zuverlässigkeit ist. Du übst Linux Networking & TCP/IP for Developers mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Linux Networking & TCP/IP for Developers zu starten?

Keine Vorkenntnisse erforderlich. Linux Networking & TCP/IP for Developers auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „UDP-Client-Server-Sockets“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Linux Networking & TCP/IP for Developers-Lektion Code schreiben und ausführen?

Ja. Jede Linux Networking & TCP/IP for Developers-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Linux Networking & TCP/IP for Developers