Detailed explanation of location and rewrite usage in nginx

1. Summary of location usage

Location can locate different types of requests to different processing methods.

1. Usage of location

location ~* /js/.*/\.js

• Starting with = indicates an exact match; for example, only requests ending with the root directory are matched, and no string can be followed.
• Starting with ^~ means that the URI starts with a regular string, not a regular match
• Starting with ~ indicates a case-sensitive regular match;
• Starting with ~* indicates a case-insensitive regular expression match
• Starts with /, universal match, if there is no other match, any request will match

The matching order of location is "match regular first, then match common".

Correction: The matching order of location is actually "match common first, then match regular". When I say this, everyone will definitely refute me, because the principle of "matching common first, then matching regular" cannot explain the practical experience of "matching regular first, then matching common" that everyone is accustomed to. Here I can only temporarily explain that the reason for this misunderstanding is that regular matching will override ordinary matching.

2. Location usage examples

Location regular expression:

1. # Exact match /, the host name cannot be followed by any string

location = / {
[ configuration A ]
} 

2.# All addresses start with /, so this rule will finally match the default request

# But regular expressions and longest strings will match location / {
[ configuration B ]
}

example:

  location / { 
     proxy_pass http://server_pools;
    } 
#This rule can only be matched if other rules do not meet the requirements; it will be the last one to be matched, with the lowest matching degree. The function implemented above is: for example, if the website is www.blog.com; if nothing is entered afterwards,
When other rules do not match, the request is finally handed over to the server in the load balancing pool.

3.# Match any address starting with /documents/. After matching, continue searching

# This one will be used only if the following regular expression does not match location /documents/ {
[ configuration C ]
}

example:

location /static/
    {
    rewrite ^ http://www.abc.com ;   
    }
#The function implemented above: Assuming the website domain name is www.blog.com; then the above function is configured to enter www.blog.com/static/, no matter what page is after static (the page may not exist),
Then it will eventually jump to the website www.abc.com.

4.# Match any address starting with /documents/. After matching, continue searching

# This rule will be used only if the following regular expression does not match

location ~ /documents/Abc {
[ configuration CC ]
}

5.# Match any address starting with /images/. After the match is found, stop searching for regular expressions and use this one.

location ^~ /images/ {
[ configuration D ]
}

6.# Match all requests ending with gif,jpg or jpeg

# However, all requests for images under /images/ will be processed by config D, because ^~ cannot reach this regular expression

location ~* \.(gif|jpg|jpeg)$ {
[ configuration E ]
}

example:

7. The # character matches /images/. If you continue to go down, you will find that ^~ exists.

location /images/ {
[ configuration F ]
}

8.# The longest character matches /images/abc. Continue to go down and you will find ^~ exists

# The order of placement of F and G does not matter

location /images/abc {
[ configuration G ]
}

9.# Only when config D is removed will it be effective: first match the address starting with config G for the longest time, continue searching down, and match this regular expression, use

location ~ /images/abc/ {
[ configuration H ]
}

Order no priority:

(location =) > (location full path) > (location ^~ path) > (location ~,~* regular sequence) > (location partial starting path) > (/) The above matching results:

According to the location writing above, the following matching examples are established:
/ -> config A
Exact match, even /index.html cannot match /downloads/download.html -> config B
After matching B, there is no match below, so use B
/images/1.gif -> configuration D
Matches to F, matches to D, stops at /images/abc/def -> config D
The longest match is G, and then it goes down to D, and stops. You can see that anything starting with /images/ will match D and stop. FG is meaningless here, and H will never get a turn. This is just to illustrate the matching order /documents/document.html -> config C
Matches to C, no matches below, use C
/documents/1.jpg -> configuration E
Matches to C, and then matches to E
/documents/Abc.jpg -> config CC
The longest match is C, and the regular sequence matches CC, not E.

3. Practical use suggestions

So in actual use, I think there are at least three matching rule definitions, as follows:

#Directly match the website root. It is more frequent to access the website homepage through the domain name. Using this will speed up the processing, the official website said.
#This is forwarded directly to the backend application server, or it can be a static homepage# The first required rule location = / {
proxy_pass http://tomcat:8080/index
}
# The second mandatory rule is to process static file requests, which is the strength of nginx as an http server. # There are two configuration modes, directory matching or suffix matching, choose one or use both location ^~ /static/ {
root /webroot/static/;
}
location ~* \.(gif|jpg|jpeg|png|css|js|ico)$ {
root /webroot/res/;
}
#The third rule is a general rule, which is used to forward dynamic requests to the backend application server. #Non-static file requests are dynamic requests by default, and you can grasp it according to your actual situation. #After all, some popular frameworks now rarely have .php and .jsp suffixes. location / {
proxy_pass http://tomcat:8080/
}
http://tengine.taobao.org/book/chapter_02.html
http://nginx.org/en/docs/http/ngx_http_rewrite_module.html

2. Summary of Rewrite usage

1. Definition of rewrite

The rewrite function uses the global variables provided by nginx or the variables you set yourself, combined with regular expressions and flags to achieve URL rewriting and redirection.

 rewrite can only be placed in server{}, location{}, if{}, and can only work on the string after the domain name excluding the passed parameters.
For example, http://seanlook.com/a/we/index.php?id=1&u=str will only rewrite /a/we/index.php.

2. Syntax of rewirte

rewrite regex replacement [flag];

If a relative domain name or parameter string works, you can use global variable matching or you can use proxy_pass reverse proxy.

From the above, it can be seen that rewrite and location functions are somewhat similar, and both can achieve jumps. The main difference is that rewrite changes the path to obtain resources within the same domain name, while location controls access or performs reverse proxy on a class of paths, which can proxy_pass to other machines.

In many cases, rewrite is also written in location. Their execution order is:

1 Execute the rewrite directive of the server block

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 the real file is found. If the loop exceeds 10 times, a 500 Internal Server Error is returned.

flag

• last : Equivalent to Apache's [L] flag, indicating that rewrite is complete
• break: Stop executing the subsequent rewrite instruction set of the current virtual host
• redirect : Return 302 temporary redirect, the address bar will show 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:

1. Last is usually written in server and if, while break is usually used in location.
2. 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
3. Both break and last can prevent the execution of subsequent rewrite instructions.
   

3.Rewrite commonly used regular expressions.

• . : matches any character except newline
• ? : Repeat 0 or 1 times
• + : Repeat 1 or more times
• * : Repeat 0 or more times
• \d : matches a number
• ^ : matches the beginning of a string
• $ : matches the end of the string
• {n} ： repeat n times
• {n,} ： repeat n times or more
• [c] ： Matches a single character c
• [az]: matches any lowercase letter az

The content matched between the parentheses () can be referenced later by $1, and $2 represents the content in the second (). What is confusing in regular expressions is the \ escape special characters.

Rewrite Example

Example 1:
http {
# Define the image log format log_format imagelog '[$time_local] ' $image_file ' ' $image_type ' ' $body_bytes_sent ' ' $status;
# Enable rewrite log rewrite_log on;
 
server {
root /home/www;
 
location / {
# Rewrite rule information error_log logs/rewrite.log notice;
# Note that single quotes should be used here to avoid {}
rewrite '^/images/([az]{2})/([a-z0-9]{5})/(.*)\.(png|jpg|gif)$' /data?file=$3.$4;
# Note that you cannot add the "last" parameter after the above rule, otherwise the following set command will not be executed set $image_file $3;
set $image_type $4;
}
 
location /data {
#Specify the log format for images to analyze the image type and size access_log logs/images.log mian;
root /data/images;
# Apply the variables defined previously. First determine whether the file exists, if not, then determine whether the directory exists, if not, jump to the last url try_files /$arg_file /image404.html;
}
location = /image404.html {
# If the image does not exist, return specific information return 404 "image not found\n";
}
}
 
For a request like /images/ef/uh7b3/test.png, it is rewritten to /data?file=test.png, so it matches the location /data. First, check whether the /data/images/test.png file exists. If it exists, respond normally. If not, rewrite tryfiles to the new image404 location and directly return a 404 status code.

Example 2:
rewrite ^/images/(.*)_(\d+)x(\d+)\.(png|jpg|gif)$ /resizer/$1.$4?width=$2&height=$3? last;
For file requests such as /images/bla_500x400.jpg, they are rewritten to the address /resizer/bla.jpg?width=500&height=400, and will continue to try to match location.

if instruction and global variables

if judgment instruction syntax

if (condition)
{...}

Judge the given condition. If true, the rewrite directives within the curly braces will be executed. The if condition can be any of the following:

When the expression is just a variable, if the value is empty or any string starting with 0, it will be considered false.
When comparing variables and contents directly, use = or !=
~ Regular expression matching
~* case-insensitive matching
!~ case-sensitive mismatch
-f and !-f are used to determine whether a file exists
-d and !-d are used to determine whether a directory exists
-e and !-e are used to determine whether a file or directory exists
-x and !-x are used to determine whether the file is executable

example:

If the user device is IE browser, redirect 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://example.com/ permanent;
} //If the query string contains "post=140", permanently redirect to example.com
 
location ~* \.(gif|jpg|png|swf|flv)$ {
valid_referers none blocked www.jefflei.comwww.leizhenfang.com;
if ($invalid_referer) {
return 404;
} //Anti-hotlinking}

Global variables

The following are global variables that can be used as if judgments

• $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 method (e.g. http, https).
• $server_protocol : The protocol used by 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.

example:

http://localhost:88/test1/test2/test.php
$host:localhost
$server_port:88
$request_uri：http://localhost:88/test1/test2/test.php
$document_uri:/test1/test2/test.php
$document_root:/var/www/html
$request_filename：/var/www/html/test1/test2/test.php

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.