Detailed explanation of commonly used nginx rewrite rules

This article provides some commonly used rewrite rules to beautify web page links. If you don't know where the $1$2 in the rule comes from, just remember that the first () is $1 and the second () is $2.

The requested URL is for humans to see, and the rewritten URL is for computers to see.

Perform a search

The purpose of this rule is to perform a search for keywords contained in the URL.

Requested URL: //hqidi.com/search/some-search-keywords
Rewritten URL: //hqidi.com/search.php?p=some-search-keywords
Rewrite rule rewrite ^/search/(.*)$ /search.php?p=$1?;

User Profile Page

Most dynamic websites that run visitor registrations provide a page where the profile can be viewed. The URL of this page contains the user's UID and username.

Requested URL: //hqidi.com/user/47/dige
Rewritten URL //hqidi.com/user.php?id=47&name=dige
Rewrite rule rewrite ^/user/([0-9]+)/(.+)$ /user.php?id=$1&name=$2?;

Multiple parameters

Some sites use different syntax for string parameters, such as using slashes "/" to separate non-named parameters.

Requested URL: //hqidi.com/index.php/param1/param2/param3
Rewritten URL //hqidi.com/index.php?p1=param1&p2=param2&p3=param3
Rewrite rule rewrite ^/index.php/(.*)/(.*)/(.*)$ /index.php?p1=$1&p2=$2&p3=$3?;

Encyclopedia-like format

This format features a prefix directory followed by the article name

Requested URL: //hqidi.com/wiki/some-keywords
Rewritten URL //hqidi.com/wiki/index.php?title=some-keywords
Rewrite rule rewrite ^/wiki/(.*)$ /wiki/index.php?title=$1?;

forum

Forums generally use two parameters, a topic identifier (topic) and a starting point (starting post)

Requested URL: //hqidi.com/topic-1234-50-some-keywords.html
Rewritten URL //hqidi.com/viewtopic.php?topic=1234&start=50
Rewrite rule rewrite ^/topic-([0-9]+)-([0-9]+)-(.*)\.html$ viewtopic.php?topic=$1&start=$2?;

New site articles

This URL structure is characterized by an article identifier, followed by a slash, and a list of keywords.

Requested URL: //hqidi.com/88/future
Rewritten URL: //hqidi.com/atricle.php?id=88
Rewrite rule rewrite ^/([0-9]+)/.*$ /aticle.php?id=$1?;

The last question mark

If the URI to be replaced contains parameters (such as /app/test.php?id=5), the parameters will be automatically appended to the replacement string by default. This problem can be solved by adding a ? mark at the end of the replacement string.

rewrite ^/users/(.*)$ /show?user=$1? last;

Compare one plus? Marked or not? The difference between marked URL jumps:

rewrite ^/test(.*)$ //hqidi.com/home premanent;

Visit //hqidi.com/test?id=5 and after 301 redirection, the URL address is //hqidi.com/home?id=5

rewrite ^/test(.*)$ //hqidi.com/home? premanent;

Visit //hqidi.com/test?id=5 and the URL after 301 redirection is //hqidi.com/home

Nginx's rewrite function requires the support of PCRE software, that is, rule matching is performed through perl-compatible regular expression statements. Compiling nginx with default parameters will support the rewrite module, but PCRE support is also required

rewrite is the key instruction to implement URL rewriting. It redirects to replacement according to the regex (regular expression) part, and ends with a flag tag.

nginx rewrite instruction execution order

1. Execute the rewrite instruction of the server block (the block here refers to the area surrounded by {} after the server keyword, and other xx blocks are similar)
2. Perform location matching
3. Execute the rewrite instruction in the selected location

If the URI in any step is rewritten, steps 1-3 are executed again in a loop until a real file is found.

If the loop exceeds 10 times, a 500 Internal Server Error is returned.

flag

The syntax of rewrite is very simple, such as:

rewrite regex URL [flag];

rewrite is a keyword, regex is a regular expression, URL is the content to be replaced, and [flag] means the flag bit, which has the following values:

• last: Equivalent to the [L] flag in Apache, indicating that rewrite is complete
• break: Stop executing the subsequent rewrite instruction set of the current virtual host
• redirect: Returns a 302 temporary redirect, and the address bar will display the redirected address
• permanent: Returns a 301 permanent redirect, and the address bar will display the redirected address

Because 301 and 302 cannot simply return only the status code, there must also be a redirection URL. This is why the return instruction cannot return 301,302. The difference between last and break here is a bit difficult to understand:

• Last is usually written in server and if, while break is usually used in location.
• last does not terminate the rewritten URL matching, that is, the new URL will go through the matching process from the server again, while break terminates the rewritten matching
• Both break and last can prevent the execution of subsequent rewrite instructions.

Let's look at a simple example:

rewrite ^/listings/(.*)$ /listing.html?listing=$1 last;
rewrite ^/images/(.*)_(\d+)x(\d+)\.(png|jpg|gif)$ /resizer/$1.$4?width=$2&height=$3? last;

In the first rewrite rule, we can use the friendly URL: http://mysite.com/listings/123 instead of http://mysite.com/listing.html?listing=123, which is equivalent to entering http://mysite.com/listings/123 in the address bar of the browser, and the actual URL resource accessed is http://mysite.com/listing.html?listing=123.

In the second rule, the file request of the form http://mysite.com/images/bla_500x400.jpg is rewritten to the address http://mysite.com/resizer/bla.jpg?width=500&height=400, and it will continue to try to match the location.

if instruction and global variables

The syntax of the if instruction is if(condition){...}, which judges the given condition. If true, the rewrite directives within the curly braces will be executed.

Let’s look at the code rules:

if ($http_user_agent ~ MSIE) {
  rewrite ^(.*)$ /msie/$1 break;
} //If UA contains "MSIE", rewrite the request to the /msid/ directory if ($http_cookie ~* "id=([^;]+)(?:;|$)") {
  set $id $1;
 } //If the cookie matches the regular expression, set the variable $id to be equal to the regular expression reference part if ($request_method = POST) {
  return 405;
} //If the submission method is POST, the return status is 405 (Method not allowed). return cannot return 301,302
 
if ($slow) {
  limit_rate 10k;
} //Speed ​​limit, $slow can be set by the set command if (!-f $request_filename){
  break;
  proxy_pass http://127.0.0.1; 
} //If the requested file name does not exist, reverse proxy to localhost. The break here also stops the rewrite check if ($args ~ post=140){
  rewrite ^ http://mysite.com/ permanent;
} //If the query string contains "post=140", permanently redirect to mysite.com

In the if instruction, global variables can be used. These variables are:

• $args: #This variable is equal to the parameters in the request line, the same as $query_string
• $content_length: The Content-length field in the request header.
• $content_type: The Content-Type field in the request header.
• $document_root: The value specified in the root directive of the current request.
• $host: The request Host header field, otherwise the server name.
• $http_user_agent: Client agent information
• $http_cookie: Client cookie information
• $limit_rate: This variable can limit the connection rate.
• $request_method: The action requested by the client, usually GET or POST.
• $remote_addr: The IP address of the client.
• $remote_port: The client's port.
• $remote_user: The username that has been authenticated by the Auth Basic Module.
• $request_filename: The file path of the current request, generated by the root or alias directive and the URI request.
• $scheme: HTTP protocol (such as http, https).
• $server_protocol: The protocol used in the request, usually HTTP/1.0 or HTTP/1.1.
• $server_addr: Server address. This value can be determined after completing a system call.
• $server_name: Server name.
• $server_port: The port number on which the request arrives on the server.
• $request_uri: The original URI including the request parameters, without the hostname, such as: "/foo/bar.php?arg=baz".
• $uri: The current URI without request parameters. $uri does not contain the host name, such as "/foo/bar.html".
• $document_uri: Same as $uri.

Use return to jump

Sometimes we need to use rewrite on Nginx to do a 301 address jump, such as the following rules:

rewrite ^ $scheme://www.mysite.com$request_uri permanent;

When you visit any URL, it will be permanently redirected to the URL www.mysite.com with 301. This way of writing is correct, but because of the use of rewrite regular matching, some resources will be consumed, and the nginx official website does not recommend this way of writing. We can also use return to achieve 301 redirect, which is simple and practical. See the example:

301 Permanently redirect to the new domain name

server {
  listen 80;
  listen 443 ssl;
  server_name www.old-name.com old-name.com;
  return 301 $scheme://www.new-name.com;
}

The above code implements a 301 redirect from the old domain name to the new domain name. If the website needs to change to a new domain name, use this method to do a 301 redirect.

301 redirection from a domain without www to a domain with www

server {
  listen 80;
  listen 443 ssl;
  server_name mysite.com;
  return 301 $scheme://www.mysite.com$request_uri;
}

301 redirect from http site to https site

server {
  listen 80;
  server_name www.mysite.com;
  return 301 https://www.mysite.com$request_uri;
}

The above is an introduction to Nginx's rewrite and redirection. If you find it useful, please practice it many times and save this article to avoid getting lost. I also hope that everyone will support 123WORDPRESS.COM.