Apache’s `mod_rewrite` module lets you rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings. It also lets you rewrite URLs based on conditions. In this tutorial, you’ll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

Debian

### Introduction

In this tutorial, we will activate and learn how to manage URL rewrites using Apache 2's `mod_rewrite` module. This module allows us to rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings or redirecting URLs based on additional conditions.

This guide is split into two parts. The first sets up an example website and covers a simple rewrite example. The second part contains two more in-depth examples of commonly-used rewrite rules.

## Prerequisites

To follow this tutorial, you will need:

* One Debian 8 server set up with [this initial server setup tutorial](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-8).
* Apache 2 installed on your server by following Step 1 of [How To Install Linux, Apache, MySQL, PHP (LAMP) Stack on Debian 8](https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on-debian-8).

## Step 1 — Enabling mod_rewrite

First, we need to activate `mod_rewrite`. It's available but not enabled with a clean Apache 2 installation.

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up .htaccess

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can be also put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` because Apache processes it faster that way.

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect and it does not require root privileges to edit those rules, simplifying maintenance and and making changes possible with unprivileged account. Some popular open-source software, like Wordpress and Joomla, often relies on an `.htaccess` file for the software to modify and create additional rules on demand.

<$>

We will need to set up and secure a few more settings before we can begin.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor.

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks MultiViews<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

Now, create the `.htaccess` file in the web root.

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file which you can use to govern your web application's routing rules. In the next step, we will create sample website files that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite, which converts pretty URLs into actual paths to code. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`.

Begin by creating a file named `about.html` in the web root.

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. If you would users to access the page using simply `about` instead, rewrite rules will allow this very functionality.

All `RewriteRules` abide by the following format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e. the path of the file Apache servers.
* `flags` are optional parameters that can modify how the rule works.

Open up the `.htaccess` file.

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the `RewriteRule` marked in red and save the file.

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL, after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

Now, you should be now able access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because original proper filename will always work.

The following will not:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about` using the `$` character.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a simple rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value  `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasent links as the above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address, but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substition]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address  and Apache is told to serve `results.php?item=shirt&season=summer` instead. 

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look as follows:

```
[label Simple substition]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular rexpression group in parenthesis matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing mutliple items and seasons to be correctly rewritten using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules will be processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is  the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the `RewriteRule` immediately following will be considered. If it won't, the rule will be discarded. Multiple `RewriteCond` may be used one after another and, with default behaviour, all must evaluate to true for the following rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition which verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple and redirects every request to the `/` website root.

# Conclusion

`mod_rewrite` is a useful Apache module that can be used effectively to ensure human-readable URLs. In this tutorial, you learned how to use the `RewriteRule` directive to redirect URLs, including ones with query strings. You also learned how to conditionally redirect URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).

The mod_rewrite module allows us to rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings or redirecting URLs based on additional conditions. This guide is split into two parts. The first sets up an example website and covers a simple rewrite example. The second part contains two more in-depth examples of commonly-used rewrite rules.

How To Rewrite URLs with mod_rewrite for Apache on Debian 8

How to Rewrite URLs with mod_rewrite for Apache

Ubuntu

16.04

### Introduction

In this tutorial, we will activate and learn how to manage URL rewrites using Apache 2's `mod_rewrite` module. This module allows us to rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings or redirecting URLs based on additional conditions.

This guide is split into two parts. The first sets up an example website and covers a simple rewrite example. The second part contains two more in-depth examples of commonly-used rewrite rules.

## Prerequisites

To follow this tutorial, you will need:

* One Ubuntu 16.04 server set up with [this initial server setup tutorial](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04), including a sudo non-root user and firewall.
* Apache 2 installed on your server by following Step 1 of [How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on-ubuntu-16-04).

## Step 1 — Enabling mod_rewrite

First, we need to activate `mod_rewrite`. It's available but not enabled with a clean Apache 2 installation.

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up .htaccess

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can be also put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` because Apache processes it faster that way.

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect and it does not require root privileges to edit those rules, simplifying maintenance and and making changes possible with unprivileged account. Some popular open-source software, like Wordpress and Joomla, often relies on an `.htaccess` file for the software to modify and create additional rules on demand.

<$>

We will need to set up and secure a few more settings before we can begin.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor.

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks MultiViews<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

Now, create the `.htaccess` file in the web root.

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file which you can use to govern your web application's routing rules. In the next step, we will create sample website files that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite, which converts pretty URLs into actual paths to code. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`.

Begin by creating a file named `about.html` in the web root.

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. If you would users to access the page using simply `about` instead, rewrite rules will allow this very functionality.

All `RewriteRules` abide by the following format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e. the path of the file Apache servers.
* `flags` are optional parameters that can modify how the rule works.

Open up the `.htaccess` file.

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the `RewriteRule` marked in red and save the file.

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL, after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

Now, you should be now able access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because original proper filename will always work.

The following will not:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about` using the `$` character.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a simple rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value  `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasent links as the above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address, but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substition]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address  and Apache is told to serve `results.php?item=shirt&season=summer` instead. 

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look as follows:

