Linux-netværk og TCP/IP for udviklere · Lektion

UDP-klient-serversockets

Udvikl forbindelsesløs, datagram-baseret kommunikation med UDP-sockets til applikationer, hvor hastighed prioriteres over pålidelighed

Lektion 3 af 412 trin

UDP-klient-serversockets er en gratis Linux-netværk og TCP/IP for udviklere-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Linux-netværk og TCP/IP for udviklere, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Linux-netværk og TCP/IP for udviklere-kurset indeholder 4 lektioner i alt.

Hvad er UDP?

Velkommen til UDP! Mens TCP fokuserer på pålidelig, forbindelsesorienteret kommunikation, tilbyder UDP (bruger-datagramprotokollen) en anden tilgang: forbindelsesløs og upålidelig.

Tænk på UDP som at sende et postkort. Du skriver beskeden og sender den, men du ved ikke, om den nåede frem, i hvilken rækkefølge den ankommer, eller om den gik tabt. Det er hurtigt, men der er ingen garanti.

UDP kontra TCP: Vigtige forskelle

For at forstå, hvornår du skal bruge UDP, skal du kende de vigtigste forskelle fra TCP:

Forbindelsesløs: Der kræves ikke noget håndtryk, før data sendes.
Upålidelig: Der er ingen garanti for levering eller rækkefølge, og ingen beskyttelse mod dubletter.
Hurtigere: Der er mindre overhead, fordi forbindelsen ikke skal oprettes, og der ikke udføres pålidelighedskontrol.
Datagrammer: Data sendes i uafhængige pakker, der kaldes datagrammer.

UDP er perfekt til applikationer, hvor hastighed er vigtigere end garanteret levering.

Hvornår skal du bruge UDP?

UDP er velegnet i situationer, hvor et vist datatab er acceptabelt, eller hvor applikationerne selv håndterer pålideligheden. Almindelige anvendelser omfatter:

Onlinespil: Hastighed er afgørende for handling i realtid.
Streaming af tale og video: Små forsinkelser er bedre end at sende data igen.
DNS (domænenavnesystemet): Hurtige opslag prioriteres.
SNMP (simpel netværksstyringsprotokol): Overvågning af netværksenheder.

Disse applikationer prioriterer lav latenstid frem for absolut dataintegritet.

Pythons `socket`-modul til UDP

Pythons socket-modul er dit værktøj til netværksprogrammering, herunder UDP. For at oprette en UDP-socket angiver du adressefamilien og socket-typen.

socket.AF_INET: Til IPv4-adresser.
socket.SOCK_DGRAM: Angiver en UDP-socket (datagramsocket).

Lad os se, hvordan du opretter en.

Opret en UDP-socket

Sådan opretter du en grundlæggende UDP-socket. Bemærk, at det minder meget om TCP, men bruger SOCK_DGRAM.

Kør denne kode for at se en UDP-socket blive initialiseret og derefter lukket.

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: Bind til en adresse

En UDP-server skal bind() til en bestemt IP-adresse og port for at lytte efter indgående datagrammer. Det fortæller operativsystemet, hvor serveren forventer at modtage data.

I modsætning til TCP findes der ingen listen() eller accept() til UDP, fordi UDP er forbindelsesløst. Serveren venter bare på at modtage data.

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: Modtagelse af data

Metoden recvfrom() bruges af en UDP-server til at modtage data. Den returnerer både dataene og afsenderens adresse.

Serveren nedenfor venter på én meddelelse, udskriver den og lukker derefter. Prøv at køre den, og kør derefter klientkoden i den næste 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-klient: Afsendelse af data

En UDP-klient bruger metoden sendto() til at sende data. Den tager dataene (som bytes) og destinationsadressen (IP og port) som argumenter.

Klienten behøver ikke at binde sig til en bestemt port, medmindre den forventer at modtage et svar på den port. En midlertidig port tildeles automatisk.

Kør denne klient, efter du har startet serveren fra den forrige 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()

Komplet UDP-ekko-server og -klient

Lad os oprette en enkel UDP-ekko-server, der modtager en meddelelse og sender den tilbage til klienten, samt en klient, der sender en meddelelse og venter på ekkoet.

Kør først serveren. Kør derefter klienten i en separat terminal eller et separat kørselsmiljø.

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

Komplet UDP-ekko-klient

Kør nu denne klientkode. Den sender en meddelelse til den kørende server og venter derefter på at modtage svaret med ekkoet.

Dette demonstrerer en komplet og enkel kommunikationssløjfe med UDP.

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

Kontrol af UDP-klient og -server

Hvilket af følgende udsagn om UDP-sockets er SANDT?

Besvar den i den interaktive lektion

Opsummering: UDP-sockets

I denne lektion har du udforsket UDP-sockets og forstået deres grundlæggende forskelle fra TCP.

UDP er forbindelsesløst og upålideligt og prioriterer hastighed.
Det bruger datagrammer til kommunikation.
Pythons socket-modul med SOCK_DGRAM opretter UDP-sockets.
Servere bruger bind() og recvfrom().
Klienter bruger sendto().

Nu kan du vælge den rigtige protokol til din applikations behov!

Gratis at komme i gang

Lær Linux-netværk og TCP/IP for udviklere med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “UDP-klient-serversockets” gratis?

Ja — hele teksten til “UDP-klient-serversockets” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Linux-netværk og TCP/IP for udviklere-kurset, skal du opgradere til CoddyKit PRO. Linux-netværk og TCP/IP for udviklere-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “UDP-klient-serversockets”?

Udvikl forbindelsesløs, datagram-baseret kommunikation med UDP-sockets til applikationer, hvor hastighed prioriteres over pålidelighed Du øver dig i Linux-netværk og TCP/IP for udviklere med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Linux-netværk og TCP/IP for udviklere?

Der kræves ingen tidligere erfaring. Linux-netværk og TCP/IP for udviklere på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “UDP-klient-serversockets”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Linux-netværk og TCP/IP for udviklere-lektion?

Ja. Alle Linux-netværk og TCP/IP for udviklere-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Linux-netværk og TCP/IP for udviklere