首先得宣告，這不是我的原創，是在網上搜索到的一篇文章，原著是誰也搞不清楚了，按風格應該是屬於章亦春的文章。

整理花了不少時間，所以就暫寫成原創吧。

一. 概述

二. 準備

首先，介紹一下Nginx的一些特性，便於後文介紹ngx_lua的相關特性。

Nginx程序模型

Nginx採用多程序模型，單Master—多Worker，由Master處理外部訊號、配置檔案的讀取及Worker的初始化，Worker程序採用單執行緒、非阻塞的事件模型（Event Loop，事件迴圈）來實現埠的監聽及客戶端請求的處理和響應，同時Worker還要處理來自Master的訊號。由於Worker使用單執行緒處理各種事件，所以一定要保證主迴圈是非阻塞的，否則會大大降低Worker的響應能力。

Nginx處理Http請求的過程

<span style="font-size:10px;">NGX_HTTP_POST_READ_PHASE,     //0讀取請求phase
NGX_HTTP_SERVER_REWRITE_PHASE,//1這個階段主要是處理全域性的(server block)的rewrite
NGX_HTTP_FIND_CONFIG_PHASE,   //2這個階段主要是通過uri來查詢對應的location，然後根據loc_conf設定r的相應變數
NGX_HTTP_REWRITE_PHASE,       //3這個主要處理location的rewrite
NGX_HTTP_POST_REWRITE_PHASE,  //4postrewrite，這個主要是進行一些校驗以及收尾工作，以便於交給後面的模組。
NGX_HTTP_PREACCESS_PHASE,     //5比如流控這種型別的access就放在這個phase，也就是說它主要是進行一些比較粗粒度的access。
NGX_HTTP_ACCESS_PHASE,        //6這個比如存取控制，許可權驗證就放在這個phase，一般來說處理動作是交給下面的模組做的.這個主要是做一些細粒度的access
NGX_HTTP_POST_ACCESS_PHASE,   //7一般來說當上面的access模組得到access_code之後就會由這個模組根據access_code來進行操作
NGX_HTTP_TRY_FILES_PHASE,     //8try_file模組，就是對應配置檔案中的try_files指令，可接收多個路徑作為引數，當前一個路徑的資源無法找到，則自動查詢下一個路徑   
NGX_HTTP_CONTENT_PHASE,       //9內容處理模組   
NGX_HTTP_LOG_PHASE            //10log模組
 

每個階段上可以註冊handler，處理請求就是執行每個階段上註冊的handler。Nginx模組提供的配置指令只會一般只會註冊並執行在其中的某一個處理階段。

比如，set指令屬於rewrite模組的，執行在rewrite階段，deny和allow執行在access階段。

其實在Nginx 世界裡有兩種型別的“請求”，一種叫做“主請求”（main request），而另一種則叫做“子請求”（subrequest）。 所謂“主請求”，就是由 HTTP 客戶端從 Nginx 外部發起的請求。比如，從瀏覽器訪問Nginx就是一個“主請求”。 而“子請求”則是由 Nginx 正在處理的請求在 Nginx 內部發起的一種級聯請求。“子請求”在外觀上很像 HTTP 請求，但實現上卻和 HTTP 協議乃至網路通訊一點兒關係都沒有。它是 Nginx 內部的一種抽象呼叫，目的是為了方便使用者把“主請求”的任務分解為多個較小粒度的“內部請求”，併發或序列地訪問多個 location 介面，然後由這些 location 介面通力協作，共同完成整個“主請求”。當然，“子請求”的概念是相對的，任何一個“子請求”也可以再發起更多的“子子請求”，甚至可以玩遞迴呼叫（即自己呼叫自己）。

當一個請求發起一個“子請求”的時候，按照 Nginx 的術語，習慣把前者稱為後者的“父請求”（parent request）。

location /main {
    echo_location /foo;     # echo_location傳送子請求到指定的location
    echo_location /bar;
}
location /foo {
    echo foo;
}
location /bar {
    echo bar;
}

輸出：

協程類似一種多執行緒，與多執行緒的區別有： 