```
[label Simple substition]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular rexpression group in parenthesis matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing mutliple items and seasons to be correctly rewritten using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules will be processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is  the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the `RewriteRule` immediately following will be considered. If it won't, the rule will be discarded. Multiple `RewriteCond` may be used one after another and, with default behaviour, all must evaluate to true for the following rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition which verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple and redirects every request to the `/` website root.

# Conclusion

`mod_rewrite` is a useful Apache module that can be used effectively to ensure human-readable URLs. In this tutorial, you learned how to use the `RewriteRule` directive to redirect URLs, including ones with query strings. You also learned how to conditionally redirect URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).

How To Rewrite URLs with mod_rewrite for Apache on Ubuntu 16.04

18.04

### Introduction

Apache's `mod_rewrite` module lets you rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings. It also lets you rewrite URLs based on conditions.

An `.htaccess` file lets you create and apply rewrite rules without accessing server configuration files. By placing the `.htaccess` file in the root of your web site, you can manage rewrites on a per-site or per-directory basis.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

## Prerequisites

To follow this tutorial, you will need:

* [One Ubuntu 18.04 server](https://www.digitalocean.com/products/linux-distribution/ubuntu/) set up by following the [Ubuntu 18.04 initial server setup guide](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04). This includes a sudo non-root user and a firewall.

* Apache installed by following Step 1 of  [How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-ubuntu-18-04).

  

## Step 1 — Enabling mod_rewrite

In order for Apache to understand rewrite rules, we first need to activate `mod_rewrite`. It's already installed, but it's disabled on a default Apache installation. Use the `a2enmod` command to enable the module:

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up .htaccess

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can be also put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` because Apache processes it faster that way.

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect and it does not require root privileges to edit those rules, simplifying maintenance and and making changes possible with unprivileged account. Some popular open-source software, like Wordpress and Joomla, often relies on an `.htaccess` file for the software to modify and create additional rules on demand.
<$>

Before you start using `.htaccess` files, you'll need to set up and secure a few more settings.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor.

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks MultiViews<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

Now, create an `.htaccess` file in the web root.

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file which you can use to govern your web application's routing rules. In the next step, we will create sample website files that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite which converts pretty URLs into actual paths to pages. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`, but display a page called `about.html`.

Begin by creating a file named `about.html` in the web root.

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```html
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. To access the page using `/about` instead, we'll create a rewrite rule.

All `RewriteRules` follow this format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e. the path of the file Apache servers.
* `flags` are optional parameters that can modify how the rule works.

Let's create our URL rewrite rule. Open up the `.htaccess` file.

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the `RewriteRule` marked in red and save the file.

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL, after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

You can now access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because the  original proper filename will always work.

However, the following will not work:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about`, since  the `$` character appears after `about`.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a basic rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value  `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasent links as the above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address, but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substition]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address  and Apache is told to serve `results.php?item=shirt&season=summer` instead. 

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look as follows:

```
[label Simple substition]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular rexpression group in parenthesis matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing mutliple items and seasons to be correctly rewritten using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules will be processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is  the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the `RewriteRule` immediately following will be considered. If it won't, the rule will be discarded. Multiple `RewriteCond` may be used one after another and, with default behaviour, all must evaluate to true for the following rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition which verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple and redirects every request to the `/` website root.

# Conclusion

`mod_rewrite` lets you create human-readable URLs. In this tutorial, you learned how to use the `RewriteRule` directive to redirect URLs, including ones with query strings. You also learned how to conditionally redirect URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).

Apache's mod_rewrite module lets you redirect URLs based on additional conditions, or rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query string. In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.


How to Rewrite URLs with mod_rewrite for Apache on Ubuntu 18.04

### Introduction

Apache's `mod_rewrite` module lets you rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings. It also lets you rewrite URLs based on conditions.

An `.htaccess` file lets you create and apply rewrite rules without accessing server configuration files. By placing the `.htaccess` file in the root of your web site, you can manage rewrites on a per-site or per-directory basis.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

## Prerequisites

To follow this tutorial, you will need:

* One Debian 9 server set up by following the [Debian 9 initial server setup guide](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9), including a sudo non-root user and a firewall.

* Apache installed by following Steps 1 and 2 of  [How To Install the Apache Web Server on Debian 9](https://www.digitalocean.com/community/tutorials/how-to-install-the-apache-web-server-on-debian-9).


## Step 1 — Enabling mod_rewrite

In order for Apache to understand rewrite rules, we first need to activate `mod_rewrite`. It's already installed, but it's disabled on a default Apache installation. Use the `a2enmod` command to enable the module:

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache:

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up .htaccess

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can also be put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` thanks to faster processing times. 

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect or root privileges to edit rules, simplifying maintenance and the process of making changes with an unprivileged account. Popular open-source software like Wordpress and Joomla relies on `.htaccess` files to make modifications and additional rules on demand.
<$>

Before you start using `.htaccess` files, you'll need to set up and secure a few more settings.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or [your favorite text editor](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9#step-six-—-completing-optional-configuration):

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. 

Check your configuration:

```command
sudo apache2ctl configtest
```
If there are no errors, restart Apache to put your changes into effect:

```command
sudo systemctl restart apache2
```

Now, create an `.htaccess` file in the web root:

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file that you can use to govern your web application's routing rules. In the next step, we will create sample website files that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite which converts pretty URLs into actual paths to pages. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`, and display a page called `about.html`.

Begin by creating a file named `about.html` in the web root:

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```html
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. To access the page using `/about` instead, we'll create a rewrite rule.

All `RewriteRules` follow this format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e. the path of the file Apache serves.
* `flags` are optional parameters that can modify how the rule works.

Let's create our URL rewrite rule. Open up the `.htaccess` file:

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the following `RewriteRule` and save the file:

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL, after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

You can now access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will also point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because the original filename will always work.

However, the following will not work:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about`, since the `$` character appears after `about`.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a basic rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasant links as the example above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address, but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substition]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address and Apache is told to serve `results.php?item=shirt&season=summer` instead. 

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look like this:

```
[label Simple substition]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular expression group in parentheses matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of the hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing multiple items and seasons to be correctly rewritten using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules will be processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the next `RewriteRule` will be considered. If it doesn't, the rule will be discarded. Multiple `RewriteConds` may be used one after another, though all must evaluate to true for the next rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition which verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple and redirects every request to the `/` website root.

# Conclusion

`mod_rewrite` lets you create human-readable URLs. In this tutorial, you learned how to use the `RewriteRule` directive to redirect URLs, including ones with query strings. You also learned how to conditionally redirect URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).

Apache's `mod_rewrite` module lets you rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings. It also lets you rewrite URLs based on conditions.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

How To Rewrite URLs with mod_rewrite for Apache on Debian 9

### Introduction

Apache's `mod_rewrite` module lets you rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query strings. It also lets you rewrite URLs based on conditions.

An `.htaccess` file lets you create and apply rewrite rules without accessing server configuration files. By placing the `.htaccess` file in the root of your web site, you can manage rewrites on a per-site or per-directory basis.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

## Prerequisites

To follow this tutorial, you will need:

* One Debian 10 server set up by following the [Debian 10 initial server setup guide](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-10), including a sudo non-root user and a firewall.

* Apache installed by following Steps 1 and 2 of [How To Install the Apache Web Server on Debian 10](https://www.digitalocean.com/community/tutorials/how-to-install-the-apache-web-server-on-debian-10).


## Step 1 — Enabling mod_rewrite

In order for Apache to understand rewrite rules, we first need to activate `mod_rewrite`. It's already installed, but it's disabled on a default Apache installation. Use the `a2enmod` command to enable the module:

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache:

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up .htaccess

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can also be put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` thanks to faster processing times. 

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect or root privileges to edit rules, simplifying maintenance and the process of making changes with an unprivileged account. Popular open-source software like Wordpress and Joomla rely on `.htaccess` files to make modifications and additional rules on demand.
<$>

Before you start using `.htaccess` files, you'll need to set up and secure a few more settings.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor:

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented:

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. If you used `nano`, do so by pressing `CTRL+X`, `Y`, then `ENTER`.

Then, check your configuration:

```command
sudo apache2ctl configtest
```
If there are no errors, restart Apache to put your changes into effect:

```command
sudo systemctl restart apache2
```

Now, create an `.htaccess` file in the web root:

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file that you can use to govern your web application's routing rules. In the next step, we will create a sample website file that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite which converts pretty URLs into actual paths to pages. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`, and display a page called `about.html`.

Begin by creating a file named `about.html` in the web root:

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```html
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. To access the page using `/about` instead, we'll create a rewrite rule.

All `RewriteRules` follow this format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e. the path of the file Apache serves.
* `flags` are optional parameters that can modify how the rule works.

Let's create our URL rewrite rule. Open up the `.htaccess` file:

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the following `RewriteRule` and save the file:

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL, after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

You can now access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will also point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because the original filename will always work.

However, the following will not work:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about`, since the `$` character appears after `about`.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a basic rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasant links as the example above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address, but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substition]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address and Apache is told to serve `results.php?item=shirt&season=summer` instead. 

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look like this:

```
[label Simple substition]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular expression group in parentheses matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of the hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing multiple items and seasons to be correctly rewritten using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules will be processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the next `RewriteRule` will be considered. If it doesn't, the rule will be discarded. Multiple `RewriteConds` may be used one after another, though all must evaluate to true for the next rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition which verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if the specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if the specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple and redirects every request to the `/` website root.

# Conclusion

`mod_rewrite` lets you create human-readable URLs. In this tutorial, you learned how to use the `RewriteRule` directive to redirect URLs, including ones with query strings. You also learned how to conditionally redirect URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).



How To Rewrite URLs with mod_rewrite for Apache on Debian 10

20.04

*The author selected the [Diversity in Tech Fund](https://www.brightfunds.org/funds/diversity-in-tech) to receive a donation as part of the [Write for DOnations](https://do.co/w4do-cta) program.*

### Introduction

Apache's `mod_rewrite` module lets you rewrite URLs more cleanly, translating human-readable paths into code-friendly query strings. It also enables you to rewrite URLs based on conditions.

An `.htaccess` file lets you create and apply rewrite rules without accessing server configuration files. By placing the `.htaccess` file in the root of your web site, you can manage rewrites on a per-site or per-directory basis.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

## Prerequisites

To follow this tutorial, you will need:

* [One Ubuntu 20.04 server](https://www.digitalocean.com/products/linux-distribution/ubuntu/) set up by following the [Ubuntu 20.04 initial server setup guide](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-20-04), including a sudo non-root user and a firewall.

* Apache installed by following Step 1 of [How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 20.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on-ubuntu-20-04).

## Step 1 — Enabling mod_rewrite

In order for Apache to understand rewrite rules, we first need to activate `mod_rewrite`. It's already installed, but it's disabled on a default Apache installation. Use the `a2enmod` command to enable the module:

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step, we will set up an `.htaccess` file that we'll use to define rewrite rules for redirects.

## Step 2 — Setting Up `.htaccess`

An `.htaccess` file allows us to modify our rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can be also put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` because Apache processes it faster that way.

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect and it does not require root privileges to edit those rules, simplifying maintenance and making changes possible with an unprivileged account. Some popular open-source software, like WordPress and Joomla, often relies on an `.htaccess` file for the software to modify and create additional rules on demand.
<$>

