Table of Contents
- Overview
- Prerequisites
- Setup
- Creating a Simple Web Server
- Handling Requests
- Customizing the Server
- Conclusion
Overview
In this tutorial, we will learn how to build a web server using Python’s BaseHTTPServer module. We will start by creating a simple web server that can serve static files. Then, we will explore how to handle different types of HTTP requests and customize the server according to our needs.
By the end of this tutorial, you will be able to create a basic web server and understand how to extend its functionality.
Prerequisites
To follow along with this tutorial, you should have a basic understanding of Python programming. Familiarity with web development concepts such as HTTP and URLs will be beneficial but not required.
Setup
Before we begin, make sure you have Python installed on your system. You can download the latest version of Python from the official website (https://www.python.org).
Once you have Python installed, open a terminal or command prompt and check the version by running the following command:
python
python --version
If the command returns the Python version correctly, you are ready to proceed.
Creating a Simple Web Server
To create a simple web server, we’ll start by importing the necessary modules and defining a handler class that inherits from BaseHTTPServer.BaseHTTPRequestHandler. This handler will handle incoming requests and send appropriate responses.
Create a new Python file, for example, web_server.py, and add the following code:
```python
import os
import BaseHTTPServer
class WebServerHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write('Hello, World!')
if __name__ == '__main__':
server_address = ('', 8000)
httpd = BaseHTTPServer.HTTPServer(server_address, WebServerHandler)
print('Server running on port 8000...')
httpd.serve_forever()
``` Save the file and run it from the terminal using the following command:
```python
python web_server.py
``` Now, if you open a web browser and visit `http://localhost:8000`, you should see the message "Hello, World!" displayed on the page.
Congratulations! You have just created a basic web server using Python’s BaseHTTPServer.
Handling Requests
In the previous section, we created a simple web server that responds with a fixed message for all GET requests. However, in a real-world scenario, we often need to handle different types of requests and serve dynamic content.
To handle different types of requests, we can override the do_METHOD() methods in our WebServerHandler class, where METHOD can be GET, POST, PUT, DELETE, etc.
Let’s modify our example to handle a POST request and return the posted data. Update the do_GET() method with the following code:
```python
def do_POST(self):
content_length = int(self.headers[‘Content-Length’])
post_data = self.rfile.read(content_length)
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write('You posted: {}'.format(post_data))
``` Now, when we send a POST request to our server, we will see the posted data in the response.
Customizing the Server
Python’s BaseHTTPServer provides a simple way to customize and extend the functionality of our web server.
We can override the do_METHOD() methods to define our own request handlers and responses. We can also override other methods like handle_one_request(), log_request(), etc., to customize the server behavior further.
For example, let’s add a custom path to our server and respond differently based on that path. Modify the do_GET() method as follows:
python
def do_GET(self):
if self.path == '/':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write('Welcome to the Home Page!')
elif self.path == '/about':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write('This is the About Page.')
else:
self.send_error(404)
Now, if you visit http://localhost:8000/ in your browser, you will see the message “Welcome to the Home Page!” displayed. Similarly, if you visit http://localhost:8000/about, you will see “This is the About Page.”
Feel free to customize the server further according to your needs.
Conclusion
In this tutorial, we learned how to build a basic web server using Python’s BaseHTTPServer module. We started by creating a simple server that can serve static files and then explored how to handle different types of requests and customize the server’s behavior.
Python’s BaseHTTPServer provides a foundation for building web servers, but it may not be suitable for production-level applications. For production use, consider using more robust frameworks like Flask or Django.
We hope this tutorial helped you understand the basics of building a web server in Python. Experiment with the code and explore more options to enhance your server’s functionality.
Happy coding!