TCP 클라이언트-서버 소켓
Python으로 기본 TCP 클라이언트와 서버 애플리케이션을 구축하여 안정적인 연결 지향적 통신을 구현합니다.
TCP 클라이언트-서버 소켓은(는) CoddyKit의 무료 Linux Networking & TCP/IP for Developers 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Linux Networking & TCP/IP for Developers 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Linux Networking & TCP/IP for Developers 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
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!
자주 묻는 질문
“TCP 클라이언트-서버 소켓” 강의는 무료인가요?
네 — “TCP 클라이언트-서버 소켓” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Linux Networking & TCP/IP for Developers 강의 전체를 잠금 해제할 수 있습니다. Linux Networking & TCP/IP for Developers 강의에는 총 4개의 강의가 포함되어 있습니다.
“TCP 클라이언트-서버 소켓”에서 뭘 배우나요?
Python으로 기본 TCP 클라이언트와 서버 애플리케이션을 구축하여 안정적인 연결 지향적 통신을 구현합니다. 브라우저에서 직접 실행하는 실습 코드로 Linux Networking & TCP/IP for Developers을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Linux Networking & TCP/IP for Developers을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Linux Networking & TCP/IP for Developers은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.
“TCP 클라이언트-서버 소켓” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Linux Networking & TCP/IP for Developers 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Linux Networking & TCP/IP for Developers 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.
이 강의의 모든 강의
- 소켓 API 소개
- TCP 클라이언트-서버 소켓
- UDP 클라이언트-서버 소켓
- 비차단 소켓 및 select()