Soket Klien-Server TCP
Implementasikan komunikasi andal yang berorientasi koneksi dengan membangun aplikasi klien dan server TCP dasar dalam Python.
Soket Klien-Server TCP adalah pelajaran Linux Networking & TCP/IP for Developers gratis di CoddyKit. Ini adalah pelajaran 2 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.
TCP Sockets: Connection First
Welcome to building network applications with Python! This lesson focuses on TCP (Transmission Control Protocol) sockets, which are the backbone of reliable internet communication.
Unlike UDP, TCP is a connection-oriented protocol. This means a direct, stable link is established between two applications before any data is sent.
Why TCP is Reliable
TCP ensures your data arrives correctly and in order. It handles:
- Guaranteed Delivery: Data segments are retransmitted if lost.
- Ordered Data: Data arrives in the order it was sent.
- Error Checking: Data integrity is verified.
- Flow Control: Prevents a fast sender from overwhelming a slow receiver.
This makes TCP ideal for web browsing, email, and file transfers.
TCP Server: The Listener
A TCP server's role is to listen for incoming connections from clients. Here's the typical workflow for a server:
- Create a socket.
- Bind the socket to an IP address and port.
- Listen for client connections.
- Accept an incoming connection.
- Communicate (send/receive data).
- Close the sockets.
Creating a Python TCP Socket
In Python, we use the built-in socket module. To create a TCP socket, we specify socket.AF_INET for IPv4 addressing and socket.SOCK_STREAM for TCP.
Try running this basic example:
import socket
def main():
# Create a TCP/IP socket
# AF_INET for IPv4, SOCK_STREAM for TCP
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("TCP socket created successfully!")
tcp_socket.close()
print("Socket closed.")
if __name__ == "__main__":
main()Server: Bind to Address & Port
After creating the socket, the server needs to bind it to a specific IP address and port number. This tells the operating system where the server will listen for connections.
.bind((HOST, PORT)) associates the socket. .listen(backlog) prepares it to accept connections, with backlog being the max queued connections.
import socket
def main():
HOST = '127.0.0.1' # Localhost
PORT = 65432 # Port to listen on (non-privileged)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
server_socket.bind((HOST, PORT))
server_socket.listen(1) # Allow 1 pending connection
print(f"Server listening on {HOST}:{PORT}")
except Exception as e:
print(f"Error binding or listening: {e}")
finally:
server_socket.close()
print("Server socket closed.")
if __name__ == "__main__":
main()Server: Accepting a Client
The .accept() method is crucial for a server. It blocks execution until a client tries to connect. When a connection is made, it returns two values:
- A new socket object (
conn) for communicating with that specific client. - The client's address (
addr), a(host, port)tuple.
import socket
def main():
HOST = '127.0.0.1'
PORT = 65432
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen(1)
print(f"Server waiting for connection on {HOST}:{PORT}...")
# This will block until a client connects
conn, addr = server_socket.accept()
with conn: # Use 'with' for auto-closing the client socket
print(f"Connected by client from {addr}")
# In a real app, send/recv would happen here
conn.sendall(b"Hello from server!") # Send some bytes
print("Sent greeting to client.")
server_socket.close()
print("Server socket closed.")
if __name__ == "__main__":
main()TCP Client: Initiating Connection
A TCP client's role is to initiate a connection to a server. Here's its typical workflow:
- Create a socket.
- Connect to the server's IP address and port.
- Communicate (send/receive data).
- Close the socket.
Client: Connecting to Server
The client uses the .connect((HOST, PORT)) method to establish a connection with the server. If successful, a virtual circuit is created. If the server isn't listening, you'll get a ConnectionRefusedError.
Run this. If no server is running, it will show an error:
import socket
def main():
HOST = '127.0.0.1' # Server's IP address
PORT = 65432 # Server's port
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
print(f"Attempting to connect to server at {HOST}:{PORT}...")
client_socket.connect((HOST, PORT))
print("Successfully connected to the server!")
except ConnectionRefusedError:
print("Connection refused. Is the server running?")
except Exception as e:
print(f"Client connection error: {e}")
finally:
client_socket.close()
print("Client socket closed.")
if __name__ == "__main__":
main()Sending & Receiving Data
Once connected, both client and server can send and receive data. Remember that network data is transmitted as bytes, so you'll often need to .encode() strings before sending and .decode() received bytes back into strings.
.sendall(data): Sends all data reliably..recv(buffer_size): Receives up tobuffer_sizebytes.
import socket
def main():
HOST = '127.0.0.1'
PORT = 65432
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
client_socket.connect((HOST, PORT))
message = "Hello from the client!"
client_socket.sendall(message.encode('utf-8'))
print(f"Client sent: '{message}'")
data = client_socket.recv(1024) # Receive up to 1024 bytes
if data:
print(f"Client received: '{data.decode('utf-8')}'")
else:
print("Client received no data (server might have closed).")
except ConnectionRefusedError:
print("Connection refused. Please run the server example first!")
except Exception as e:
print(f"Client communication error: {e}")
finally:
client_socket.close()
print("Client socket closed.")
if __name__ == "__main__":
main()TCP Communication Flow
Consider the typical steps for a Python TCP server to establish a connection and an echo client to communicate.
Recap: TCP Client-Server Sockets
Great job! You've learned the fundamentals of TCP client-server communication in Python:
- TCP provides reliable, connection-oriented communication.
- Servers bind to an address, listen for connections, and accept clients.
- Clients connect to a server's address.
- Both use
.sendall()to send and.recv()to receive bytes.
These concepts are crucial for building robust networked applications!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Soket Klien-Server TCP” gratis?
Ya — teks lengkap “Soket Klien-Server TCP” 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 TCP”?
Implementasikan komunikasi andal yang berorientasi koneksi dengan membangun aplikasi klien dan server TCP dasar dalam Python. 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 2 dari 4.
Berapa lama pelajaran “Soket Klien-Server TCP” 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
- Pengenalan API Soket
- Soket Klien-Server TCP
- Soket Klien-Server UDP
- Soket Non-Pemblokiran dan select()