Rewrite flags (last, break, redirect, permanent) in Nginx - Step-by-Step Execution

Process Flow - Rewrite flags (last, break, redirect, permanent)

Request comes in

↓

Rewrite rule matches?

No→Serve original URI

Yes↓

Apply rewrite with flag

↓

last

↓

break

↓

redirect

↓

permanent

When a rewrite rule matches, nginx applies the flag to decide how to handle the request next: restart, stop, or redirect.

Execution Sample

Nginx

rewrite ^/oldpath/(.*)$ /newpath/$1 last;
rewrite ^/temp/(.*)$ /tempfile break;
rewrite ^/go/(.*)$ http://example.com/$1 redirect;
rewrite ^/perm/(.*)$ http://example.com/$1 permanent;

Four rewrite rules showing different flags: last restarts location search, break stops rewriting, redirect sends 302, permanent sends 301.

Process Table

Step	Request URI	Rewrite Rule Matched	Flag	Action Taken	Resulting URI or Response
1	/oldpath/page	^/oldpath/(.*)$	last	Restart location search with /newpath/page	/newpath/page
2	/newpath/page	No match	-	Serve /newpath/page	/newpath/page
3	/temp/file	^/temp/(.*)$	break	Stop rewriting, continue with /tempfile	/tempfile
4	/tempfile	No rewrite	-	Serve /tempfile	/tempfile
5	/go/home	^/go/(.*)$	redirect	Send 302 redirect to http://example.com/home	302 Redirect to http://example.com/home
6	/perm/about	^/perm/(.*)$	permanent	Send 301 redirect to http://example.com/about	301 Redirect to http://example.com/about
7	/other	No match	-	Serve /other	/other

💡 Execution stops when no rewrite rule matches or after redirect response is sent.

Status Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	After Step 6	Final
Request URI	/oldpath/page	/newpath/page	/temp/file	/go/home	/perm/about	/other
Rewrite Rule Matched	None	^/oldpath/(.*)$	^/temp/(.*)$	^/go/(.*)$	^/perm/(.*)$	None
Action Taken	None	Restart location search	Stop rewriting	302 redirect	301 redirect	Serve original

Key Moments - 3 Insights

Why does the 'last' flag cause nginx to restart location search?

Because 'last' tells nginx to treat the rewritten URI as a new request and search for matching location blocks again, as shown in step 1 and 2 of the execution_table.

What happens when the 'break' flag is used in a rewrite?

'break' stops further rewrite processing and continues with the current location using the rewritten URI, as seen in step 3 and 4.

How do 'redirect' and 'permanent' flags differ in their HTTP response?

'redirect' sends a temporary 302 redirect, while 'permanent' sends a 301 permanent redirect, demonstrated in steps 5 and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the Request URI after step 1?

A /oldpath/page

B /temp/file

C /newpath/page

D /go/home

💡 Hint

Check the 'Request URI' column in row for step 1.

At which step does nginx send a 301 redirect response?

A Step 6

B Step 5

C Step 3

D Step 2

💡 Hint

Look at the 'Action Taken' and 'Resulting URI or Response' columns for redirect types.

If the 'break' flag was replaced with 'last' in step 3, what would happen?

A Nginx would serve /temp/file without rewriting

B Nginx would restart location search with /tempfile

C Nginx would send a redirect to /tempfile

D Nginx would stop processing and serve original URI

💡 Hint

Compare the behavior of 'break' vs 'last' flags in the concept_flow and execution_table.

Concept Snapshot

nginx rewrite flags control request handling:
- last: rewrite and restart location search
- break: rewrite and stop rewriting, continue current location
- redirect: send 302 temporary redirect
- permanent: send 301 permanent redirect
Use flags to control URL rewriting and client response.

Full Transcript

When nginx receives a request, it checks rewrite rules. If a rule matches, it applies the rewrite and uses the flag to decide what to do next. The 'last' flag restarts location search with the new URI, allowing further processing. The 'break' flag stops rewriting and continues with the current location using the rewritten URI. The 'redirect' flag sends a temporary 302 redirect to the client, while 'permanent' sends a 301 permanent redirect. If no rewrite matches, nginx serves the original URI. This flow helps control how URLs are rewritten and how clients are redirected.

Practice

1. What does the last flag do in an nginx rewrite directive?

easy

A. Stops processing the current location and restarts the rewrite phase with the new URI

B. Sends a temporary redirect (HTTP 302) to the client

C. Stops processing the rewrite directives and continues with the current location

D. Sends a permanent redirect (HTTP 301) to the client

Solution

