Detailed explanation of Nginx's rewrite module

The rewrite module is the ngx_http_rewrite_module module. Its main function is to rewrite the request URI. It is the module installed by default in Nginx. The rewrite module will rewrite the URI according to the PCRE regular expression, then initiate an internal redirect and match the location, or directly do a 30x redirect to return to the client.

The order of command execution is to first execute the rewrite module commands in the server block to obtain the request URI after rewriting.
Then execute the following instructions in a loop

If the break loop flag is not encountered, this loop will be executed at most 10 times, but we can use the break instruction to interrupt the new round of loop after rewrite
(1). Match the defined location block according to the request URI after rewriting

(2) Sequentially execute the rewrite module instructions in the matched location

instruction
break
Context: server, location, if
Stop executing the instruction set of ngx_http_rewrite_module, but other module instructions are not affected

Example

server {
 listen 8080;
 # Here break will stop the execution of the return instruction of the server block (return instruction belongs to the rewrite module)
 # If you comment it out, all incoming requests will return ok
 break;
 return 200 "ok";
 location = /testbreak {
  break;
  return 200 $request_uri;
  proxy_pass http://127.0.0.1:8080/other;
 }
 location / {
  return 200 $request_uri;
 }
}

# Send the request as follows# curl 127.0.0.1:8080/testbreak
# /other

# You can see that `/other` is returned instead of `/testbreak`, indicating that the `proxy_pass` instruction is still executed. # That is to say, the instructions of other modules will not be interrupted by break. # (proxy_pass is the instruction of ngx_http_proxy_module)

if
Context: server, location

Determines whether to execute the contents of the if block statement based on the specified conditions

Several judgment conditions in if
1. A variable name. If the value of the variable $variable is an empty string or the string "0", it is false
2. The comparison between a variable and a string is equal (=) and not equal (!=). Note that you should not use equality as an assignment statement here.
3. The pattern matching operator for a variable and a regular expression can be (~ for case-sensitive regular matching, ~ for case-insensitive regular matching, !! , the negation of the first two)
4. Check if the file exists using -f (exists) and !-f (does not exist)
5. Check if the path exists using -d (exists) and !-d (does not exist). The following judgment can be a string or a variable
6. Check if a file, path, or link exists by using -e (exists) and !-e (does not exist). The following check can be a string or a variable.
7. To check whether a file is an executable file, use -x (executable) and !-x (non-executable). The following judgment can be a string or a variable.

Note that the values in items 1, 2, and 3 above must be variables, while values in items 4, 5, 6, and 7 can be either variables or strings. The basic usage of -f/-d/-e/-x is the same as that of bash.

set $variable "0"; 
if ($variable) {
 # Will not execute because "0" is false
 break;   
}

# There is no problem using variables to match regular expressions if ( $http_host ~ "^star\.igrow\.cn$" ) {
 break;   
}

# String matches regular expression and reports an error if ( "star" ~ "^star\.igrow\.cn$" ) {
 break;   
}
# Check if both file-like strings and variables are OK if ( !-f "/data.log" ) {
 break;   
}

if ( !-f $filename ) {
 break;   
}

return

Context: server, location, if

return code [text];
return code URL;
return URL;

Stops processing and returns the specified code to the client. The nonstandard code 444 closes the connection without sending a response header.

Starting from version 0.8.42, the return statement can specify a redirect URL (the status code can be 301, 302, 303, 307).
You can also specify the text content of the response for other status codes, and the redirect URL and the response text can contain variables.

There is a special case where the redirected url can be specified as the local url of this server. In this case, nginx will automatically generate a complete url based on the requested protocol $scheme, server_name_in_redirect and port_in_redirect (it should be noted here that the server_name_in_redirect and port_in_redirect instructions indicate whether to use the server_name and listen port in the server block as redirects)

# return code [text]; Return ok to the client location = /ok {
 return 200 "ok";
}

# return code URL; Temporary redirect to Baidu location = /redirect {
 return 302 http://www.baidu.com;
}

# return URL; As above, the default is also a temporary redirect location = /redirect {
 return http://www.baidu.com;
}

rewrite

Context: server, location, if

rewrite regex replacement [flag];

The rewrite directive uses the specified regular expression regex to match the requested URI, and if the match is successful, the URI is changed using replacement. rewrite directives are executed in the order they appear in the configuration file. The flag can be used to terminate further processing of the instruction. If the replacement string replacement starts with http://, https://, or $scheme, stop processing subsequent content and redirect directly back to the client.

The first case rewrites the string with http://

location / {
 # When matching the regular expression /test1/(.*), the request will be temporarily redirected to http://www.$1.com
 # Equivalent to flag written as redirect
 rewrite /test1/(.*) http://www.$1.com;
 return 200 "ok";
}
# Enter 127.0.0.1:8080/test1/baidu in the browser 
# Temporarily redirect to www.baidu.com
# The following return command will not have a chance to execute

The second case rewrites the string without http://

location / {
 rewrite /test1/(.*) www.$1.com;
 return 200 "ok";
}
# Send the request as follows# curl 127.0.0.1:8080/test1/baidu
# ok

# There is no http:// here so it is just a simple rewrite. The requested URI is rewritten from /test1/baidu to www.baidu.com
# Because the rewrite command will be executed sequentially, the next step is to execute the return command and the response is ok

Four flags of rewrite

