Sling Academy
Home/DevOps/NGINX: How to Mass Redirect URLs Using Regular Expressions

NGINX: How to Mass Redirect URLs Using Regular Expressions

Last updated: January 19, 2024

Introduction

NGINX stands as a powerful web server which can also be used as a reverse proxy, load balancer, and HTTP cache. The ability to redirect URLs efficiently is a vital factor in managing your web resources, and understanding how to leverage NGINX’s powerful rewrite module is an essential skill for web administrators and developers alike. This tutorial will guide you through the process of mass redirecting URLs using regular expressions with NGINX.

Basic Understanding of NGINX Redirects

Before jumping into regular expressions, it’s important to understand the basic mechanism behind NGINX redirects. The NGINX web server uses the return and rewrite directives to manage redirects.

Here is a simple example of a permanent redirect (HTTP 301):

server {
    listen 80;
    server_name example.com;
    location /oldpage.html {
        return 301 http://example.com/newpage.html;
    }
}

This configuration will redirect all requests from /oldpage.html to /newpage.html on the same domain.

Introduction to Regular Expressions

Regular expressions (regex) are patterns that describe a set of strings. NGINX uses the Perl Compatible Regular Expressions (PCRE) library for regex pattern matching. When applied to URL redirection, regex allows you to define patterns that match multiple URLs, enabling the ability to redirect large numbers of URLs in a more flexible way.

Simple Regex Redirects

Start by defining a pattern that matches the URLs you want to redirect. For example, if you want to redirect all URLs with /old/ to /new/, your NGINX configuration could look like this:

server {
    listen 80;
    server_name example.com;
    location ~ ^/old/(.*)$ {
        return 301 http://example.com/new/$1;
    }
}

Here, the regex pattern ^/old/(.*)$ matches any URL that starts with /old/. The parentheses ((.*)) capture everything after /old/, which can be used in the redirection URL with $1, representing the first captured group.

Advanced Regex Redirects

Let’s consider a more complex example. You want to redirect URLs from old product pages to new ones, but the URL structure has changed significantly. Here’s a sample of what this regex redirect could look like:

server {
    listen 80;
    server_name example.com;
    location ~* ^/product/(?<old_id>[0-9]+)/(?<old_name>[\w-]+)/?$ {
        return 301 http://example.com/new-products/$old_name-$old_id;
    }
}

This configuration redirects URLs matching the product’s old ID and name pattern to the new URL pattern. Note the use of named captures (?<name>) for better readability and maintainability. The redirect sends traffic to the new product path, where the product name precedes the ID, separated by a dash.

Error Handling with Redirects

Sometimes, you may need to redirect only if a certain condition, such as the absence of a file or an error code, is met. NGINX can match these conditions with the @ syntax for a named location, combining it with try_files to achieve the redirect:

server {
    listen 80;
    server_name example.com;
    location / {
        try_files $uri $uri/ @fallback;
    }
    location @fallback {
        return 301 http://example.com/new-landing;
    }
}

In this example, if the requested file or directory is not found on the server, NGINX will redirect to the /new-landing page.

Testing Your Redirects

After making changes to your NGINX configuration file, always test to ensure no syntax errors are present before applying them. You can test your configuration using the following command:

sudo nginx -t

If the test passes, you can apply the changes with:

sudo nginx -s reload

Then, verify your redirects by accessing the old URLs and checking if you are properly redirected to the new ones.

Conclusion

Understanding how to manage mass redirects using NGINX and regular expressions allows for powerful and dynamic control over your site’s navigation and can greatly enhance the user experience. Redirects not only aid in maintaining SEO rankings during site migrations or restructures but also help in keeping your website organized and accessible for visitors. With practice, you can apply increasingly complex patterns for any redirection need that may arise in your web endeavors.

Next Article: NGINX and Directory Permission: 403 Forbidden Error

Previous Article: URL Rewriting in NGINX: The Ultimate Guide

Series: NGINX Tutorials

DevOps

You May Also Like

  • How to reset Ubuntu to factory settings (4 approaches)
  • Making GET requests with cURL: A practical guide (with examples)
  • Git: What is .DS_Store and should you ignore it?
  • NGINX underscores_in_headers: Explained with examples
  • How to use Jenkins CI with private GitHub repositories
  • Terraform: Understanding State and State Files (with Examples)
  • SHA1, SHA256, and SHA512 in Terraform: A Practical Guide
  • CSRF Protection in Jenkins: An In-depth Guide (with examples)
  • Terraform: How to Merge 2 Maps
  • Terraform: How to extract filename/extension from a path
  • JSON encoding/decoding in Terraform: Explained with examples
  • Sorting Lists in Terraform: A Practical Guide
  • Terraform: How to trigger a Lambda function on resource creation
  • How to use Terraform templates
  • Understanding terraform_remote_state data source: Explained with examples
  • Jenkins Authorization: A Practical Guide (with examples)
  • Solving Jenkins Pipeline NotSerializableException: groovy.json.internal.LazyMap
  • Understanding Artifacts in Jenkins: A Practical Guide (with examples)
  • Using Jenkins with AWS EC2 and S3: A Practical Guide