Have you ever wondered how your device is connected over the Internet? Or how the business manages to share information across regions seamlessly? All this is achieved using computer networks as part of the business strategy. It allows us to establish communication, collaborate, and share resources among different applications and devices in the network over the Internet. Now, you can contact or share things with your friends or anyone with just one click, thanks to the integration of networking with software applications, and various other technologies. In Python, networking is a fundamental concept that enables the interaction between devices and external resources. Python includes many built-in modules that support networking capabilities, such as `socket` for general networking and `requests` for HTTP communication.
Therefore, in this article, we will discuss networking from its basic concepts to advanced concepts in Python using practical examples.
Introduction to Networking Concepts
1. Networking and Its Significance In Distributed Systems
Networking involves connecting multiple computers and devices via wired cables or wireless networks to exchange data and share resources over the Internet. It allows communication between multiple devices. As we know, distributed systems are those in which large numbers of clients, hardware devices, and processes are connected to share resources and communicate. Therefore, networking and distributed systems are significantly interconnected. They provide the infrastructure that facilitates storage, resource sharing, and electronic communication to enhance the efficiency and productivity of the system.
2. Key Networking Concepts
Some key networking concepts that we use in our day-to-day lives are as follows:
2.1. IP Address
An IP address uniquely identifies your device on a network. If you have a device that connects to the Internet, it must have an IP address. IP stands for Internet protocol. It is a unique number or an identifier for the computer or device within the network. Every device would have a unique number that makes it different from the other devices within the network. For example:
IPv4: 32-bit address: 192.168.1.1
IPv6: 128-bit address: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
Note:
An IP address is a unique string of numbers separated by full stops that identifies each computer that uses the Internet protocol to communicate over a network.
2.2. Port
A port is a numerical identifier used in networking to specify a particular service or process on a device. In contrast with an IP address, which identifies the location of a device on a network, ports allow multiple services to operate concurrently on the same device. It ensures that data is directed to the correct application or process. These ports are ranges from 0 to 65535, having certain scale reserved for specific protocols. For example:
HTTP uses port 80
HTTPS uses port 443
2.3. Protocol
A network protocol is a set of procedures and practices for communication between network devices. It defines how data are formatted, transmitted, and received. Examples include HTTP, FTP, SMTP, and DNS. Protocols can operate at various layers in the OSI model, such as the application layer (HTTP), transport layer (TCP), and network layer (IP).
2.4. Sockets
A socket is a network endpoint for sending or receiving data across multiple devices. It involves a pairing of an IP address and a port number. Sockets can be of two main types: SOCK_STREAM for TCP connections, which are connection-oriented, and SOCK_DGRAM for UDP connections, which are connectionless. Sockets enable the implementation of various network services, such as web and email servers.
3. OSI Model and The TCP/IP Stack
Certain models are defined that tell us how to connect our devices or computers over the Internet so that they can interact and communicate with each other. There are two primary models for defining networking. OSI model or TCP/IP stack. Let us get an overview of each of them briefly:
3.1. TCP/IP Stack
The TCP/IP stack is a suite of communication protocols used to interconnect network devices on the Internet, ensuring reliable data transmission and communication. It is a set of procedures on how computers can interact and how to design those systems. To understand the functions, it is divided into five layers. Each layer has its work, and these are the Application, Transport, Network Access, Data Link, and Physical layers. The TCP/IP stack provides a practical implementation of networking in the real world in contrast with the OSI model, which provides a theoretical understanding of networking communication. In addition, the Transport layer provides the facility for reliable data transmission, and Network Access ensures the correct IP address and routing of data packets, and so on.
3.2. OSI Model
Similar to TCP/IP, the OSI model is also used to design the network across multiple devices. It is a conceptual framework consisting of a set of procedures for understanding and implementing network protocols in seven different layers. It shares the same layer as TCP/IP, with an additional layer. These includes: Application, Presentation, Session, Transport, Network Access, Data Link, and Physical Layer. Specifically, the main difference between OSI and TCP/IP is the two additional layers molded into the application layer of TCP/IP.
Socket Programming Basics
1. Socket Programming As The Foundation Of Networking In Python
Networking involves the connection of two or more devices such that communication is possible within them. In Python, sockets programming is a fundamental and core network creation mechanism. For socket programming, we need to import the socket module. Using the socket module, a developer can generate, configure, and manage sockets for TCP and UDP communication. This module has many built-in methods required for creating sockets and helping them associate with each other. A few important methods that are used are socket.socket, which is used to create a socket. This socket is used on both the client and server sides. Moreover, to accept the communication, we use the socket.accept method.
Note
TCP stands for transmission control protocol, which is a connection-oriented protocol that ensures reliable data transfer. UDP is a user datagram protocol, a connectionless protocol that prioritizes speed over reliability.
2. Sockets As Endpoints For Communication Between Machines
Sockets are the network endpoints used for sending and receiving data. By default, a single network has two sockets, one for each communication device. These sockets combine IP addresses and port numbers. In addition, a single device can have N sockets based on the port number used. Different ports are available for different types of protocols; for example, HTTP uses port 80. Through this endpoint mechanism, developers can ensure an accurate and reliable exchange of data in various networking scenarios.
3. Example: Creating and Using Sockets for Basic Network Communication
Now that we have understood what socket programming is as it is the foundation of Python programming, let's move to the code editor and see how we can create it. We must create two different files for the client and server sides to establish the connection.
server.py
import socket #Import library
#Create a socket object and then define two arguments first one specifies the IP address
#and second indicate the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen to the connection
soc.listen(5)
while True:
#Set client socket and address and make a connection
clt, addr = soc.accept()
print(f"Connection Established to address {addr}")
msg = "Message Received and the message is ->"
clt.send(bytes(msg + "Socket Programming in Python", "utf-8"))
client.py
import socket #Importing the module
#Create a socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of the message how much you want to receive
msg = soc.recv(100)
print(msg.decode("utf-8"))
Working with TCP/IP
1. Transmission Control Protocol (TCP) And Its Role in Communication
TCP, also known as transmission control protocol, is a transport layer protocol within the TCP/IP model. It consists of a set of protocols and procedures that decide how to send data over the Internet. Usually, when data are sent as files, they are broken down into individual packets. When packets arrive at the destination with a unique number for each packet. We can assemble them with it. In addition, if some packets are missing, TCP ensures that they are resend. This is why we call TCP a reliable protocol for communication because it establishes communication through the handshake process, acknowledges the received data, and retransmits lost packets by maintaining the correct order of packets and ensuring data integrity and delivery.
2. Example: Creating TCP Client And Server Applications In Python
The server is the software that waits for the client's request, and the client requests the resources from the server. Socket programming is mostly implemented for the client-server architecture. Here, we discuss the example of creating a client and a server where the client sends a message, and the server responds to that message and gives the appropriate response to that request using the socket module with TCP. Let us design both the client and server model.
server.py
import socket #Import socket library
def start_server():
#Create a TCP/IP socket
#Create a socket object and then define two arguments first one specifies the IP
address
#and second for indicating the use of a TCP socket.
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Bind the socket to the port
server_address = ('localhost', 65432)
print('Starting server on {} port {}'.format(*server_address))
server_socket.bind(server_address)
#Listen for incoming connections
server_socket.listen(1)
while True:
#Wait for a connection
print('Waiting for a connection')
connection, client_address = server_socket.accept()
try:
print('Connection from', client_address)
#Receive the data and send it back
while True:
data = connection.recv(1024)
if data:
print('Received: {}'.format(data.decode()))
connection.sendall(data)
else:
print('No more data from', client_address)
break
finally:
#Clean up the connection
connection.close()
if __name__ == '__main__':
start_server()
client.py
import socket #import socket library
def start_server():
#Create a TCP/IP socket
#Create a socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of a TCP socket.
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Connect the socket to the server's port
server_address = ('localhost', 65432)
print('Connecting to {} port {}'.format(*server_address))
client_socket.connect(server_address)
try:
#Send data
message = 'Hello, Server!'
print('Sending: {}'.format(message))
client_socket.sendall(message.encode())
#Look for the response
amount_received = 0
amount_expected = len(message)
while amount_received < amount_expected:
data = client_socket.recv(1024)
amount_received += len(data)
print('Received: {}'.format(data.decode()))
finally:
#Close the socket
print('Closing socket')
client_socket.close()
if __name__ == '__main__':
start_client()
3. Building A Simple Chat Application Using TCP Sockets
Let us create a simple chat application in Python using TCP sockets, where the server listens to the incoming commands and the client connects to that server to send and receive messages. We are going to build the chat room using the Python built-in module i.e. socket. So, we need to write code for each side like the client and the server, separately:
server.py
import socket #Import library
#Create a socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen the connection
soc.listen(5)
print("Server listening...")
#Set client socket and address and make connection
clt, addr = soc.accept()
print(f"Connection Established to address {addr}")
try:
while True:
data = clt.recv(1024).decode('utf-8')
if not data:
break
print(f"Received from client: {data}")
clt.send("Message received".encode('utf-8'))
finally:
clt.close()
soc.close()
client.py
import socket #Importing the module
#Create socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of message how much you wanna receive
try:
while True:
message = input("Enter your message: ")
soc.send(message.encode('utf-8'))
data = soc.recv(1042).decode('utf-8')
print(f"Received from server: {data}")
finally:
soc.close()
Wrapping Up
Networking is a crucial concept in computer science and programming. It resolves most human problems, whether you are working in your office or sharing files with your team. Alternatively, contact a relative from another country. In summary, we focused on the solid introduction of networking foundations using Python. We learned the essential topics of network controls and models, client and server architecture, and practical examples using the socket library. This library ensures the establishment of a secure and reliable network for distributed systems. Keep experimenting and building upon these skills to further enhance your proficiency in network programming. Hope this guide is helpful. Thank you for reading. Happy Coding!
Top comments (0)