1.last
Stop processing the current set of instructions for ngx_http_rewrite_module and start searching for a location that matches the changed URI; (because last means "continue", it will continue to try to match and jump to other locations)
2.break
Stops processing the current set of ngx_http_rewrite_module instructions, just like the break instruction mentioned above; (break means "break stop")
3. Redirect
Returns a 302 temporary redirect. (It can be understood as "temporary rental")
4.permanent
Returns a 301 permanent redirect. (It can be understood as "moving to a new home")

# If there is no rewrite and no flag after it, it will be executed sequentially. # If there is no rewrite module instruction in location that can be executed, it will be rewritten to initiate a new round of location matching location / {
 # Without flag, the default order is rewrite ^/test1 /test2;
 rewrite ^/test2 /test3; # A new round of location matching uri is initiated here, which is /test3
}

location = /test2 {
 return 200 "/test2";
} 

location = /test3 {
 return 200 "/test3";
}
# Send the following request# curl 127.0.0.1:8080/test1
# /test3

The difference between last and break

Like last and break, they will terminate the execution of other rewrite module instructions in this location.
But last immediately initiates a new round of location matching, while break does not.

location / {
 rewrite ^/test1 /test2;
 rewrite ^/test2 /test3 last; # A new round of location matching uri is initiated here: /test3
 rewrite ^/test3 /test4;
 proxy_pass http://www.baidu.com;
}

location = /test2 {
 return 200 "/test2";
} 

location = /test3 {
 return 200 "/test3";
}
location = /test4 {
 return 200 "/test4";
}
# Send the following request# curl 127.0.0.1:8080/test1
# /test3 

If you change the location / above to the following code location / {
 rewrite ^/test1 /test2;
 # A new round of location matching will not be initiated here; the subsequent rewrite module instructions will be terminated and the rewritten uri will be /more/index.html
 rewrite ^/test2 /more/index.html break; 
 rewrite /more/index\.html /test4; # This command will be ignored # Because proxy_pass is not a command of the rewrite module, it will not be terminated by break proxy_pass https://www.baidu.com;
}
# Send the following request# Enter 127.0.0.1:8080/test1 in the browser 
# Agent to Baidu product page https://www.baidu.com/more/index.html;

Request parameters after rewrite <br /> If the replacement string replacement contains new request parameters, the previous request parameters are appended after them. If you don't want the previous parameters, put a question mark at the end of the replacement string to avoid appending them.

# Because a ? is added at the end, the original request parameters will not be appended to the URL after rewrite rewrite ^/users/(.*)$ /show?user=$1? last;

rewrite_log

Context: http, server, location, if

Enable or disable the log of rewrite module instruction execution. If enabled, rewrite will record notice-level logs to nginx error_log. The default is off.

Syntax: rewrite_log on | off;

set

Context: server, location, if

Sets the value of the specified variable. The value of a variable can contain text, variables, or a combination of these.

location / {
 set $var1 "host is ";
 set $var2 $host;
 set $var3 "uri is $request_uri";
 return 200 "response ok $var1$var2$var3";
}
# Send the following request# curl 127.0.0.1:8080/test
# response ok host is 127.0.0.1 uri is /test

uninitialized_variable_warn

Context: http, server, location, if

Controls whether warnings about uninitialized variables are logged. Enabled by default

Internal Implementation

The ngx_http_rewrite_module module directives are compiled during the configuration phase into internal directives that are interpreted during request processing. The interpreter is a simple virtual stack machine.

For example, the instruction

location /download/ { if ( forbidden ) return 403 ; if ( forbidden) { return 403; } if ( forbidden)return403;if(slow) { limit_rate 10k; } rewrite ^/(download/. )/media/(. )…*$ /$1/mp3/$2.mp3 break; }

Will be translated into the following instructions:

variable $forbidden check against zero return 403 end of code variable $slow check against zero match of regular expression copy “/” copy $1 copy “/mp3/” copy $2 copy “.mp3” end of regular expression end of code

Note that there is no limit_rate directive above, as it has nothing to do with the ngx_http_rewrite_module module. Create a separate configuration for the if block. If the condition is true, then a request will be allocated for this configuration with limit_rate equal to 10k. \

instruction

rewrite ^/(download/. )/media/(. )…*$ /$1/mp3/$2.mp3 break;

If the first slash in the regular expression is placed within parentheses, it can be simplified:

rewrite ^(/download/. )/media/(. )…*$ $1/mp3/$2.mp3 break;

The corresponding directive would look like this:

match of regular expression copy $1 copy “/mp3/” copy $2 copy “.mp3” end of regular expression end of code

location (non-rewrite module)

grammar

Use it in the server block, such as:

server{
location expression {
}

location expression type

If you write a path directly, the path will be matched by a regular expression, which is case-sensitive.
~* means to perform a regular match, which is case insensitive
^~ means ordinary character matching. Use prefix matching. If the match is successful, no other locations will be matched.
= Performs an exact match of common characters. That is, an exact match.

Priority
1. The equal sign type (=) has the highest priority. Once a match is found, no further matches are searched.
2.^~ type expression. Once a match is found, no further matches are searched.
3. Regular expression type (~ ~*) has the next highest priority. If there are multiple locations that match the regular expression, the one with the longest regular expression is used.
4. Conventional string matching type. Match by prefix.

This is the end of this article about the detailed explanation of Nginx's rewrite module. For more relevant Nginx rewrite content, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!

You may also be interested in: