nginx configuration location summary location regular writing and rewrite rule writing

1. Location regular expression

Let's take a look at an example:

location = / {
 # Exact match / , the host name cannot be followed by any string [ configuration A ]
}

location / {
 # Because all addresses start with /, this rule will match all requests # But regular expressions and longest strings will be matched first [ configuration B ]
}

location /documents/ {
 # Match any address starting with /documents/. After matching, continue searching. # This one will be used only if the following regular expressions are not matched [ configuration C ]
}

location ~ /documents/Abc {
 # Match any address starting with /documents/Abc. After the match is met, continue to search below. # This one will be used only if the following regular expression does not match [ configuration CC ]
}

location ^~ /images/ {
 # Match any address starting with /images/. After the match is found, stop searching for regular expressions and use this one.
 [ configuration D ]
}

location ~* \.(gif|jpg|jpeg)$ {
 # Matches 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 [configuration E]
}

location /images/ {
 # The character matches /images/. If you continue to look down, you will find that ^~ exists [ configuration F ]
}

location /images/abc {
 # The longest character matches /images/abc. If you continue to look down, you will find that ^~ exists # The order of placement of F and G is irrelevant [ configuration G ]
}

location ~ /images/abc/ {
 # Only when config D is removed will it be effective: first match the address starting with config G, continue searching, and when this regular expression is matched, use [configuration H]
}

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

location prefix

No prefix matches locations that begin with the specified pattern

= Exact match, not starting with the specified pattern

~ Regular expression matching, case-sensitive

~* Regular expression matching, case insensitive

^~ Non-regular matching, matching locations that start with the specified pattern
/ Universal match, if there is no other match, any request will match

location matching order

Multiple regular locations are matched directly in the order in which they are written. Once a match succeeds, no further matching will be done.

Ordinary (non-regular) locations will continue to move down until the highest match (maximum prefix match) is found.

When both common location and regular location exist, if the regular location matches successfully, the common location will not be matched again.

When all types of location exist, "=" matching > "^~" matching > regular matching > normal (maximum prefix matching)

order:

(location =) > (location full path) > (location ^~ path) > (location ~,~* regular sequence) > (location partial start path) > (/)

The matching results above

According to the location writing above, the following matching examples are established:

/ -> config A

Exact match, even /index.html will not match

/downloads/download.html -> config B

After matching B, there is no match below, so use B

/images/1.gif -> configuration D

Match to F, match to D, stop going down

/images/abc/def -> config D

The longest match is G, and it goes down to match D, and stops. You can see that anything starting with /images/ will match D and stop. It doesn't make any sense to write FG 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.

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/
}

2. Rewrite rules

The rewrite function uses the global variables provided by nginx or the variables set by 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://jb51.net/a/we/index.php?id=1&u=str will only rewrite /a/we/index.php.

Syntaxrewrite 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.

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

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

Execute the rewrite directive of the server block

Perform location matching

Execute the rewrite directive 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.

2.1 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:

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.

2.2 if instruction and global variables

if judgment instruction

The syntax is if(condition){...} , which judges 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 non-matching

-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

For example:

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.com www.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

2.3 Common 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
$: Introduction to matching strings
{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.

2.4 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.

The above is a summary of nginx configuration location regularization and rewrite rule writing. There are more articles about nginx configuration introduction in the following related articles. I hope it can help you.