1. Step 1: Understand the last flag behavior

   The last flag tells nginx to stop processing current rewrite directives and restart the rewrite phase with the new URI.

2. Step 2: Compare with other flags

   Unlike break which stops rewriting internally, last restarts processing, and unlike redirect or permanent which send redirects, it does not send a client redirect.

3. Final Answer:

   Stops processing the current location and restarts the rewrite phase with the new URI -> Option A

4. Quick Check:

   last = restart rewrite phase [OK]

Hint: Remember: last restarts rewrite, break stops internally [OK]

Common Mistakes:

• Confusing last with break flag
• Thinking last sends a redirect
• Mixing last with permanent redirect

2. Which of the following is the correct syntax to perform a permanent redirect in nginx using the rewrite directive?

easy

A. rewrite ^/old$ /new break;

B. rewrite ^/old$ /new last;

C. rewrite ^/old$ /new permanent;

D. rewrite ^/old$ /new redirect;

Solution

1. Step 1: Identify the flag for permanent redirect

   The permanent flag sends an HTTP 301 status code indicating a permanent redirect.

2. Step 2: Check syntax correctness

   The syntax rewrite ^/old$ /new permanent; correctly applies the permanent redirect flag.

3. Final Answer:

   rewrite ^/old$ /new permanent; -> Option C

4. Quick Check:

   Permanent redirect uses permanent flag [OK]

Hint: Permanent redirect uses 'permanent' flag at end [OK]

Common Mistakes:

• Using 'last' or 'break' instead of 'permanent' for redirects
• Omitting the semicolon at the end
• Confusing 'redirect' with 'permanent'

3. Given the nginx configuration snippet:

location /test {
  rewrite ^/test/(.*)$ /new/$1 redirect;
}

What will happen when a client requests /test/page?

medium

A. The client will receive a 301 permanent redirect to /new/page

B. The rewrite will restart processing with the new URI /new/page

C. The request will be internally rewritten to /new/page without redirect

D. The client will receive a 302 temporary redirect to /new/page

Solution

1. Step 1: Understand the redirect flag

   The redirect flag sends an HTTP 302 temporary redirect to the client.

2. Step 2: Analyze the rewrite rule

   The rewrite matches /test/page and rewrites it to /new/page with a temporary redirect.

3. Final Answer:

   The client will receive a 302 temporary redirect to /new/page -> Option D

4. Quick Check:

   redirect = 302 temporary redirect [OK]

Hint: redirect flag means 302 temporary redirect [OK]

Common Mistakes:

• Confusing redirect with permanent
• Thinking redirect rewrites internally
• Assuming last or break flags here

4. You have this nginx rewrite rule:

rewrite ^/oldpath/(.*)$ /newpath/$1 last

But it causes a 500 Internal Server Error. What is the likely problem?

medium

A. Missing semicolon at the end of the rewrite directive

B. Using 'last' flag instead of 'break' causes infinite loop

C. The regex pattern is invalid

D. Rewrite directive must be inside a location block

Solution

1. Step 1: Check syntax of rewrite directive

   Every nginx directive must end with a semicolon. The given rewrite lacks a semicolon.

2. Step 2: Understand error cause

   Missing semicolon causes nginx to fail parsing config, leading to 500 error.

3. Final Answer:

   Missing semicolon at the end of the rewrite directive -> Option A

4. Quick Check:

   Missing semicolon = syntax error = 500 error [OK]

Hint: Always end rewrite directives with semicolon [OK]

Common Mistakes:

• Assuming last flag causes infinite loop
• Ignoring missing semicolon syntax errors
• Thinking regex pattern is wrong without checking

5. You want to rewrite URLs starting with /app to /app/index.html internally without redirecting the client, and stop further rewrite processing. Which rewrite directive and flag should you use?

hard

A. rewrite ^/app$ /app/index.html last;

B. rewrite ^/app$ /app/index.html break;

C. rewrite ^/app$ /app/index.html redirect;

D. rewrite ^/app$ /app/index.html permanent;

Solution

1. Step 1: Identify internal rewrite without client redirect

   The break flag stops rewrite processing and serves the rewritten URI internally without redirecting the client.

2. Step 2: Match requirement to flag

   Using break with the rewrite stops further rewrites and serves /app/index.html internally.

3. Final Answer:

   rewrite ^/app$ /app/index.html break; -> Option B

4. Quick Check:

   break = internal rewrite stop [OK]

Hint: Use break to rewrite internally and stop further rewrites [OK]

Common Mistakes:

• Using last which restarts rewrite phase
• Using redirect or permanent which send client redirects
• Not stopping rewrite processing causing unexpected behavior