Before you start using `.htaccess` files, you'll need to set up and secure a few more settings.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor.

```command
sudo nano /etc/apache2/sites-available/000-default.conf
```

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

Now, create an `.htaccess` file in the webroot.

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

We now have an operational `.htaccess` file that we can use to govern our web application's routing rules. In the next step, we will create sample website files that we'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, we will set up a basic URL rewrite that converts pretty URLs into actual paths to pages. Specifically, we will allow users to access `http://<^>your_server_ip<^>/about`, but display a page called `about.html`.

Begin by creating a file named `about.html` in the webroot.

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```html
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. To access the page using `/about` instead, we'll create a rewrite rule.

All `RewriteRules` follow this format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e., the path of the file Apache servers.
* `flags` are optional parameters that can modify how the rule works.

Let's create our URL rewrite rule. Open up the `.htaccess` file.

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the highlighted `RewriteRule` and save the file.

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. Our example uses a few characters with special meaning:

* `^` indicates the start of the URL after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

You can now access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because the original proper filename will always work.

However, the following will not work:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about`, since the `$` character appears after `about`.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a basic rule that you can modify and extend to your needs. In the following sections, we will show two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value  `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasant links as the above into *friendly URLs* that are easier to type and interpret visually. In this example, we would like to simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substitution]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address and Apache is told to serve `results.php?item=shirt&season=summer` instead.

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, we can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look as follows:

```
[label Simple substitution]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular expression group in parenthesis matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of hardcoded `shirt` and `summer` values we used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing multiple items and seasons to be rewritten correctly using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to our rewrite rules to control when the rules are processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the `RewriteRule` immediately following will be considered. If it won't, the rule will be discarded. Multiple `RewriteCond` may be used one after another and, with default behavior, all must evaluate to true for the following rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . / [R=301]
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition that verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple. The dot `.` in the pattern matches anything and the substitution directs every request to the `/` website root. 

Additionally, `[R=301]` flag tells Apache to return a *301 Moved Permanently* redirect HTTP response code to the browser, resulting in a browser knowing the redirect happened and explicitly fetching the website root instead of the requested URL, with the change being reflected on the browser address bar. 

Without this flag, Apache would return the website root contents, but the browser would still think the requested page URL exists and would show the originally requested address on the address bar.

# Conclusion

`mod_rewrite` lets you create human-readable URLs. In this tutorial, you used the `RewriteRule` directive to redirect URLs, including ones with query strings. You also wrote conditionally redirecting URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).


Apache's mod_rewrite module lets you redirect URLs based on additional conditions, or rewrite URLs in a cleaner fashion, translating human-readable paths into code-friendly query string. In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

How to Rewrite URLs with mod_rewrite for Apache on Ubuntu 20.04

12.04

<h3>About Mod_Rewrite</h3>

<p>Think about the last time you visited some shopping website, looking for that one specific thing you needed to buy.  When you finally reached the page, the URL most likely looked something like this:</p>

<pre>gizmo.com/latest_and_greatest/specific_gadgets/exactly_what_youre_looking_for</pre>

<p>This is not because this website took the time to set up every single directory you would need to make your purchase, but because of a handy module called Mod_Rewrite. Mod_Rewrite allows you to make custom and simplified URLs as needed. In reality, the actual URL may have looked closer to this:</p>

<pre>http://www.gizmo.com/gp/itemB004RYVI0Q/ref=as_li_ss_tl?</pre>

<p>This tutorial will go over Activating Mod_Rewrite, Creating and Using the required .htaccess page, and setting up the URL rewrites.</p> 


<h3>Contents</h3>

<ol><li><a href="#Section 1">How to Activate Mod_Rewrite</a></li>
<li><a href="#Section 2">How to Create and Allow the Use of the .htaccess file</a></li>
<li><a href="#Section 3">How to Use Rewrite Rules</a></li>
<li><a href="https://www.digitalocean.com/community/articles/how-to-set-up-mod_rewrite-page-2#Section 4">How to Use the Rewrite Cond Directive</a></li>
<li><a href="https://www.digitalocean.com/community/articles/how-to-set-up-mod_rewrite-page-2#Section 5">Resources</a></li></ol>

<h3>Setup</h3>

