0Pricing
Linux Networking & TCP/IP for Developers · Pelajaran

Soket Klien-Server UDP

Kembangkan komunikasi tanpa koneksi berbasis datagram menggunakan soket UDP untuk aplikasi yang memprioritaskan kecepatan daripada keandalan.

Soket Klien-Server UDP adalah pelajaran Linux Networking & TCP/IP for Developers gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Networking & TCP/IP for Developers, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Networking & TCP/IP for Developers mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Soket Klien-Server UDP” gratis?

Ya — teks lengkap “Soket Klien-Server UDP” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Networking & TCP/IP for Developers, upgrade ke CoddyKit PRO. Kursus Linux Networking & TCP/IP for Developers mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Soket Klien-Server UDP”?

Kembangkan komunikasi tanpa koneksi berbasis datagram menggunakan soket UDP untuk aplikasi yang memprioritaskan kecepatan daripada keandalan. Kamu berlatih Linux Networking & TCP/IP for Developers dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Networking & TCP/IP for Developers?

Tidak diperlukan pengalaman sebelumnya. Linux Networking & TCP/IP for Developers di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Soket Klien-Server UDP” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Networking & TCP/IP for Developers ini?

Ya. Setiap pelajaran Linux Networking & TCP/IP for Developers menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengenalan API Soket
  2. Soket Klien-Server TCP
  3. Soket Klien-Server UDP
  4. Soket Non-Pemblokiran dan select()
← Kembali ke Linux Networking & TCP/IP for Developers