What is Apache?

Apache HTTP Server, commonly referred to as Apache, is one of the most popular and widely used open-source web servers in the world. Originally developed by the Apache Software Foundation and first released in 1995, Apache plays a critical role in serving web content over the Internet.

Apache acts as a software intermediary between a client (such as a web browser) and the web server’s content (HTML files, images, scripts, etc.). It receives requests from clients and serves back the appropriate responses. Apache supports a wide range of features, including dynamic content processing, authentication, SSL/TLS encryption, URL rewriting, and load balancing.

Apache’s modular architecture, reliability, and robust community support have made it the de facto choice for web hosting, powering a significant portion of the internet’s websites.

Major Use Cases of Apache

1. Web Hosting

Apache is widely used to host websites, from simple static pages to complex, dynamic applications. It supports various content types and scripting languages (PHP, Python, Perl).

2. Serving Dynamic Web Content

By integrating with server-side technologies like CGI, FastCGI, and modules such as mod_php, Apache can serve dynamic web content generated by applications.

3. Reverse Proxy and Load Balancing

Apache can act as a reverse proxy server, forwarding client requests to backend servers, balancing load, and providing fault tolerance.

4. Secure Web Server

Apache supports HTTPS through SSL/TLS modules, providing encrypted communication for secure web applications.

5. Virtual Hosting

Apache supports hosting multiple websites/domains on a single server, each with its own configuration.

6. API Gateway

By handling HTTP requests, Apache can be used as a gateway to backend APIs, adding features such as caching, authentication, and rate limiting.

7. Content Compression and Caching

Modules allow Apache to compress responses (e.g., gzip) and cache frequently requested content, enhancing performance.

How Apache Works Along with Architecture

Apache follows a client-server model where the server listens for HTTP requests and responds accordingly.

Core Architectural Components:

• Main Process

The main Apache process runs with administrative privileges, managing configuration, spawning worker processes/threads, and handling shutdowns and restarts.

• Child Processes/Workers

These are spawned by the main process to handle incoming HTTP requests. Depending on the Multi-Processing Module (MPM) used, Apache can handle requests using multiple processes, threads, or a combination.

• Modules

Apache’s modular architecture allows extending core functionality with loadable modules (DSOs). Modules provide features like URL rewriting, authentication, SSL support, logging, caching, and more. Common modules include:

• mod_ssl: SSL/TLS support
• mod_rewrite: URL rewriting
• mod_proxy: Proxying requests
• mod_auth: Authentication mechanisms
• mod_cache: Caching
• Configuration Files

Apache’s behavior is controlled through configuration files, primarily httpd.conf and additional files like .htaccess for directory-level configuration overrides.

• Request Handling Flow
  1. Client sends an HTTP request.
  2. Apache accepts the connection via socket.
  3. The request is parsed and routed based on the URL and configuration.
  4. Appropriate modules are invoked to process the request.
  5. Content is served (static or dynamically generated).
  6. Response is sent back to the client.

Multi-Processing Modules (MPMs)

MPMs define how Apache manages connections:

• prefork MPM: Uses multiple child processes with one thread each; preferred for compatibility with non-thread-safe libraries.
• worker MPM: Uses fewer child processes with multiple threads; more efficient for high loads.
• event MPM: Similar to worker but optimized for handling keep-alive connections efficiently.

Basic Workflow of Apache

1. Server Initialization

Upon startup, Apache reads its configuration files, loads necessary modules, and initializes worker processes or threads.

2. Listening for Connections

Apache listens on configured IP addresses and ports (typically port 80 for HTTP, 443 for HTTPS).

3. Accepting Client Requests

When a client (browser or API consumer) sends a request, Apache accepts it and creates a request object.

4. Request Processing

Apache determines how to process the request using its configuration, routing it to the appropriate handler module.

5. Content Generation

The requested content (static files or dynamic scripts) is retrieved or generated.

6. Response Delivery

Apache sends the HTTP response back to the client, including headers and body content.

7. Connection Handling

Depending on configuration, Apache may keep the connection alive for further requests or close it.

Step-by-Step Getting Started Guide for Apache

Step 1: Install Apache

• On Linux (Ubuntu/Debian):

sudo apt update
sudo apt install apache2

• On CentOS/RHEL:

sudo yum install httpd
sudo systemctl start httpd
sudo systemctl enable httpd

• On Windows:

Download from Apache Lounge and follow the installer instructions.

Step 2: Verify Installation

Open a browser and navigate to http://localhost. You should see the Apache default welcome page.

