0Pricing
Linux Networking & TCP/IP for Developers · Lección

Sockets UDP cliente-servidor

Desarrolle comunicaciones sin conexión basadas en datagramas mediante sockets UDP para aplicaciones en las que se prioriza la velocidad sobre la fiabilidad.

Sockets UDP cliente-servidor es una lección gratuita de Linux Networking & TCP/IP for Developers en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Linux Networking & TCP/IP for Developers, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Linux Networking & TCP/IP for Developers incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

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!

Preguntas frecuentes

¿La lección «Sockets UDP cliente-servidor» es gratis?

Sí — el texto completo de «Sockets UDP cliente-servidor» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Linux Networking & TCP/IP for Developers, actualiza a CoddyKit PRO. El curso de Linux Networking & TCP/IP for Developers incluye 4 lecciones en total.

¿Qué aprenderé en «Sockets UDP cliente-servidor»?

Desarrolle comunicaciones sin conexión basadas en datagramas mediante sockets UDP para aplicaciones en las que se prioriza la velocidad sobre la fiabilidad. Practicas Linux Networking & TCP/IP for Developers con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Linux Networking & TCP/IP for Developers?

No se requiere experiencia previa. Linux Networking & TCP/IP for Developers en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Sockets UDP cliente-servidor»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Linux Networking & TCP/IP for Developers?

Sí. Cada lección de Linux Networking & TCP/IP for Developers incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Introducción a la API de sockets
  2. Sockets TCP cliente-servidor
  3. Sockets UDP cliente-servidor
  4. Sockets no bloqueantes y select()
← Volver a Linux Networking & TCP/IP for Developers