Welcome to the first lesson of Advanced NGINX Configuration and Monitoring! We're excited to embark on this journey with you as we explore the powerful capabilities of NGINX beyond basic web serving. Throughout this course, we'll dive deep into advanced configuration techniques that will help you build more efficient, scalable, and user-friendly web applications.

In this lesson, we'll focus on URL rewriting and redirects, essential techniques for creating clean, search engine-friendly URLs and maintaining backward compatibility as your application evolves. By the end of this lesson, you'll understand how to transform query-based URLs into elegant path-based ones, handle legacy URLs gracefully, and create dynamic routing patterns using regular expressions.

Before we dive into the code, let's clarify what URL rewriting and redirects accomplish and why they matter. Modern web applications often need to present clean, readable URLs to users while maintaining compatibility with older URL structures. For example, instead of showing /products?id=123, we might want to display /products/123.

URL rewriting and redirects serve different but complementary purposes:

• Redirects tell the client's browser to make a new request to a different URL, which is visible to the user.
• Rewrites happen internally on the server, transforming one URL pattern into another without the client knowing.

Note: With a rewrite, the correct page will open without redirecting. But here's the crucial distinction: Opening the correct page is not the same as having the correct URL. When using a rewrite, the URL in the browser's address bar remains unchanged—the user still sees the original URL they requested, even though the server is processing a different internal path. This is in contrast to a redirect, where the browser's URL updates to reflect the new location.

Together, these techniques help us maintain a clean URL structure, support legacy paths, and create more intuitive navigation for our users.

Let's start by establishing our basic NGINX server configuration. We'll configure a server that listens on port 3000 and sets up the foundation for our URL handling logic:

worker_processes 1;
events { worker_connections 1024; }
http {
  default_type text/plain;
  server {
    listen 3000;
    server_name localhost;
    # URL handling directives will go here
  }
}

This configuration creates a simple HTTP server that responds with plain text by default. The server listens on port 3000 and is ready to accept requests on localhost. We've set default_type text/plain to simplify our responses for demonstration purposes.

Many legacy systems use query parameters for routing, such as /products?id=123. Let's create a cleaner experience by redirecting these to path-based URLs:

location = /products {
  if ($arg_id) {
    return 301 /products/$arg_id;
  }
  return 400 "missing id";
}

This location block handles requests to exactly /products (note the = modifier). Here's what happens:

• The special variable $arg_id contains the value of the id query parameter.
• If $arg_id exists, we issue a 301 redirect to the clean URL format /products/123.
• If no id parameter is provided, we return a 400 Bad Request with an error message.

This approach transforms /products?id=123 into /products/123, creating URLs that are more readable and SEO-friendly.

A Note on Using if in NGINX: You may have heard that if directives are discouraged in NGINX configuration (sometimes referred to as "If is Evil"). While this is generally true due to unexpected behavior in many contexts, using if with return is one of the safe cases. The return directive immediately stops processing, avoiding the common pitfalls associated with if. For more complex conditional logic involving query parameters, consider using the map directive.

In this lesson, we've built a comprehensive URL handling system using NGINX. We learned how to redirect legacy URLs with the rewrite directive, transform query-based URLs into clean paths using location blocks and conditionals, extract data from URLs with regular expressions, and provide appropriate fallback handling for unmatched routes.

These techniques form the foundation of modern web routing and are essential for maintaining clean, maintainable URL structures in production applications. The combination of redirects, rewrites, and dynamic pattern matching gives us the flexibility to evolve our application's URL structure while maintaining backward compatibility.

Now it's time to put these concepts into practice! In the upcoming exercises, you'll have the opportunity to implement these URL rewriting and redirect patterns yourself, solidifying your understanding through hands-on experience.