Alternatively, run:

apachectl status

or

systemctl status apache2

Step 3: Configure Apache

• Configuration files are located at:
  • /etc/apache2/ (Ubuntu/Debian)
  • /etc/httpd/ (CentOS/RHEL)
  • Apache’s httpd.conf file is the primary configuration file.
• Edit configuration files with a text editor, e.g.,

sudo nano /etc/apache2/sites-available/000-default.conf

Step 4: Serve Your Website

• Place your website files (HTML, CSS, JS) in the web root directory:
  • /var/www/html on most Linux systems.
• Test by navigating to http://localhost/index.html.

Step 5: Enable Modules

• Enable modules like SSL or rewrite as needed:

sudo a2enmod ssl
sudo a2enmod rewrite
sudo systemctl restart apache2

Step 6: Set Up Virtual Hosts

To serve multiple sites:

• Create separate configuration files under sites-available, e.g.,

sudo nano /etc/apache2/sites-available/example.com.conf

• Enable the site:

sudo a2ensite example.com.conf
sudo systemctl reload apache2

Step 7: Configure Firewall

Allow HTTP and HTTPS traffic:

sudo ufw allow 'Apache Full'

Step 8: Enable HTTPS (Optional)

• Use Let’s Encrypt for free SSL certificates:

sudo apt install certbot python3-certbot-apache
sudo certbot --apache

Step 9: Monitor Logs and Performance

• Access logs: /var/log/apache2/access.log
• Error logs: /var/log/apache2/error.log

Use logs to troubleshoot and optimize performanc

Apache Installation

Apache gives its functionality and the components to individual units which can be customized and configured independently. The basic unit that describes a site or a domain is called a virtual host.

This allows the administrator to use one server to host multiple domains or sites with a single interface or IP address by using a mechanism.

$ sudo apt-get update
$ sudo apt-get install apache2

Create the Directory Structure

A directory structure shall hold the site information and data which will be served to visitors. By default, the top-level directory for apache is /var/www and we will be setting them to the individual directories under the /var/www directory for each site/domain.

$ sudo mkdir -p /var/www/firstSite.com
$ sudo mkdir -p /var/www/secondSite.com

Grant Permissions

Our directory’s owned by our root user. If we want our normal user to be able to modify files in our web directories, then we have to change the ownership to others normal users.

$ sudo chown -R $USER:$USER /var/www/firstSite.com
$ sudo chown -R $USER:$USER /var/www/secondSite.com
$ sudo chmod -R 755 /var/www

Create Demo Pages for for both sites.

To create a file we use touch command, The touch command is a standard command used in UNIX/Linux operating system which is used to create, change and modify timestamps of a file.

$ touch /var/www/webserver1.com/index.html

Then put some lines of html.

<!DOCTYPE html>
<html>
<head>
<title>Site one</title>
</head>
<body>

<h1>Site one heading</h1>
<p>My first paragraph.</p>

</body>
</html>

We’ll copy and past the same page for second server and modify it accordingly

$ cp /var/www/firstSite.com/index.html /var/www/secondSite.com/index.html

$ nano /var/www/webserver2.com/index.html
<html>
   <head>
      <title>Welcome to secondSite.com!</title>
   </head>
   <body>
      <h1>Success!</h1>
   </body>
</html>

Create New Virtual Host Files

$ sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/firstSite.conf
$ sudo nano /etc/apache2/sites-available/firstSite.com.conf

<VirtualHost *:80>
   ServerAdmin admin@firstSite.com
   ServerName firstSite.com
   ServerAlias www.firstSite.com
   DocumentRoot /var/www/firstSite.com/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Copy First Virtual Host file and customize for Second Domain webserver2.com

$ sudo cp /etc/apache2/sites-available/firstSite.com.conf /etc/apache2/sites-available/secondSite.com.conf
$ sudo nano /etc/apache2/sites-available/secondSite.com.conf

Do the same thing for secondSite VH

<VirtualHost *:80>
   ServerAdmin admin@secondSite.com
   ServerName secondSite.com
   ServerAlias www.secondSite.com
   DocumentRoot /var/www/secondSite.com/
   ErrorLog ${APACHE_LOG_DIR}/error.log
   CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Enable the New Virtual Host Files

$ sudo a2ensite webserver1.com.conf
$ sudo a2ensite webserver2.com.conf

We needed to restart Apache server

$ sudo service apache2 restart

Testing the Websites

$ sudo /etc/hosts

192.168.1.84 website1.com
192.168.1.84 website1.com