<p>The steps in this tutorial require the user to have root privileges. You can see how to set that up on Ubuntu <a href="https://www.DigitalOcean.com/community/articles/initial-server-setup-with-ubuntu-12-04">here</a>, in steps 3 and 4.</p>

<p>Additionally, you need to have apache installed on your server. If you do not have it, you can download it for Ubuntu with this command:</p>

<pre>sudo apt-get install apache2</pre>

<h3 id= "Section 1">Section 1—How to Activate Mod_Rewrites</h3>

<p>Before we begin generating the actual URL rewrites, we need to  activate the apache mod_rewrite module that controls them. This is simple:</p>

<pre>sudo a2enmod rewrite</pre>

<p>The command activates the module or—if it is already activated, displays the words, "Module rewrite already enabled"</p>

<h3><a name= "Section 2">Section 2—About the .htaccess File:</a></h3>

<p>Once the module has been activated, you can set up your URL rewrites by creating an .htaccess file in your website directory.</p> 

<p>An .htaccess file is a way to configure the details of your website without needed to alter the server config files. The period that starts the file name will keep the file hidden within the folder.</p> 

<p>Additionally the placement of the .htaccess file is important. The configurations in that file will affect everything in its directory and the directories under it.</p> 

<p>You can create the .htaccess file in a text editor (make sure to name it only .htaccess without any other extension or name) and then upload it to your site through an ftp client.</p>  

<p>Alternatively you can use this command, replacing the example.com with the name of your site, to create your .htaccess file in terminal.</p>

<pre>sudo nano /var/www/example.com/.htaccess</pre>


<h3>How to permit changes in the .htaccess file:</a></h3>
<p>To allow the .htaccess file to override standard website configs, start by opening  up the configuration file. NB: You will need sudo privileges for this step.</p>  

<pre>sudo nano /etc/apache2/sites-available/default</pre>

<p>Once inside that file, find the following section, and change the line that says AllowOverride from None to All. The section should now look like this:</p>

<pre> &lt;Directory /var/www/>
                Options Indexes FollowSymLinks MultiViews
                AllowOverride All
                Order allow,deny
                allow from all
 &lt;/Directory></pre>

<p>After you save and exit that file, restart apache. .htacess files will now be available for all of your sites.</p> 

<pre>sudo service apache2 restart</pre>

<p>Now you are all set up to rewrite your site’s URLs.</p>

<h3><a name= "Section 3">Section 3—How to Rewrite URLS</a></h3>

<p>The entire URL rewriting operation takes place within the .htaccess file.</p>

<p>Overall, all of the URL rewrite commands follow the same pattern:</p>

<pre> RewriteRule Pattern Substitution [OptionalFlags]</pre>

<p>Here is a short explanation of each part:</p>

<ul><li>RewriteRule: This is the section in which you can write in the name of the the mod_rewrite directive that you want to use.</li> 

<li>Pattern: This section is dedicated to interpreting the requested URL, using regular expressions. This tutorial does not include a discussion of regular expressions, but you can find a useful tutorial on the subject <a href="http://httpd.apache.org/docs/current/rewrite/intro.html">here</a>.</li>

<li>Substitution: This is the actual URL of the page with the information we want to display. It may be hard to remember or confusing because of php paremeters or long strings of numbers. eg. www.cityzoo.com/animals.php?mammals=seals </li>

<li>Optional Flags: A flag is a tag at the end of the Rewrite Rule directive that may change the behavior of of the expression. Some common flags include [F], making the URL forbidden, [NC], forcing the rule to disregard capitalization, [R=301] or [R=302], controlling the redirect code you want to use, [L] indicating that this is the last rule in a series.</ul>

<h3>Three URL Rewrite Examples:</h3>

<p><b>Example 1: Go to Page A, find page B:</b></p>

<p>This is the most basic example for a URL rewrite: a visitor to the site types one URL into the browser but  is redirected to another. 
Here is how to set it up.</p>

<p>Lets go ahead and make two separate pages on for a site—say, one for Apples (apples.html) and one for Oranges (oranges.html):</p>

<p>Copy the code into the Apple page:</p>

<pre>&lt;html>
  &lt;head>
    &lt;title>Apples&lt;/title>
  &lt;/head>
  &lt;body>
    &lt;h1>This page is about Apples&lt;/h1>
  &lt;/body>
&lt;/html></pre>

<p>After that, can make the orange page, substituting all the fruit names to refer to the appropriate one.</p>

<p>Now open up the .htaccess file.</p> 
<pre>sudo nano /var/www/example.com/.htaccess</pre>

<p>Add the following URL rewrite commands to the file:</p>

<pre>RewriteEngine on
RewriteRule ^oranges.html$ apples.html</pre>

<p>Save and exit.</p> 

<p>Once everything is in place, visit the site ending in "/oranges.html"— all of the information displayed will come from the "/apple.html" site.</p>

<p><b>Now for an explanation:</b></p>
<ul><li>^oranges.html: this refers to how the page starts. The caret (^)  signifies the beginning of a string. In other words-- if the  page whose URL we wanted to rewrite began with anything but oranges (eg.navel_oranges.html), it would not be recognized by the rewrite rule, and it would not redirect to apples.html. </li>

<li>$: the dollars sign refers to the URL's end. If there is anything else after the last characters in the string, the web page would be equally unrecognizable by the rewrite rule.</li> 