1. 協程並非os執行緒，所以建立、切換開銷比執行緒相對要小。 

2. 協程與執行緒一樣有自己的棧、區域性變數等，但是協程的棧是在使用者程序空間模擬的，所以建立、切換開銷很小。

3. 多執行緒程式是多個執行緒併發執行，也就是說在一瞬間有多個控制流在執行。而協程強調的是一種多個協程間協作的關係，只有當一個協程主動放棄執行權，另一個協程才能獲得執行權，所以在某一瞬間，多個協程間只有一個在執行。 

4. 由於多個協程時只有一個在執行，所以對於臨界區的訪問不需要加鎖，而多執行緒的情況則必須加鎖。 

5. 多執行緒程式由於有多個控制流，所以程式的行為不可控，而多個協程的執行是由開發者定義的所以是可控的。 

Nginx的每個Worker程序都是在epoll或kqueue這樣的事件模型之上，封裝成協程，每個請求都有一個協程進行處理。這正好與Lua內建協程的模型是一致的，所以即使ngx_lua需要執行Lua，相對C有一定的開銷，但依然能保證高併發能力。

三. ngx_lua

官網上列出： 

· Mashup’ing and processing outputs of various nginx upstream outputs(proxy, drizzle, postgres, redis, memcached, and etc) in Lua, 
· doing arbitrarily complex access control and security checks in Luabefore requests actually reach the upstream backends, 
· manipulating response headers in an arbitrary way (by Lua) 
· fetching backend information from external storage backends (likeredis, memcached, mysql, postgresql) and use that information to choose whichupstream backend to access on-the-fly, 
· coding up arbitrarily complex web applications in a content handlerusing synchronous but still non-blocking access to the database backends andother storage, 
· doing very complex URL dispatch in Lua at rewrite phase, 
· using Lua to implement advanced caching mechanism for nginxsubrequests and arbitrary locations.

# nginx.conf
worker_processes 4;

events {
     worker_connections 1024;
}
http {

    server {
        listen 80;
        server_name localhost;

        location=/lua {
            content_by_lua ‘
                ngx.say("Hello, Lua!")
            ';
        }
    }
}

ngx_lua安裝

配置：

location =/adder {
    set_by_lua $res"
            local a = tonumber(ngx.arg[1])
                local b = tonumber(ngx.arg[2])
                return a + b"$arg_a$arg_b;

        echo$res;
}

配置：

location =/fib {
        set_by_lua_file $res "conf/adder.lua" $arg_n;

        echo $res;
}</span>

adder.lua:

local a=tonumber(ngx.arg[1])
local b=tonumber(ngx.arg[2])
return a + b

access_by_lua和access_by_lua_file

配置：

location /auth {
    access_by_lua '
        if ngx.var.arg_user == "ntes" then
            return
        else
            Ngx.exit(ngx.HTTP_FORBIDDEN)
        end
    ';
    echo'welcome ntes';
}

rewrite_by_lua和rewrite_by_lua_file

實現url重寫，在rewrite階段執行。

location =/foo {
        rewrite_by_lua 'ngx.exec("/bar")';
    echo'in foo';
}

location =/bar {
        echo'in bar';
}

Contenthandler在content階段執行，生成http響應。由於content階段只能有一個handler，所以在與echo模組使用時，不能同時生效，我測試的結果是content_by_lua會覆蓋echo。這和之前的hello world的例子是類似的。

location =/lua {
        content_by_lua 'ngx.say("Hello, Lua!")';
}

location =/hello {
        content_by_lua '
            local who = ngx.var.arg_who
            ngx.say("Hello, ", who, "!")
        ';
}

location =/other {
    ehco 'Hello, world!';
}

# Lua非阻塞IO
location =/lua {
    content_by_lua '
        local res = ngx.location.capture("/other")
        if res.status == 200 then
            ngx.print(res.body)
        end
    ';
}

# 同時傳送多個子請求（subrequest）
location =/moon {
    ehco 'moon';
}
location =/earth {
    ehco 'earth';
}

