vi is a powerful text editor that runs on Linux and UNIX systems, commonly used for editing configuration files, programming, and general text manipulation. It is known for its efficiency and speed once users are familiar with its commands.
vi is my editor of choice while I am connected to a web server via the Secure Shell (SSH). I am a PHP programmer and have a home lab that consists of using VirtualBox to create virtual machines. These virtual machines are web servers created for PHP development and testing. They are Linux, Apache, MySQL, and PHP (LAMP).
I use Ubuntu servers to create these LAMP web servers. Vi is one of the tools in my toolbox.
Why use vi?
Pre-installed: vi is usually available by default on almost all Linux distributions, making it convenient when working on servers or systems with minimal software installed.
Efficiency: vi allows advanced users to perform complex text editing tasks quickly and with precision.
Lightweight: It is a lightweight editor that consumes minimal system resources, which is ideal for working on remote servers or in environments with limited resources.
The best way to learn Vi is to create a new file and try it out for yourself.
1) VI Operates in Three Main Modes:
Normal Mode: This is the default mode. You can navigate and manipulate text using various commands.
Insert Mode: Add, Edit, Delete, and Copy text. Press the i key to activate insert mode. In insert mode, one can add, edit, delete, copy text, and move text around.
Command Mode: You enter this mode by pressing : (colon key) while in normal mode, to run commands like saving, quitting, or searching.
2) I Only Use a Subset of What is Available.
Type “vi <file-name>” on the command line to edit or create a file.
Pressing the “i” key switches us into Insert mode.
Pressing the “ESC” key switches us out of Insert mode into normal mode.
Pressing the “:” (colon) switches us into command mode.
dd command – Remove a line.
:q To quit when no changes have occurred.
:q! To not save changes.
:w Save and continue editing.
:wq To write (save) and quit (exit editing of file)
:set nu — Display line numbers.
:set nonu – Stop displaying line numbers.
3) Commands I Rarely or Never Use:
yy — Copy the current line. Referred to as yank(ed)
p — Paste the yanked line.
o — New line under the current line.
O — New line above the current line.
A — Append to the end of the line.
a — Append after the cursor’s current position.
I — Insert text at the beginning of the current line.
b — Go to the beginning of the word.
e — Go to the end of the word.
x — Delete a single character. (where the cursor is blinking)
dd — Delete the current line.
[number]dd — Delete X number of lines.
[number]yy — Yank X number of lines.
G — Go to the end of the file.
XG — Go to line X in a file.
gg — Go to the first line in a file.
h — Move left one character.
j — Move down one line.
k — Move up one line.
l — Move right one character.
Conclusion
Vi is the editor I like to use when connected to a remote server. I manage virtual web hosts on VirtualBox. Vi makes it easy to manage all the configurations a LAMP server contains.
In this article we learned that vi has Three Main Mode, is always available on Linux and Unix servers, and is easy to use once some of the features are understood.
I am a PHP developer. I use Linux, Apache, MySQL, and PHP (LAMP) to further that goal.
I have published a number of YouTube videos and blog posts that document configuring a LAMP server for development and testing.
I am using an older HP laptop that is running Windows 10. On that, I have installed VirtualBox.
VirtualBox is a type two hypervisor that allows me to create virtual machines.
In this context, Linux is the operating system of the web server. Most PHP websites run on Linux web servers and are configured as a LAMP stack.
Apache serves web pages to users who request them via browsers, handling HTTP requests and delivering the corresponding web content (HTML files, images, etc.) from a server to a client (usually a web browser).
MySQL is an open-source relational database management system (RDBMS) that uses Structured Query Language (SQL) to manage and interact with databases. It is widely used for storing and retrieving data in a variety of applications, from web development to enterprise-level solutions.
PHP (Hypertext Preprocessor) is a popular general-purpose scripting language that is especially suited to web development. It is a server-side language, meaning that it runs on a web server rather than in the user’s browser, allowing developers to create dynamic web pages and other content.
I have created a private network in my home office. This network uses private non-routable IP addresses and private non-routable domain names.
I have configured two virtual hosts on my server:
1) default.internal.
2) lamp.internal.
I have created two users:
1) default.
2) lamp.
The user named default is the owner of the virtual host that is created by Apache when Apache is installed. This virtual host is incomplete. I completed the virtual host configuration so I can use it as a model for the virtual hosts I will build in the future. This virtual host can be accessed by a browser by using the private domain, default.internal.
The user named lamp is the owner of the lamp virtual host and is accessed by a browser using the private domain lamp.internal.
Both users were configured to allow them to use SSH (Secure Shell).
I am configuring my server this way so I can access the virtual host remotely with the ability to create, read, update, and delete files and directories on the remote server.
To complete the goal of remote editing we need to install and configure PHP-FPM. PHP-FPM stands for PHP FastCGI Process Manager.
SPM will enhance the performance of an Apache web server, however I am using it to enable the ability for remote editing.
My daily driver is a 10 year old Dell that is running Kunbuntu (Linux). Native to Kunbuntu is the Linux terminal that allows me to access a remote server. I also have installed Visual Studio Code on this computer which allows for remote editing of PHP code.
Even though VirtualBox is running on my laptop running Windows 10, any virtual server created using VirtualBox is remote to that Windows configuration.
We start by installing and configuring PHP-FPM. This install is only required once.
In the 2nd part, I will configure an Apache virtual host to take advantage of PHP-FPM.
After completing part 1, any time you want to configure an Apache virtual host to take advantage of the PHP-FPM install, you will only need to follow the 2nd part – where I configure an Apache host to use PHP-FPM.
**********************************************************
**********************************************************
*** Install and Activate PHP-FPM ONLY ***
**********************************************************
**********************************************************
To install, activate, start, and configure PHP-FPM on Ubuntu 24.04 LTS without modifying Apache2 configuration or vhost settings, you can follow these steps. This will ensure that PHP-FPM is running and available for use without interfering with Apache’s default settings.
Step 1: Upgrade and Update all of the server packages
Step 2: Create the configuration file for the lamp user:
– sudo vi /etc/php/8.3/fpm/pool.d/lamp.conf
Add the following content:
[lamp] ; Define the pool name, which will be referenced by PHP-FPM
user = lamp ; Set the user under which PHP-FPM will run
group = lamp ; Set the group under which PHP-FPM will run
listen = /run/php/php8.3-fpm.lamp.sock ; Define the socket path for the pool (for communication with the web server)
listen.owner = www-data ; Set the owner of the socket file
listen.group = www-data ; Set the group of the socket file
listen.mode = 0660 ; Set the permissions for the socket file (660 = read/write for owner/group)
pm = dynamic ; Enable dynamic process management (adjusts worker count based on demand)
pm.max_children = 50 ; Maximum number of child processes to handle requests
pm.start_servers = 5 ; Number of child processes created on startup
pm.min_spare_servers = 5 ; Minimum number of idle servers to keep alive
pm.max_spare_servers = 10 ; Maximum number of idle servers to keep alive
pm.max_requests = 5000 ; The maximum number of requests a child process should handle before being restarted
php_admin_value[error_log] = /var/log/php8.3-fpm/lamp_error.log ; Set a custom error log for this pool
php_admin_value[log_errors] = on ; Enable error logging
env[PATH] = /usr/local/bin:/usr/bin:/bin ; Define the environment variables (add more if needed)
** The bolded values should be changed to the user for the virtual host you are configuring.
** Remove all spaces from the left of this code or you will receive an error.
Step 3: Set ownership, permissions, and home directory
Step 7: Ensure that both domains are configured correctly and accessible in your browser:
– Make sure the site is viewable in a browser : http://lamp.internal/info.php
– Look for “Server API” with the value: “FPM/FastCGI”
– Connect via Filezilla.
– Use PuTTy or a Linux Konsole to verify the SSH connection is working.
– Use Visual Studio Code to verify that code can be edited.
– Use Visual Studio to create a PHP script that will create a text file, proving PHP is working correctly under PHP-FPM: Using Visual Studio code create a new file and name it : php-tester.php. Copy and paste the following code into that file and save it. Then run it in your browser : http://lamp.internal/php-tester.php
<?php // The name of the file to be created $filename = "test_file.txt"; // Open the file for writing (creates file if it doesn't exist) $file = fopen($filename, "w"); // Check if the file is created successfully if ($file) { fwrite($file, "This file was created by PHP!"); fclose($file); echo "File '$filename' was successfully created!"; } else { echo "Failed to create the file."; } ?>
– If all is working as expected you should find a file by the name of test_file.txt with the contents of “This file was created by PHP!”.
Conclusion
In this article we covered how to install PHP-FPM and configure it to work with an Apache virtual host.
PHP-FPM serves two purposes: 1) is it a performance enhancer, 2) it provides a way for us to remote edit our PHP code directly on the server.
Installing and configuring PHP-FPM is only required once. That would be the first part which consists of 9 steps.
The second set of 7 steps has to be completed every time you want to configure a new virtual host.
I do this so I will land in the docroot of the virtual host when using SSH, FileZilla, and/or Visual Studio Code. This configuration aids me when I want to edit PHP remotrely using Visual Studio Code.
The command sudo usermod -d is used to change the home directory of a user on a Unix-like operating system. In this case I use this command on Ubuntu 24.04LTS.
Here’s a Breakdown of the Command
sudo: This command runs the following command with superuser (root) privileges, which are often necessary for modifying user accounts.
usermod: This is the command used to modify user account settings.
-d <directory-path>: This option specifies the new home directory for the user.
username: This is the placeholder for the actual username of the account whose home directory you want to change.
Apache configures a default virtual host as part of the initial installation. This virtual host is incomplete as a virtual host. I completed the build of the default Apache virtual host.
As part of the build out I added a user named default and changed it’s home directory to /var/www/html by the following command:
– sudo usermod -d /var/www/html default
Key Points
Changing Home Directory: This command changes where the user’s files and settings are stored. By default, a user’s home directory is often located in /home/username.
Permissions: Ensure that the new directory (<directory-path>) has the appropriate permissions for the user to access and manage files there.
Impact: Changing the home directory can affect scripts, applications, and settings that rely on the old home directory path.
Make sure to back up any important data before making such changes.
To create an SSH user on Ubuntu 24.04lts and restrict access using the AllowUsers directive without using SSH keys, follow these steps:
sudo adduser <user-name>
Follow the prompts to set a password and fill in any additional user information.
2. Update SSH Configuration: Open the SSH configuration file in a text editor:
sudo vi /etc/ssh/sshd_config
3. Find the #AllowUsers line (if it exists) and uncomment it. Then, add your new user to the list. If there is not a line containing AllowUsers add it.
For example:
AllowUsers user1 user2 newuser
If there are other users listed, you can separate them with spaces:
4. Password Authentication: Make sure password authentication is enabled in the SSH configuration.
Uncomment “PasswordAuthentication yes” by removing the hashtage from in front of it.
5. Restart the SSH Service: After saving the changes, restart the SSH service to apply them:
sudo systemctl restart ssh
6. Test SSH Access: From a different terminal or machine, try to SSH into your Ubuntu server using the new user:
ssh newuser@your_server_ip
You should be prompted for the password you set earlier.
7. Important Considerations
Firewall Rules: Ensure that your firewall allows SSH connections (typically on port 22).
Security: Using password authentication can be less secure than using SSH keys. Consider setting up key-based authentication if possible.
That’s it! You’ve created an SSH user and restricted access using AllowUsers.
The .htaccess file is a configuration file used by the Apache web server to manage settings on a per-directory basis. It allows you to override global settings without modifying the main server configuration file. Common uses for .htaccess include:
URL Rewriting: Redirecting URLs or creating cleaner, more readable URLs using the RewriteRule directive.
Access Control: Restricting access to specific files or directories with directives like Require or Deny.
Custom Error Pages: Specifying custom pages for error responses (e.g., 404 Not Found) using the ErrorDocument directive.
Caching: Controlling caching behavior for resources with Expires or Cache-Control headers.
Security: Enhancing security by blocking specific IP addresses or preventing directory listing.
To use .htaccess, simply create the file in the desired directory and add the necessary directives. Make sure that the Apache server is configured to allow .htaccess overrides with the AllowOverride directive in the main configuration file.
<IfModule mod_rewrite.c> : Rewrite rules will only be applied if the mod_rewrite module is loaded and enabled.
RewriteEngine On : Enable the rewrite engine. The RewriteEngine allows you to create complex URL manipulations, such as rewriting URLs for cleaner web addresses, redirecting users, or controlling access based on specific conditions.
The RewriteBase directive in an .htaccess file is used in conjunction with mod_rewrite to specify the base URL for rewriting rules.
RewriteCond %{REQUEST_FILENAME} !-f : If the requested path is not a directory, it rewrites the request to index.php, passing the original path as a query parameter.
– RewriteCond %{REQUEST_FILENAME} !-d : If the requested resource is not a directory, the request will be rewritten to index.php, passing the original request path as a query parameter.
RewriteRule ^(.*)$ index.php/$1 [L] : Here’s a breakdown of the rule:
^(.*)$ : This matches the entire requested URL path. The .* captures any characters (except for line breaks), and the parentheses create a capturing group.
index.php/$1 : This indicates that the request should be rewritten to index.php, followed by the content captured by the first group (i.e., whatever was matched by (.*)).
[L]: This flag tells Apache to stop processing any further rewrite rules if this rule matches. It effectively means “this is the last rule to be processed.”
</IfModule> :Closes the check if mod_rewrite is loaded.
I use this .htaccess because I am planning on creating a simple Mode-View-Controller framework.
This particular configuration requires the Apache2 mod_rewrite be installed and enabled.
Use the PHP function $_SERVER[‘REQUEST_URI’] to collect the URI as a string that can be processed by the PHP code.
Given a URL of https://www.example.com/user/add/ – by using $_SERVER[‘REQUEST_URI’] in the index.php file the $_SERVER[‘REQUEST_URI’] will return a string “/user/add/”.
In M-V-C this would translate into load and run the class user. Then run the method/function add. Basically the code would show a form to create a new user.
Conclusion
In this article we cover that the .htaccess file is a configuration file used by the Apache web server to manage settings on a per-directory basis. It allows you to override global settings without modifying the main server configuration file. I show the .htaccess file I use, with explanations, for my homegrown Model-View-Controller framework that grabs the URI using the PHP $_SERVER[‘REQUEST_URI’] function.
– Access to an Ubuntu LAMP web server running Apache2 with root/sudo access
– Run the following commands:
– sudo apt update
– sudo apt upgrade
– sudo apt autoremove
– sudo reboot
Introduction
I will use the IP of my server which is 192.168.1.81 and two local-non-routable domain names for this tutorial. The IP address of 192.168.1.81 is a private IP address, which means it is not accessible from the Internet. I’ll be using default.internal and lamp.internal domain names. .internal is not accessible from the Internet. .internal is a local-non-routable Top Level Domain Name (TLD).
By using a private IP address for my server and using .internal I can create a simple network that I run out of my home office.
You will need to use your server’s IP address in place of mine. You will also need to use the domains you have decided to use to replace the .internal domain names that I use.
All of this will make more sense once the tutorial has been completed.
I use Ubuntu 24.04LTS as my server operating system and this tutorial is oriented towards Ubuntu and Apache2.
I fully configure the Apache2 default virtual host so it can be copied and modified to create other virtual hosts. This makes life easier.
This tutorial is broken down into two separate parts and assumes you are following along with a fully functional Ubuntu 24.04LTS server that is configured to run Apache2 and the PHP programming language. We will not be accessing the MySQL data server, however it should be installed and be fully functional.
Part 1 : Build out the default Apache virtual Host
Step 1 Ensure That the Required Modules Are Enabled
You typically need mod_ssl for SSL support (if using HTTPS) and mod_rewrite for URL rewriting.
– sudo a2enmod rewrite
– sudo a2enmod ssl
Step 2: Configure the Default Apache Virtual Host file 000-default.conf
Step 10: Check Your Apache Configuration for Syntax Errors
– sudo apache2ctl configtest
If there are no errors, you should see Syntax OK.
Step 11: Enable the new Host
– sudo a2ensite lamp.internal
Step 12: Restart Apache to Apply the Changes
– sudo systemctl restart apache2
Step 13: Update Your Hosts File
For local testing, you can edit your Windows/macOS/Linux hosts file to point your domain names to your local server. Open the file:
– Windows:
– Open Notepad as administrator
– c:/windows/system32/drivers/etc/hosts
– Add 192.168.1.81 lamp.internal
– Linux/macOS:
– sudo vi /etc/hosts (edit Kubuntu using Putty)
– Add 192.168.1.81 lamp.internal
Step 14 : Test Using a Browser
– Test with the IP address of your server
– Test using the local-non-routable domain name
– Test using the lamp.internal/controller/action/arg1 domain name
– Test using the lamp.internal/info.php domain name
This proves everything is working correctly to include PHP and mod_rewrite
Conclusion
In this article and associated YouTube videos we learned how to completely configure the Apache2 default virtual host. We learned how to configure and test the Apache2 module mod_rewrite. We learned how to configure the mod_rewrite .htaccess file. We also learned how to copy the Apache2 virtual host configuration to make a new virtual host on the same server.
In this article we will cover how to fix the Apache Error AH00558 : Could not reliably determine the server’s fully qualified domain name.
This typically indicates that Apache is having trouble determining the server’s fully qualified domain name (FQDN).
In this tutorial, I use the IP address of 182.168.1.81 and [domain].internal. Replace my IP address of 192.168.1.81 with the IP you use on your server. As for the usage of [domain].internal, .internal is a top-level domain I (TLD). This domain is not routable and therefore cannot be accessed by the public Internet. When you see the reference to [domain].internal you can replace the [domain] part with the domain of your liking. You can also use another private/non-routable TLD.
I am running Apache2 on Ubuntu 24.04 LTS. This server is configured as a LAMP server (Linux, Apache, MySQL, and PHP). This configuration is common for most hosting servers.
I am a PHP developer and use VirtualBox to create Ubuntu LAMP servers for development and testing.
I spend most of my Linux time on the command line.
During one such session, I ran the command sudo systemctl restart apache2. As a result, the server responded : AH00558: apache2: Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1. Set the ‘ServerName’ directive globally to suppress this message.
To alleviate the Apache error AH00558 we will follow the 9 steps listed below.
1) Backup the original apache2.conf file. It is always a good idea to make a copy of any configuration file before modifying it.
The first step is to change directories to the Apache2 directory. Run this command cd /etc/apache2/. Then run this command sudo cp apache2.conf apache2.conf-original to make a copy of the original apache2.conf file.
2) Edit the Apache Configuration File following the 3 steps below:
– sudo vi /etc/apache2/apache2.conf
– set the ServerName directive by entering it into the Apache configuration file. The directive looks like this : ServerName default.internal
– Save and Close the file
3) Run the command sudo apache2ctl configtest to verify Apache is configured correctly and to verify the error message is gone.
4) Restart Apache by running: sudo systemctl restart apache2
5) Verify the change by running the command: sudo tail -f /var/log/apache2/error.log
At this point, you have corrected the error message and can stop here. If you are still experiencing issues jump down to section 9) Test the Apache configuration and follow the directions there.
I added the following steps to complete setting the ServerName directive in the default virtual host.
I also added the part on how to use the Windows/Linux/macOS hosts file so you can create a private network where your servers are on a private/non-routable IP address that utilizes a non-routable/private top-level domain (TLD). I felt this tutorial would not be complete without this information.
6) Configure the ServerName directive for the default virtual host by adding the ServerName directive to the virtual host configuration file. Follow these steps:
– Run this command: cd /etc/apache2/sites-available/
– Then run this command sudo vi 000-default.conf.
– Add the ServerName directive ServerName default.internal to the 000-default.conf file.
– Your 000-default.conf configuration file should look like this:
<VirtualHost *:80>
# The ServerName directive sets the request scheme,
# hostname and port
# that the server uses to identify itself.
# This is used when creating
# redirection URLs. In the context of virtual hosts,
# the ServerName
# specifies what hostname must appear in the request's
# Host: header to
# match this virtual host. For the default
# virtual host (this file)
# this value is not decisive as it is used as a
# last resort host
# regardless. However, you must set it for any
# further virtual host
# explicitly.
# ServerName www.example.com
ServerAdmin webmaster@localhost
ServerName default.internal
DocumentRoot /var/www/html
# Available loglevels: trace8, ..., trace1, debug,
# info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the
# loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/[host].error.log
CustomLog ${APACHE_LOG_DIR}/[host].access.log combined
# For most configuration files from
# conf-available/, which are
# enabled or disabled at a global level,
# it is possible to
# include a line for only one particular virtual host.
# For example the
# following line enables the CGI configuration
# for this host only
# after it has been globally disabled
# with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
</VirtualHost>
Don’t forget to replace [host] with your domain name.
There is some valuable information in this file that is worth reading.
7) Configure the Windows/Linux/macOS hosts file. In this case I will show the steps necessary to modify Windows 10.
– Right mouse click on Notepad.
– Run Notepad as administrator.
– Open the hosts file : c:/windows/system32/drivers/etc/ [set drop down to show all files]and select the hosts file.
– add 182.168.1.81 default.internal to the end of the file.
– save and close
For Linux and macOS, add the IP and domain name to the hosts file by running the command sudo vi /etc/hosts and add the line 182.168.1.81 default.internal then save and close.
8) Restart Apache by running the sudo systemctl restart apache2 command.
9) Test the Apache configuration
Run the command sudo apache2ctl configtest. If the Apache AH00558 error message persists check :
Verify /etc/apache2/apache2.conf is configured correctly.
Verify /etc/apache2/sites-available/000-default.conf is configured correctly.
Run sudo tail -f /var/log/apache2/error.log in search of any errors.
Run sudo apache2ctl configtest as many times as it is necessary to get the Apache configuration correct and to remove any error messages.
When all the errors have been addressed, launch a browser and enter the domain you are using into the browser’s URL. At this point, you should see the output from the default virtual host.
Conclusion
In this article we learned how to fix the AH00558: apache2: Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1. Set the ‘ServerName’ directive globally to suppress this message error message. We learned how to configure the /etc/apache2/apache2.conf configuration file, and the /etc/apache2/sites-available/000-default.conf configuration file. We learned how to configure the hosts files for Windows/Linux/macOS so we can use a non-routable domain name that uses the .internal top-level domain (TLD). We use this TLD in conjunction with a local network that consists of private/non-routable IP addresses.
mod_rewrite is an Apache module that provides a powerful and flexible way to rewrite URLs. Here are some common reasons to use it:
Improving SEO: Clean, descriptive URLs are better for search engine optimization (SEO) and user experience. For example, example.com/products/123 can be rewritten to example.com/products/special-widget, making it more readable and relevant.
Model-View-Controller: Model-View-Controller (m-v-c) is a design pattern used in software development. In the case of M-V-C the Uniform Resource Identifier (URI) for https://www.domain.tld/edit/login/1 is the string user/edit/1. User is the controller, edit is the action or method within the controller, and the number 1 is an argument or the user’s id.
Redirecting URLs: It allows for easy redirection of old URLs to new ones. This is particularly useful when you’ve changed the structure of your website or need to redirect traffic from outdated links.
Creating User-Friendly URLs: You can create user-friendly URLs by hiding query strings and parameters. For example, example.com/article?id=456 can be rewritten to example.com/article/456.
Implementing Custom URL Structures: If you have a dynamic website and want to implement a custom URL structure, mod_rewrite can handle the translation of friendly URLs to the underlying script.
Handling Requests Dynamically: It allows for the handling of requests dynamically based on various conditions, such as redirecting requests based on the user agent, geographical location, or other request headers.
Enforcing HTTPS: You can use mod_rewrite to enforce HTTPS by redirecting all HTTP traffic to HTTPS, enhancing security.
Access Control: You can use rewrite rules to control access to certain parts of your site based on IP addresses, user agents, or other criteria.
Cache-Control: You can use it to manage caching by rewriting URLs in a way that incorporates versioning or other mechanisms to control how content is cached.
Overall, mod_rewrite provides a versatile tool for managing URLs and can be an essential part of maintaining a well-organized, user-friendly, and SEO-optimized website.
Steps to Configure mod_rewrite
1) Run this command on the command line: sudo a2enmod rewrite – enables the Apache mod_rewrite module.
2) After enabling the module, you must restart Apache to apply the changes. On the command line run the command sudo systemctl restart apache2.
3) Creating and configuring the .htaccess file. Change the directory to the docroot of the virtual host. Enter cd /var/www/[doman]/public_html/ on the command line. Then enter the command sudo vi .htaccess. Make sure to replace [doman] with your domain name.
Cut and paste the following code into the file being edited by vi.
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
# Remove index.php from the URL
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]
</IfModule>
Then save the file.
The .htaccess Directives Explained
<IfModule mod_rewrite.c> : This directive starts a block of configuration that will only be applied if the mod_rewrite module is loaded.
RewriteEngine is a directive used in Apache HTTP Server’s mod_rewrite module. It controls whether URL rewriting rules are enabled or disabled for a particular directory or virtual host.
RewriteBase sets the base URL path for the rewrite rules that follow in the .htaccess file. This is particularly useful when your site is located in a subdirectory, and you need to ensure that your rewrite rules are interpreted correctly relative to that directory.
RewriteCond %{REQUEST_FILENAME} !-f specifies that the rewrite rule following this condition should only be applied if the requested filename does not correspond to an existing file on the server. This is often used in conjunction with RewriteRule to handle URL rewriting, such as redirecting requests to a front controller or a specific script when the requested file isn’t found.
RewriteCond %{REQUEST_FILENAME} !-d is used to apply the following RewriteRule only when the requested URL does not correspond to an existing directory on the server. This is commonly used in scenarios where you want to handle requests dynamically when the requested resource isn’t a real directory, such as routing to a specific script or controller when the directory structure doesn’t match the request.
RewriteRule ^(.*)$ index.php/$1 [L] in summary, this rule tells Apache to redirect any URL request to the root index.php, appending the original URL path to the index.php file for processing. For instance, a request for /something would be internally redirected to index.php, and the string something would be processed accordingly. This setup is commonly used in frameworks or applications where routing is handled by a single entry point, such as index.php, and the rest of the URL is used to determine the specific resource or action(s).
</IfModule> ends the block that was started with the command <IfModule mod_rewrite.c>. All the commands within this block will be applied if the Apache mod_rewrite module is enabled.
The design pattern Model-View-Controller (M-V-C) is a single point of entry model that utilizes the above .htaccess code to transfer the URI entered into the browser, to the root index file. In the case of a PHP M-V-C application, these directives entered into the .htaccess work in conjunction with the PHP function $_SERVER[‘REQUEST_URI’] to determine what controller and method to run along with any arguments. The URL would look something like this your-domain.TLD/controller/method/arg1/argn….
4) For mod_rewrite to work using the above .htaccess directives, you need to configure Apache to allow overrides in your site’s configuration. This is usually done in the <Directory> block of your Apache virtual host configuration files.
At the command line enter cd /etc/apache2/sites-available/.
Enter sudo vi [domain].conf on the command line. Don’t forget to replace [domain] with your domain name.
Insert the following code :
<Directory /var/www/[domain]/public_html/>
Options Indexes FollowSymLinks
AllowOverride All
Require all granted
</Directory>
After editing, save the file and exit the editor.
Replace [domain] with your domain name.
This block specifies that the .htaccess file in the directory listed. is allowed to override any server settings for this directory. This works in conjunction with the above .htaccess file directives.
When complete, your virtual host configuration file should look something like this:
5) Test the Apache configuration by running apachectl configtest.
When you run apachectl configtest, Apache will check your configuration files for any mistakes and report them back to you, allowing you to fix any errors before restarting or reloading the server.
6) Configure the index.php file. Enter the command line command cd /var/www/[domain]/public_html/.
Then enter the command vi index.php.
Replace what is in the index.php file with the following (or create the file if not there):
In PHP, <?php is the PHP opening tag that signals Apache to start processing PHP code.
echo ‘[domain] – ‘;
echo $_SERVER[‘REQUEST_URI’];
The echo command is used to output data to the browser or the console. In this case, it will echo the string ‘[domain] – ‘ and the output of the PHP command $_SERVER[‘REQUEST_URI’].
The PHP command $_SERVER[‘REQUEST_URI’] returns the URI (Uniform Resource Identifier) of the page being requested.
And the last line, ?> signals to Apache to stop processing PHP code.
Anything between <?php and ?> is treated as PHP code.
6) At this point we need to restart Apache so all these changes take effect. On the command line enter the command sudo systemctl restart apache2.
7) Testing
Ensure your rewrite rules are working correctly by testing them in your browser. Open a browser and enter http://[domain]/controller/method/arg1/arg2/arg3 in the URL of the browser and hit enter. You should see the output of the PHP program we created. The output should look like this: [domain] – /controller/method/arg1/arg2/arg3
8) Troubleshooting
If mod_rewrite doesn’t seem to be working:
Run apachectl configtest from the command line. If there is any configuration issues, address them and run apachectl configtest again. Repeat until all issues are corrected.
Another tool that can help you with the Apache mod_rewrite configuration is to run the following command on the command line : sudo tail -f /var/log/apache2/error.log
If there are any errors in the Apache log you can use Google search and/or you can use [https://chatgpt.com/] Artificial Intelligence (AI).
Some other things you can do is :
– Ensure there are no syntax errors in your .htaccess file or Apache configuration.
– Verify that the .htaccess file is in the correct directory : sudo vi /var/www/[domain]/public_html/.htaccess
– Ensure that the AllowOverride directive is set correctly in your Apache configuration : sudo vi /etc/apache2/sites-available/[domain].conf
– Verify the index.php file is configured properly : sudo vi /var/www/[domain]/public_html/index.php
If your Apache virtual host configuration is not working try the following command line commands in order :
– sudo a2enmod rewrite
– sudo systemctl restart apache2
– apachectl configtest
Conclusion
The Apache mod_rewrite module has many reasons for its use. In this article, we cover how to enable the mod_rewrite module, and how to restart Apache. We learned how to create the .htaccess file and we learned what code to put inside of the .htaccess file. We learned what the .htaccess directives mean and what they do. We configured the Apache virtual host configuration file to take advantage of many of the features of the mod_rewrite module. Mostly how it supports the M-V-C design pattern in PHP. Lastly, we learned how to test and troubleshoot the mod_rewrite configuration.
The Linux, Windows, and MAC hosts file is a system file used to map hostnames to IP addresses. When a program or user on a Linux, Windows, or MAC system tries to connect to a hostname, the operating system first looks in this file to see if there’s a corresponding IP address. If it finds one, it uses that IP address instead of querying a DNS server.
Couple that with a non-routable top-level domain (TLD) such as .internal the Linux, Windows, and MAC hosts file can be a useful strategy for managing internal network resources without the need for a Domain Name System (DNS) server on your local/private network.
The DNS system translates human-friendly domain names, like www.example.com, into IP addresses, which are used by computers to identify and communicate with each other over the Internet/intranet. Basically, it acts like a phone book for the Internet/intranet, converting names into numbers so that browsers can load websites.
The .internal TLD
The .internal TLD is not a standard, globally recognized TLD and is intended for internal use only. It’s useful for private networks where you don’t want your internal domain names to conflict with external domain names.
The hosts file on your local machine maps hostnames to IP addresses, which can be used to route traffic within your internal/private network.
Private Non-Routable IP Addresses
10.0.0.0 to 10.255.255.255 (10.0.0.0/8) Note that /8 is a subnet mask in CIDR notation.
172.16.0.0 to 172.31.255.255 (172.16.0.0/12)
192.168.0.0 to 192.168.255.255 (192.168.0.0/16)
How CIDR Notation Works
Network Portion: The prefix length determines the network portion of the IP address. For example, in 192.168.1.0/24, the /24 prefix means the first 24 bits are used to identify the network, and the remaining 8 bits (in a 32-bit IP address) are used for host addresses within this network.
A host is a device that has been assigned an IP address.
Host Portion: The remaining bits after the prefix length are used for individual host addresses within the network. In the /24 example, this means there are 2^8 (256) possible addresses, with 254 usable for hosts (excluding the network address and broadcast address).
Intranet
A network made up of private/non-routable IP addresses is an intranet and is only accessible by authorized users. Unlike the Internet, which is public and accessible to anyone with an Internet connection, an intranet is restricted to members of the organization and is typically used to share information, collaborate on projects, and streamline internal communications.
Intranets often include:
Internal Websites: These might feature company news, policy documents, and other resources.
Collaboration Tools: Such as shared calendars, project management software, and internal messaging systems.
Databases: For storing and retrieving company-specific information.
File Sharing: Systems to upload, download, and manage documents within the organization.
The main goal of an intranet is to facilitate efficient and secure communication and collaboration within an organization, enhancing productivity and ensuring that employees have easy access to the information and tools they need.
Edit the Hosts File
On different operating systems, the hosts file is located in different places:
Windows: C:\Windows\System32\drivers\etc\hosts
Linux/macOS: /etc/hosts
To add an internal domain to your hosts file:
Open the hosts file with a text editor. I use the vi editor on Linux and Notepad on Windows. I have no experience with the MAC.
Add entries in the following format:
<tab>192.168.1.10<tab>myservice.internal
<tab>192.168.1.11<tab>another.internal
Here, 192.168.1.10 and 192.168.1.11 are internal/private/non-routable IP addresses, and myservice.internal and another.internal are your internal domain names.
Save the file and exit the editor.
Testing Your Configuration
To verify the Linux server is running on the IP address you are attempting to use, open an SSH connection using the Linux terminal or on Windows use PuTTY. Then use the ping command to test the hostname like this: ping myservice.internal
If everything is configured correctly, you should see something like:
keith@Kubuntu22:~$ ping 192.168.1.81
PING 192.168.1.81 (192.168.1.81) 56(84) bytes of data.
64 bytes from 192.168.1.81: icmp_seq=1 ttl=64 time=6.42 ms
64 bytes from 192.168.1.81: icmp_seq=2 ttl=64 time=1.79 ms
64 bytes from 192.168.1.81: icmp_seq=3 ttl=64 time=1.85 ms
64 bytes from 192.168.1.81: icmp_seq=4 ttl=64 time=1.82 ms
64 bytes from 192.168.1.81: icmp_seq=5 ttl=64 time=1.49 ms
To test that your configuration is configured correctly, open a browser, enter your local domain in the URL, and hit enter. If all is good you will see the page that comes from that local domain’s virtual host website.
Internal TLD Usage
Naming Conventions: Using a non-standard TLD like .internal helps avoid conflicts with public DNS. Ensure that the naming conventions you use are consistent across your network.
Alternative TLDs: Some organizations use TLDs like .local or .lan for internal domains, although these can also have potential conflicts or limitations, especially with multicast DNS (mDNS) and some network configurations.
For years developers have used the TLD .dev. .dev is now a public TLD and if used on a private network may conflict with its public counterpart.
This is a small network solution. If your network is larger than 2 or 3 computers you may want to consider using a DNS server for your private network.
How I Use My Intranet
I’ve created a small intranet within my home lab. I am a PHP developer and have a handful of devices that I use to develop and test PHP code. This consists of a Windows 10 laptop that runs Oracle’s VirtualBox. VirtualBox is what is called a hypervisor which allows me to create Linux, Apache, MySQL, and PHP (LAMP) web servers (guests) for development and testing.
It should be noted that each of the VirtualBox guests has a unique IP address that allows me to use the .internal top-level domain (TLD) on my Windows 10 hosts file and my Kubuntu (linux) desktop hosts file.
Conclusion
In this article, we learned how to configure a local/private .internal top-level domain. We covered private Non-Routable IP addresses. We learned a bit about how CIDR notation works. We covered how to edit the Linux, Windows, and macOS hosts file to address the need for DNS. Lastly, we tested our configuration.
On Ubuntu 24.04, Apache2 uses virtual hosts to manage multiple websites on a single server. Each virtual host configuration defines how Apache should handle requests for different domains or subdomains. Understanding how to configure these virtual hosts is crucial for effectively managing multiple sites. Here’s a comprehensive guide to Apache2 virtual host configurations.
Virtual Host Basics
Virtual hosts allow you to run multiple websites on a single Apache server by defining separate configuration files for each site. Apache uses the NameVirtualHost directive (which is now implicit) to route requests based on the domain name or IP address.
My Development Environment
I am a PHP programmer. I believe every PHP Developer should know the fundamentals of Linux and specifically know how to build a virtualization system and should have the skills to build a LAMP stack (Linux, Apache, MySQL, PHP) and have the skills to build and maintain their own development and testing environment.
I am using an old Windows 10 laptop that has an i3 CPU with 2 cores and 4 threads and 16GB of RAM. I’ve installed VirtualBox on it. VirtualBox is a type 2 hypervisor, which means it is installed on top of an operating system.
I use VirtualBox to create virtual machines (guests) for PHP development and testing. These guests consist of Ubuntu 24.04LTS (Linux), Apache, MySQL, and PHP (LAMP stack).
On Ubuntu, virtual host configurations are usually placed in /etc/apache2/sites-available/, and enabled using symbolic links in /etc/apache2/sites-enabled/.
Configuration File Structure
Each virtual host configuration file typically includes:
ServerName: The domain name to which the virtual host responds to.
DocumentRoot: The directory where the website’s files are located.
ErrorLog: The file where error messages for the virtual host are logged.
CustomLog: The file where access logs for the virtual host are recorded.
Example Configuration
Here’s a basic example of a virtual host configuration file located at /etc/apache2/sites-available/example.com.conf:
<VirtualHost *:80>: This specifies that the virtual host should respond to requests on port 80 (HTTP). You can also use port 443 for HTTPS.
ServerAdmin webmaster@example.com: The email address of the server administrator.
ServerName example.com: The primary domain name for this virtual host.
ServerAlias www.example.com: Additional domain names or subdomains that should also be handled by this virtual host.
DocumentRoot /var/www/example.com/public_html: The directory containing the files for this website.
ErrorLog ${APACHE_LOG_DIR}/example.com_error.log: Path to the error log file specific to this virtual host.
CustomLog ${APACHE_LOG_DIR}/example.com_access.log combined: Path to the access log file and log format.
Enabling a Virtual Host
After creating or modifying a virtual host configuration file, you need to enable it with the following command:
sudo a2ensite example.com.conf
Then, reload Apache to apply the changes:
sudo systemctl reload apache2
Disabling a Virtual Host
If you need to disable a virtual host, use:
sudo a2dissite example.com.conf
And reload Apache:
sudo systemctl reload apache2
Best Practices
Keep Configuration Files Organized: Use clear and descriptive names for your virtual host configuration files.
Regularly Check Logs: Monitor error and access logs for troubleshooting.
By following these guidelines and understanding each directive, you can effectively manage multiple websites on your Apache server using virtual hosts.
Conclusion
In this article, we learned how to create and configure a virtual host on a LAMP Ubuntu 24.04LTS server. This consists of creating an Apache2 virtual host configuration file. We also learned what commands are required to complete this task.
How to Setup Apache2 Virtual Host in Ubuntu 24.04 LTS