<li>apples.html: this is where the browser is actually directing traffic.</li></ul>

<p><b>Example 2: The website has a parameter in its URL. How to make it look like a subdirectory.</b></p>

<p>The first example referred to a site that simply needed to be substituted with another one.  The instance below, however, addresses a common scenario that can be seen when there is a parameter in the url.</p>

<p>Check out this URL:</p>

<pre>http://example.com/results.php?products=apple</pre>

<p>It would be much clearer displayed as:</p>

<pre> http://example.com/products/apple</pre>

<p>The lines within the .htaccess file would look like this:</p>

<pre>RewriteEngine on
RewriteRule ^products/([A-Za-z0-9-]+)/?$ results.php?products=$1 [NC]</pre>

<p><b>Now for an explanation:</b></p>  

<ul><li>^products: In order to be caught and rerouted, the URL must start with products (keep in mind that this only refers to the text after the domain name). Should it begin with anything else, the rule will not apply and the URL will stay the same. </li>

<li>([A-Za-z0-9-]+): The content within the parentheses refers to any information that could be typed into the URL. In other words, the URL will be rewritten to reflect whatever a visitor to the site inputs after /products/. </li>

<li> +: The plus sign indicates what is in the brackets can be one or more characters (as opposed to, say, a single character that is either a letter or a number). </li>

<li>/?$: the dollar sign points out the end of the string. The question mark allows the last character in the string to be a forward slash (although it does not require it).</li>

<li>results.php?products=$1: the $1 indicates where the string from the pattern should go. In other words, it will put in the information captured from whatever people wrote in the "([A-Za-z0-9-]+):" part. After the process completes, the browser will display the information from the second URL</li>

<li> [NC]: this is a flag at the end of the phrase, indicating that the rule should ignore the cases of all of the characters in the string. </li>
</ul>



<p><b>Example 3: The site has an unwieldy URL. How to clean it up</b></p>

<p>This sort of situation can arise when URLs are long and complex.</p>

<p>Take the URL below as an example:</p>

<pre>http://example.com/results.php?products=produce&type=fruit&species=apple</pre></pre>

<p>As effective as the URL is in delivering the correct content, it is not very memorable for the consumer. URL rewrites would allow you to convert the URL to something simpler and clearer:</p> 

<pre>http://example.com/produce/fruit/apple</pre>

<p>In order to accomplish this, we would need the following lines in our .htaccess file (you can add as many section as needed in the .htaccess file):</p>

<pre>RewriteEngine on
RewriteRule ^(meat|produce|dairy)/([^/.]+)/([^/.]+)$ results.php?products=$1&type=$2&species=$3</pre>

<p><b>Now for an explanation:</b></p>  

<ul><li>First the ^(caret) starts the expression.</li> 

<li>(meat|produce|dairy): If we want to limit the options that can be typed in, we can specify the only values we will accept: in this case the variety of groceries. If anything besides one of those three 3 keywords is typed in, the URL rewrite will not take place. </li>  

<li>The ([^/.]+) indicates that anything can be written between the forward slash besides the characters following the caret, in this case, the forward slash or period. </li> 

<li>results.php?products=$1&type=$2&species=$3: Each value in the parentheses will be extracted and then applied to the longer URL in the substitution part of the expression. $1 indicates the first parantheses, $2, the second, $3, the third. </li></ul>

<P ALIGN=RIGHT><a href="https://www.digitalocean.com/community/articles/90">Continued on Page 2</a></P ALIGN=RIGHT>

<div class="author">By Etel Sverdlov</div>

This tutorial goes over Mod_Rewrite, an apache module that allows you to manipulate URLS to provide shorter or more relevant ones. This tutorial will go over Activating Mod_Rewrite, Creating and Using the required .htaccess page, and setting up the URL rewrites.

How To Set Up Mod_Rewrite

22.04

*The author selected the [Diversity in Tech Fund](https://www.brightfunds.org/funds/diversity-in-tech) to receive a donation as part of the [Write for DOnations](https://do.co/w4do-cta) program.*

### Introduction

Apache's `mod_rewrite` module lets you rewrite URLs more cleanly, translating human-readable paths into code-friendly query strings. It also enables you to rewrite URLs based on conditions.

An `.htaccess` file lets you create and apply rewrite rules without accessing server configuration files. By placing the `.htaccess` file in the root of your web site, you can manage rewrites on a per-site or per-directory basis.

In this tutorial, you'll enable `mod_rewrite` and use `.htaccess` files to create a basic URL redirection, and then explore a couple of advanced use cases.

## Prerequisites

To follow this tutorial, you will need:

* [One Ubuntu 22.04 server](https://www.digitalocean.com/products/linux-distribution/ubuntu/) set up by following the [Ubuntu 22.04 initial server setup guide](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-22-04), including a sudo non-root user and a firewall.

* Apache installed by following Step 1 of [How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on-ubuntu-22-04).

## Step 1 — Enabling mod_rewrite

In order for Apache to understand rewrite rules, you first need to activate `mod_rewrite`. It's already installed, but it's disabled on a default Apache installation. Use the `a2enmod` command to enable the module:

```command
sudo a2enmod rewrite
```

This will activate the module or alert you that the module is already enabled. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

`mod_rewrite` is now fully enabled. In the next step, you will set up an `.htaccess` file that you'll use to define rewrite rules for redirects.

## Step 2 — Setting Up `.htaccess`

An `.htaccess` file allows us to modify your rewrite rules without accessing server configuration files. For this reason, `.htaccess` is critical to your web application's security. The period that precedes the filename ensures that the file is hidden.

<$>[note]
**Note:** Any rules that you can put in an `.htaccess` file can be also put directly into server configuration files. In fact, the [official Apache documentation](http://httpd.apache.org/docs/2.4/howto/htaccess.html) recommends using server configuration files instead of `.htaccess` because Apache processes it faster that way.

However, in this simple example, the performance increase will be negligible. Additionally, setting rules in `.htaccess` is convenient, especially with multiple websites on the same server. It does not require a server restart for changes to take effect and it does not require root privileges to edit those rules, simplifying maintenance and making changes possible with an unprivileged account. Some popular open-source software, like WordPress and Joomla, often relies on an `.htaccess` file for the software to modify and create additional rules on demand.
<$>

Before you start using `.htaccess` files, you'll need to set up and secure a few more settings.

By default, Apache prohibits using an `.htaccess` file to apply rewrite rules, so first you need to allow changes to the file. Open the default Apache configuration file using `nano` or your favorite text editor.

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

Inside that file, you will find a `<VirtualHost *:80>` block starting on the first line. Inside of that block, add the following new block so your configuration file looks like the following. Make sure that all blocks are properly indented.

```
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^><Directory /var/www/html><^>
        <^>Options Indexes FollowSymLinks<^>
        <^>AllowOverride All<^>
        <^>Require all granted<^>
    <^></Directory><^>
    
    . . .
</VirtualHost>
```

Save and close the file. To put these changes into effect, restart Apache.

```command
sudo systemctl restart apache2
```

Now, create an `.htaccess` file in the webroot.

```command
sudo nano /var/www/html/.htaccess
```

Add this line at the top of the new file to activate the rewrite engine.

```
[label /var/www/html/.htaccess]
RewriteEngine on
```

Save the file and exit.

You now have an operational `.htaccess` file that you can use to govern your web application's routing rules. In the next step, you will create sample website files that you'll use to demonstrate rewrite rules.

## Step 3 — Configuring URL Rewrites

Here, you will set up a basic URL rewrite that converts pretty URLs into actual paths to pages. Specifically, you will allow users to access `http://<^>your_server_ip<^>/about`, but display a page called `about.html`.

Begin by creating a file named `about.html` in the webroot.

```command
sudo nano /var/www/html/about.html
```

Copy the following HTML code into the file, then save and close it.

```html
[label /var/www/html/about.html]
<html>
    <head>
        <title>About Us</title>
    </head>
    <body>
        <h1>About Us</h1>
    </body>
</html>
```

You can access this page at `http://<^>your_server_ip<^>/about.html`, but notice that if you try to access `http://<^>your_server_ip<^>/about`, you will see a **404 Not Found** error. To access the page using `/about` instead, you'll create a rewrite rule.

All `RewriteRules` follow this format:

```
[label General RewriteRule structure]
RewriteRule pattern substitution [flags]
```

* `RewriteRule` specifies the directive.
* `pattern` is a [regular expression](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) that matches the desired string from the URL, which is what the viewer types in the browser.
* `substitution` is the path to the actual URL, i.e., the path of the file Apache servers.
* `flags` are optional parameters that can modify how the rule works.

Next, create your URL rewrite rule. Open up the `.htaccess` file.

```command
sudo nano /var/www/html/.htaccess
```

After the first line, add the highlighted `RewriteRule` and save the file.

```
[label /var/www/html/.htaccess]
RewriteEngine on
<^>RewriteRule ^about$ about.html [NC]<^>
```

In this case, `^about$` is the pattern, `about.html` is the substitution, and `[NC]` is a flag. This example uses a few characters with special meaning:

* `^` indicates the start of the URL after `<^>your_server_ip<^>/`.
* `$` indicates the end of the URL.
* `about` matches the string "about".
* `about.html` is the actual file that the user accesses.
* `[NC]` is a flag that makes the rule case insensitive.

You can now access `http://<^>your_server_ip<^>/about` in your browser. In fact, with the rule shown above, the following URLs will point to `about.html`:

* `http://<^>your_server_ip<^>/about`, because of the rule definition.
* `http://<^>your_server_ip<^>/About`, because the rule is case insensitive.
* `http://<^>your_server_ip<^>/about.html`, because the original proper filename will always work.

However, the following will not work:

* `http://<^>your_server_ip<^>/about/`, because the rule explicitly states that there may be nothing after `about`, since the `$` character appears after `about`.
* `http://<^>your_server_ip<^>/contact`, because it won't match the `about` string in the rule.

You now have an operational `.htaccess` file with a basic rule that you can modify and extend to your needs. In the following sections, you will go through two additional examples of commonly used directives.

## Example 1 — Simplifying Query Strings with RewriteRule

Web applications often make use of *query strings*, which are appended to a URL using a question mark (`?`) after the address. Separate parameters are delimited using an ampersand (`&`). Query strings may be used for passing additional data between individual application pages.

For example, a search result page written in PHP may use a URL like `http://example.com/results.php?item=shirt&season=summer`. In this example, two additional parameters are passed to the imaginary `result.php` application script: `item`, with the value `shirt`, and `season` with the value  `summer`. The application may use the query string information to build the right page for the visitor.

Apache rewrite rules are often employed to simplify such long and unpleasant links as the above into *friendly URLs* that are easier to type and interpret visually. In this example, you will simplify the above link to become `http://example.com/shirt/summer`. The `shirt` and `summer` parameter values are still in the address but without the query string and script name.

Here's one rule to implement this:

```
[label Simple substitution]
RewriteRule ^<^>shirt<^>/<^>summer<^>$ results.php?item=<^>shirt<^>&season=<^>summer<^> [QSA]
```

The `shirt/summer` is explicitly matched in the requested address and Apache is told to serve `results.php?item=shirt&season=summer` instead.

The `[QSA]` flags are commonly used in rewrite rules. They tell Apache to append any additional query string to the served URL, so if the visitor types `http://example.com/shirt/summer?<^>page=2<^>` the server will respond with `results.php?item=shirt&season=summer<^>&page=2<^>`. Without it, the additional query string would get discarded.

While this method achieves the desired effect, both the item name and season are hardcoded into the rule. This means the rule will not work for any other items, like `pants`, or seasons, like `winter`.

To make the rule more generic, you can use [regular expressions](https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions) to match parts of the original address and use those parts in a substitution pattern. The modified rule will then look as follows:

```
[label Simple substitution]
RewriteRule ^<^>([A-Za-z0-9]+)<^>/<^>(summer|winter|fall|spring)<^> results.php?item=$1&season=$2 [QSA]
```

The first regular expression group in parenthesis matches a string containing alphanumeric characters and numbers like `shirt` or `pants` and saves the matched fragment as the `$1` variable. The second regular expression group in parenthesis matches exactly `summer`, `winter`, `fall`, or `spring`, and similarly saves the matched fragment as `$2`.

The matched fragments are then used in the resulting URL in `item` and `season` variables instead of hardcoded `shirt` and `summer` values you used before.

The above will convert, for example, `http://example.com/pants/summer` into `http://example.com/results.php?item=pants&season=summer`. This example is also future proof, allowing multiple items and seasons to be rewritten correctly using a single rule.

## Example 2 — Adding Conditions with Logic Using RewriteConds

Rewrite rules are not necessarily always evaluated one by one without any limitations. The `RewriteCond` directive lets us add conditions to your rewrite rules to control when the rules are processed. All `RewriteConds` abide by the following format:

```
[label General RewriteCond structure]
RewriteCond TestString Condition [Flags]
```

* `RewriteCond` specifies the `RewriteCond` directive.
* `TestString` is the string to test against.
* `Condition` is the pattern or condition to match.
* `Flags` are optional parameters that may modify the condition and evaluation rules.

If a `RewriteCond` evaluates to true, the `RewriteRule` immediately following will be considered. If it won't, the rule will be discarded. Multiple `RewriteCond` may be used one after another and, with default behavior, all must evaluate to true for the following rule to be considered.

As an example, let's assume you would like to redirect all requests to non-existent files or directories on your site back to the home page instead of showing the standard **404 Not Found** error page. This can be achieved with following conditions rules:

```
[label Redirect all requests to non-existent files and directories to home page]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . / [R=301]
```

With the above:

* `%{REQUEST_FILENAME}` is the string to check. In this case, it's the requested filename, which is a system variable available for every request.
* `-f` is a built-in condition that verifies if the requested name exists on disk and is a file. The `!` is a negation operator. Combined, `!-f` evaluates to true only if a specified name does not exist or is not a file.
* Similarly, `!-d` evaluates to true only if a specified name does not exist or is not a directory.

The `RewriteRule` on the final line will come into effect only for requests to non-existent files or directories. The `RewriteRule` itself is very simple. The dot `.` in the pattern matches anything and the substitution directs every request to the `/` website root.

Additionally, `[R=301]` flag tells Apache to return a *301 Moved Permanently* redirect HTTP response code to the browser, resulting in a browser knowing the redirect happened and explicitly fetching the website root instead of the requested URL, with the change being reflected on the browser address bar.

Without this flag, Apache would return the website root contents, but the browser would still think the requested page URL exists and would show the originally requested address on the address bar.

# Conclusion

`mod_rewrite` lets you create human-readable URLs. In this tutorial, you used the `RewriteRule` directive to redirect URLs, including ones with query strings. You also wrote conditionally redirecting URLs using the `RewriteCond` directive.

If you'd like to learn more about `mod_rewrite`, take a look at [Apache's mod_rewrite Introduction](http://httpd.apache.org/docs/current/rewrite/intro.html) and [Apache's official documentation for mod_rewrite](http://httpd.apache.org/docs/current/mod/mod_rewrite.html).


How to Rewrite URLs with mod_rewrite for Apache on Ubuntu 22.04

senior technical writer

Manager, Developer Education

Sign up for Infrastructure as a Newsletter.

Working on improving health and education, reducing inequality, and spurring economic growth? DigitalOcean would like to help.

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

You get paid; we donate to tech nonprofits.

DigitalOcean makes it simple to launch in the cloud and scale up as you grow – whether you’re running one virtual machine or ten thousand.