location =/lua {
    content_by_lua '
        local res1,res2 = ngx.location.capture_multi({ {"/moon"}, {"earth"} })
        if res1.status == 200 then
            ngx.print(res1.body)
        end
        ngx.print(",")
        if res2.status == 200 then
            ngx.print(res2.body)
        end
    ';
}

配置：

location / {
    internal;
    root html;
}

location /capture {
    content_by_lua '
        res = ngx.location.capture("/")
        echo res.body
    ';
}

location /luaio{
    content_by_lua '
        local io = require("io")
        local chunk_SIZE = 4096
        local f = assert(io.open("html/index.html","r"))
        while true do
            local chunk = f:read(chunk)
            if not chunk then
                break
            end
            ngx.print(chunk)
            ngx.flush(true)
        end
        f:close()
    ';
}

四. 小結

五. 進階

Memcached

#使用HttpMemcModule
location =/memc {
    set $memc_cmd $arg_cmd;
    set $memc_key $arg_key;
    set $memc_value $arg_val;
    set $memc_exptime $arg_exptime;

    memc_pass '127.0.0.1:11211';
}

#在Lua中訪問Memcached
location =/memc {
    internal;   #只能內部訪問
    set $memc_cmd get;
    set $memc_key $arg_key;
    memc_pass '127.0.0.1:11211';
}
location =/lua_memc {
    content_by_lua '
        local res = ngx.location.capture("/memc", {
            args = { key = ngx.var.arg_key }
        })
        if res.status == 200 then
            ngx.say(res.body)
        end
    ';
}

Redis

#在Lua中訪問Redis
location =/redis {
    internal;   #只能內部訪問
    redis2_query get $arg_key;
    redis2_pass '127.0.0.1:6379';
}
location =/lua_redis {#需要LuaRedisParser
    content_by_lua '
        local parser = require("redis.parser")
        local res = ngx.location.capture("/redis", {
            args = { key = ngx.var.arg_key }
        })
        if res.status == 200 then
            reply = parser.parse_reply(res.body)
            ngx.say(reply)
        end
    ';
}

配置：

#在Lua中訪問Redis
location =/redis {
    internal;   #只能內部訪問
    redis2_raw_queries $args$echo_request_body;
    redis2_pass '127.0.0.1:6379';
}

location =/pipeline {
    content_by_lua 'conf/pipeline.lua';
}

pipeline.lua

-- conf/pipeline.lua file
local parser=require(‘redis.parser’)
local reqs={
    {‘get’, ‘one’}, {‘get’, ‘two’}
}
-- 構造原生的redis查詢，get one\r\nget two\r\n
local raw_reqs={}
for i, req in ipairs(reqs)do
      table.insert(raw_reqs, parser.build_query(req))
end
local res=ngx.location.capture(‘/redis?’..#reqs, {body=table.concat(raw_reqs, ‘’)})

if res.status and res.body then
       -- 解析redis的原生響應
       local replies=parser.parse_replies(res.body, #reqs)
       for i, reply in ipairs(replies)do
          ngx.say(reply[1])
       end
end

Connection Pool

http {
    # 需要HttpUpstreamKeepaliveModule
    upstream redis_pool {
        server 127.0.0.1:6379;
        # 可以容納1024個連線的連線池
        keepalive 1024 single;
    }

    server {
        location=/redis {
            …
            redis2_pass redis_pool;
        }
    }
}

小結

這裡對memcached、redis的訪問做個小結。 1. Nginx提供了強大的程式設計模型，location相當於函式，子請求相當於函式呼叫，並且location還可以向自己傳送子請求，這樣構成一個遞迴的模型，所以採用這種模型實現複雜的業務邏輯。 2. Nginx的IO操作必須是非阻塞的，如果Nginx在那阻著，則會大大降低Nginx的效能。所以在Lua中必須通過ngx.location.capture發出子請求將這些IO操作委託給Nginx的事件模型。 3. 在需要使用tcp連線時，儘量使用連線池。這樣可以消除大量的建立、釋放連線的開銷。

參考：

原文: