आप PCRE स्रोत को [PCRE वेबसाइट](http://www.pcre.org/) से डाउनलोड कर सकते हैं। JIT-सक्षम PCRE लाइब्रेरी के साथ OpenResty बनाने की चरण-दर-चरण मार्गदर्शिका के लिए यह [ब्लॉग पोस्ट](https://www.cryptobells.com/building-openresty-with-pcre-jit/) भी देखें।

## प्रदर्शन

lua-resty-waf को दक्षता और स्केलेबिलिटी को ध्यान में रखकर डिज़ाइन किया गया था। यह Nginx के अतुल्यकालिक प्रोसेसिंग मॉडल और एक कुशल डिज़ाइन का लाभ उठाता है ताकि प्रत्येक लेन-देन को यथासंभव शीघ्रता से संसाधित किया जा सके। लोड परीक्षण से पता चला है कि सभी प्रदान किए गए नियमसेट को लागू करने वाले डिप्लॉयमेंट, जो ModSecurity CRS के पीछे के तर्क की नकल करने के लिए डिज़ाइन किए गए हैं, प्रति अनुरोध लगभग 300-500 माइक्रोसेकंड में लेन-देन संसाधित करते हैं; यह [Cloudflare के WAF](https://www.cloudflare.com/waf) द्वारा विज्ञापित प्रदर्शन के बराबर है। परीक्षण एक उचित हार्डवेयर स्टैक (E3-1230 CPU, 32 GB RAM, RAID 0 में 2 x 840 EVO) पर चलाए गए थे, जो लगभग 15,000 अनुरोध प्रति सेकंड तक पहुँचते हैं। अधिक जानकारी के लिए [यह ब्लॉग पोस्ट](http://www.cryptobells.com/freewaf-a-high-performance-scalable-open-web-firewall) देखें।

lua-resty-waf का कार्यभार लगभग पूर्णतः CPU-बाउंड है। Lua VM में मेमोरी फुटप्रिंट (`lua-shared-dict` द्वारा समर्थित स्थायी भंडारण को छोड़कर) लगभग 2MB है।

## स्थापना

एक सरल Makefile प्रदान किया गया है:```
# make && sudo make install

lua-resty-waf [OPM](https://github.com/openresty/opm) पैकेज मैनेजर का उपयोग करता है, जो आधुनिक OpenResty वितरणों में उपलब्ध है। क्लाइंट OPM टूल्स के लिए यह आवश्यक है कि आपके सिस्टम के `PATH` पर्यावरण चर में `resty` कमांड लाइन टूल उपलब्ध हो।

ध्यान दें कि डिफ़ॉल्ट रूप से lua-resty-waf SIMULATE मोड में चलता है, ताकि किसी एप्लिकेशन को तुरंत प्रभावित होने से रोका जा सके; जो उपयोगकर्ता नियम क्रियाओं को सक्षम करना चाहते हैं, उन्हें ऑपरेशनल मोड को स्पष्ट रूप से ACTIVE पर सेट करना होगा।

## Synopsis```lua
http {
    init_by_lua_block {
        -- use resty.core for performance improvement, see the status note above
        require "resty.core"

        -- require the base module
        local lua_resty_waf = require "resty.waf"

        -- perform some preloading and optimization
        lua_resty_waf.init()
    }

    server {
        location / {
            access_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                -- define options that will be inherited across all scopes
                waf:set_option("debug", true)
                waf:set_option("mode", "ACTIVE")

                -- this may be desirable for low-traffic or testing sites
                -- by default, event logs are not written until the buffer is full
                -- for testing, flush the log buffer every 5 seconds
                --
                -- this is only necessary when configuring a remote TCP/UDP
                -- socket server for event logs. otherwise, this is ignored
                waf:set_option("event_log_periodic_flush", 5)

                -- run the firewall
                waf:exec()
            }

            header_filter_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                -- note that options set in previous handlers (in the same scope)
                -- do not need to be set again
                local waf = lua_resty_waf:new()

                waf:exec()
            }

            body_filter_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                waf:exec()
            }

            log_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                waf:exec()
            }
        }
    }
}

    -- this translates and calculates a ruleset called 'ruleset_name'
    local ok, errs = pcall(function()
        lua_resty_waf.load_secrules("/path/to/secrules/ruleset_name")
    end)

    -- errs is an array-like table
    if errs then
        for i = 1, #errs do
            ngx.log(ngx.ERR, errs[i])
        end
    end
}

server {
    location / {
        access_by_lua_block {
            local lua_resty_waf = require "resty.waf"

            local waf = lua_resty_waf:new()

            -- in order to use the loaded ruleset, it must be added via
            -- the 'add_ruleset' option
            waf:set_option("add_ruleset", "ruleset_name")
        }
    }
}

Additionally, `load_secrules` विभिन्न अनुवाद फ़ंक्शनों को पारित करने के लिए विकल्पों की एक तालिका के रूप में एक वैकल्पिक दूसरा तर्क ले सकता है। निम्नलिखित विकल्प पहचाने जाते हैं:

* *path*: ऐसे ऑपरेटरों के लिए डेटा फ़ाइलें खोजने हेतु फ़ाइलसिस्टम पथ परिभाषित करें जैसे @pmFromFile। यदि ऐसी कोई कुंजी परिभाषित नहीं है, तो वर्तमान कार्यशील निर्देशिका (`.`) उपयोग की जाती है
* *force*: नियम चर का अनुवाद करने में विफल होने पर त्रुटि न दें और कार्य रोकें नहीं
* *loose*: नियम क्रिया का अनुवाद करने में विफल होने पर त्रुटि न दें और कार्य रोकें नहीं
* *quiet*: नियम क्रिया का अनुवाद करने में विफल होने पर न तो त्रुटि दें और न ही चेतावनी दें

यह फ़ंक्शन बाद में प्रोसेसिंग के लिए अनुवाद त्रुटियों को पकड़ने हेतु एक तालिका के रूप में तीसरा विकल्प भी ले सकता है। यदि यह विकल्प मौजूद नहीं है या एक तालिका नहीं है, तो अनुवाद त्रुटियाँ इसके बजाय त्रुटि लॉग में लॉग की जाएँगी।

### lua-resty-waf.init()

डिफ़ॉल्ट वितरित नियमसेटों के माध्यम से उपलब्ध कराई गई चीज़ों के आधार पर नियमों और नियमसेटों की कुछ पूर्व-गणना करें। इस फ़ंक्शन को कॉल करना अनुशंसित है, लेकिन आवश्यक नहीं (ऐसा न करने पर छोटा प्रदर्शन जुर्माना लगेगा)। इस फ़ंक्शन को इस दायरे से बाहर कभी नहीं बुलाया जाना चाहिए।

*उदाहरण*:```lua
http {
    init_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        lua_resty_waf.init()
    }
}

    local waf = lua_resty_waf:new()
}

### lua-resty-waf:set_option()

प्रति-स्कोप आधार पर एक विकल्प कॉन्फ़िगर करें।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        -- enable debug logging only for this scope
        waf:set_option("debug", true)
    }
}

    local waf = lua_resty_waf:new()

    waf:set_var("FOO", "bar")
}

ध्यान दें कि किसी भी अन्य ModSecurity नियम की तरह, एक वेरिएबल के अस्तित्व का WAF प्रोसेसिंग पर कोई कार्यात्मक प्रभाव नहीं होता; नियम लेखक की जिम्मेदारी है कि वह `TX` वेरिएबल्स को समझे और उपयोग करे।

### lua-resty-waf:sieve_rule()

किसी दिए गए नियम के लिए एक संग्रह अपवाद (collection exclusion) परिभाषित करें।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        local sieves = {
            {
                type   = "ARGS",
                elts   = "foo",
                action = "ignore",
            }
        }

        waf:sieve_rule("12345", sieves)
    }
}

    local waf = lua_resty_waf:new()

    -- execute according to access phase collections and rules
    waf:exec()
}

content_by_lua_block {
    local lua_resty_waf = require "waf"

    local waf = lua_resty_waf:new()

    -- execute header_filter rules, passing in a table of additional collections
    -- this assumes the 'request_headers' and 'status' Lua variables were
    -- declared and initialized elsewhere
    local opts = {
        phase = 'header_filter',
        collections = {
            REQUEST_HEADERS = request_headers,
            STATUS = status,
        }
    }

    waf:exec(opts)
}

### lua-resty-waf:write_log_events()

ट्रांज़ैक्शन से उत्पन्न किसी भी ऑडिट लॉग प्रविष्टियों को लिखें। यह केवल तब वैकल्पिक है जब `exec` को `log_by_lua` हैंडलर में कॉल किया जाता है।

*उदाहरण*:```lua
location / {
    log_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        -- write out any event log entries to the
        -- configured target, if applicable
        waf:write_log_events()
    }
}

server {
    location / {
        access_by_lua_block {
            waf:set_option("add_ruleset", "50000_extra_rules")
        }
    }
}

एकाधिक रूलसेट `set_option` में मानों की एक तालिका पास करके जोड़े जा सकते हैं। ध्यान दें कि रूलसेट नामों को प्रोसेसिंग से पहले क्रमबद्ध किया जाता है। रूलसेट को निम्न-से-उच्च क्रमबद्ध क्रम में प्रोसेस किया जाता है।

### add_ruleset_string

*डिफ़ॉल्ट*: none

प्रोसेसिंग के दौरान उपयोग करने के लिए एक अतिरिक्त रूलसेट जोड़ता है। यह उपयोगकर्ताओं को शामिल rules निर्देशिका के ऊपर पैर जमाए बिना कस्टम रूलसेट लागू करने की अनुमति देता है। रूलसेट को इनलाइन रूप से एक Lua स्ट्रिंग के रूप में परिभाषित किया गया है, जो अनुवादित रूलसेट JSON संरचना के रूप में होती है।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("add_ruleset_string", "70000_extra_rules", [=[{"access":[{"action":"DENY","id":73,"operator":"REGEX","opts":{},"pattern":"foo","vars":[{"parse":{"values":1},"type":"REQUEST_ARGS"}]}],"body_filter":[],"header_filter":[]}]=])
    }
}

### allowed_content_types

*डिफ़ॉल्ट*: कोई नहीं

एक या अधिक Content-Type हेडर परिभाषित करता है जिन्हें अनुमति दी जाएगी, डिफ़ॉल्ट Content-Types `application/x-www-form-urlencoded` और `multipart/form-data` के अतिरिक्त। एक अनुरोध जिसका content type `allowed_content_types` में से किसी एक से मेल खाता है, वह `REQUEST_BODY` संग्रह को एक स्ट्रिंग (तालिका के बजाय) वाले एकल स्ट्रिंग पर सेट करेगा; एक अनुरोध जिसका content type इन मानों में से किसी से मेल नहीं खाता, या `application/x-www-form-urlencoded` या `multipart/form-data`, अस्वीकार कर दिया जाएगा।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- define a single allowed Content-Type value
        waf:set_option("allowed_content_types", "text/xml")

        -- defines multiple allowed Content-Type values
        waf:set_option("allowed_content_types", { "text/html", "text/json", "application/json" })
    }
}

### debug_log_level

*Default*: ngx.INFO

डिबग लॉगिंग के लिए उपयोग किए जाने वाले nginx लॉग स्तर स्थिरांक को सेट करता है।

*Example*:```lua
location / {
    access_by_lua_block {
        waf:set_option("debug_log_level", ngx.DEBUG)
    }
}

### disable_pcre_optimization

*डिफ़ॉल्ट*: false

सभी `ngx.re.match`, `ngx.re.find`, और `ngx.re.sub` कॉल्स से `oj` फ़्लैग हटा देता है। यह कुछ मामलों में उपयोगी हो सकता है जहाँ पुरानी PCRE लाइब्रेरीज़ का उपयोग किया जाता है, लेकिन इससे गंभीर प्रदर्शन गिरावट होगी, इसलिए इसका उपयोग दृढ़ता से हतोत्साहित किया जाता है; इसके बजाय उपयोगकर्ताओं को आधुनिक, JIT-क्षमता वाली PCRE लाइब्रेरी के साथ OpenResty बनाने के लिए प्रोत्साहित किया जाता है।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("disable_pcre_optimization", true)
    }
}

ध्यान दें कि `mode` का प्रभाव यह निर्धारित करने पर नहीं पड़ेगा कि कोई लेन-देन परिवर्तित माना जाता है या नहीं। अर्थात्, यदि `DENY` क्रिया वाला कोई नियम मेल खाता है, लेकिन lua-resty-waf `SIMULATE` मोड में चल रहा है, तो लेन-देन फिर भी परिवर्तित माना जाएगा, और नियम मेलों को लॉग किया जाएगा।

### event_log_buffer_size

*डिफ़ॉल्ट*: 4096

बफ़र का आकार सीमा (बाइट्स में) निर्धारित करता है, जिसका उपयोग इवेंट लॉग को संग्रहीत करने के लिए किया जाएगा। यह सीमा पूरी होने पर बफ़र फ्लश किया जाएगा।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- 8 KB event log message buffer
        waf:set_option("event_log_buffer_size", 8192)
    }
}

### event_log_ngx_vars

*डिफ़ॉल्ट*: खाली

यह निर्धारित करता है कि `ngx.var` से कौन से अतिरिक्त चर लॉग इवेंट में डाले जाते हैं। यह अलर्ट को अतिरिक्त संदर्भ के साथ विस्तारित करने का एक सामान्य तरीका है। चर का नाम लॉग प्रविष्टि में `ngx` कुंजी के अंतर्गत प्रविष्टि की कुंजी होगा। यदि चर nginx चर के रूप में मौजूद नहीं है, तो इवेंट में कोई आइटम नहीं जोड़ा जाता है।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_ngx_vars", "host")
        waf:set_option("event_log_ngx_vars", "request_id")
    }
}

### event_log_periodic_flush

*डिफ़ॉल्ट*: कोई नहीं

वह अंतराल (सेकंड में) परिभाषित करता है जिस पर इवेंट लॉग बफर समय-समय पर फ्लश होगा। यदि कोई मान कॉन्फ़िगर नहीं किया गया है, तो बफर समय-समय पर फ्लश नहीं होगा, और केवल तब फ्लश होगा जब `event_log_buffer_size` सीमा तक पहुँच जाए। इस विकल्प को बहुत कम ट्रैफ़िक वाली साइटों के लिए कॉन्फ़िगर करें, जिन्हें लंबी अवधि में कोई इवेंट लॉग डेटा प्राप्त नहीं हो सकता है, ताकि पुराना डेटा बफर में न बैठा रहे।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- flush the event log buffer every 30 seconds
        waf:set_option("event_log_periodic_flush", 30)
    }
}

### event_log_request_body

*डिफ़ॉल्ट*: false

जब true पर सेट किया जाता है, तो लॉग प्रविष्टियों में अनुरोध निकाय `request_body` कुंजी के अंतर्गत शामिल होता है।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_request_body", true)
    }
}

परिणामी इवेंट में ये अतिरिक्त आइटम शामिल हैं:```json
{
"request_headers": {
    "accept": "*/*",
    "user-agent": "curl/7.22.0 (x86_64-pc-linux-gnu) libcurl/7.22.0 OpenSSL/1.0.1 zlib/1.2.3.4 libidn/1.23 librtmp/2.3"
}
}

### event_log_ssl_sni_host

*डिफ़ॉल्ट*: none

`lua-resty-logger-socket` कनेक्शनों के लिए SNI होस्ट सेट करें।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_ssl_sni_host", "loghost.example.com")
    }
}

### event_log_socket_proto

*डिफ़ॉल्ट*: udp

यह निर्धारित करता है कि रिमोट सॉकेट के माध्यम से इवेंट लॉग भेजते समय कौन सा IP प्रोटोकॉल (TCP या UDP) उपयोग करना है। प्रोटोकॉल चाहे जो भी हो, समान बफरिंग और आवर्ती फ्लश लॉजिक का उपयोग किया जाएगा।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- send logs via TCP
        waf:set_option("event_log_socket_proto", "tcp")
    }
}

    -- send event logs to a local file on disk
    waf:set_option("event_log_target", "file")

    -- send event logs to a remote server
    waf:set_option("event_log_target", "socket")
}

ध्यान दें कि उपयोग की जाने वाली लॉगिंग लाइब्रेरी में एक सीमा के कारण, केवल एक ही लक्ष्य सॉकेट परिभाषित किया जा सकता है। यानी, आप केवल एक विशिष्ट होस्ट/पोर्ट संयोजन के साथ एक `socket` लक्ष्य कॉन्फ़िगर कर सकते हैं; यदि आप दूसरा होस्ट/पोर्ट संयोजन कॉन्फ़िगर करते हैं, तो डेटा ठीक से लॉग नहीं होगा।

### event_log_target_host

*डिफ़ॉल्ट*: कोई नहीं

उन इवेंट लॉग्स के लिए लक्ष्य सर्वर को परिभाषित करता है जो किसी दूरस्थ सर्वर को लक्षित करते हैं।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_target_host", "10.10.10.10")
    }
}

यह पथ nginx उपयोगकर्ता द्वारा लिखने योग्य स्थान पर होना चाहिए। ध्यान दें कि, स्वाभाविक रूप से, ऑन-डिस्क लॉगिंग उच्च-समवर्ती वातावरण में महत्वपूर्ण प्रदर्शन गिरावट का कारण बन सकती है।

### event_log_target_port

*डिफ़ॉल्ट*: none

उन इवेंट लॉग्स के लिए टार्गेट पोर्ट परिभाषित करता है जो किसी रिमोट सर्वर को लक्षित करते हैं।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_target_port", 9001)
    }
}

location / {
    access_by_lua_block {
        local deny_override = function(waf, ctx)
            ngx.log(ngx.INFO, "Overriding DENY action")
            ngx.status = 404
        end

        -- override the DENY action with the function defined above
        waf:set_option("hook_action", "DENY", deny_override)
    }
}

### ignore_rule

*डिफ़ॉल्ट*: कोई नहीं

मॉड्यूल को किसी निर्दिष्ट नियम ID को अनदेखा करने का निर्देश देता है। ध्यान दें कि किसी श्रृंखला (chain) में किसी नियम को अनदेखा करने पर पूरी श्रृंखला अनदेखा कर दी जाती है, और प्रसंस्करण श्रृंखला के बाद आने वाले अगले नियम पर जारी रहेगा।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("ignore_rule", 40294)
        waf:set_option("ignore_rule", {40002, 41036})
    }
}

### mode

*डिफ़ॉल्ट*: SIMULATE

मॉड्यूल के परिचालन मोड को सेट करता है। विकल्प ACTIVE, INACTIVE और SIMULATE हैं। ACTIVE मोड में, नियम मिलान लॉग किए जाते हैं और क्रियाएँ निष्पादित होती हैं। SIMULATE मोड में, lua-resty-waf प्रत्येक सक्षम नियम के माध्यम से लूप करता है और नियम मिलान लॉग करता है, लेकिन किसी दिए गए रन में निर्दिष्ट क्रिया को पूरा नहीं करता है। INACTIVE मोड मॉड्यूल को चलने से रोकता है।

डिफ़ॉल्ट रूप से, यदि कोई मोड स्पष्ट रूप से सेट नहीं किया गया है तो SIMULATE चुना जाता है; इसके लिए नए उपयोगकर्ताओं को मोड को ACTIVE पर सेट करके सक्रिय रूप से ब्लॉकिंग लागू करनी होती है।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        waf:set_option("mode", "ACTIVE")
    }
}

### process_multipart_body

*डिफ़ॉल्ट* true

`lua-resty-upload` मॉड्यूल का उपयोग करते हुए, मल्टीपार्ट/फॉर्म-डेटा अनुरोध निकायों (जब उपस्थित हों) के प्रसंस्करण को सक्षम करें। भविष्य में, lua-resty-waf अपलोड निकायों की अधिक कठोर जाँच करने के लिए इस प्रसंस्करण का उपयोग कर सकता है; फिलहाल यह मॉड्यूल अनुरोध निकाय पर केवल न्यूनतम सत्यापन करता है, और यदि अनुरोध निकाय अमान्य है तो कोई घटना (event) लॉग नहीं करेगा। यदि आपको इस जाँच की आवश्यकता नहीं है, या यदि अपस्ट्रीम मॉड्यूल में बग HTTP अपलोड के साथ समस्याएँ पैदा कर रहे हैं, तो इस विकल्प को अक्षम करें।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- disable processing of multipart/form-data requests
        -- note that the request body will still be sent to the upstream
        waf:set_option("process_multipart_body", false)
    }
}

### res_body_max_size

*Default*: 1048576 (1 MB)

उस सामग्री लंबाई सीमा को परिभाषित करता है जिसके आगे प्रतिक्रिया निकाय (response bodies) संसाधित नहीं किए जाएंगे। प्रतिक्रिया निकाय का यह आकार Content-Length प्रतिक्रिया हेडर द्वारा निर्धारित किया जाता है। यदि प्रतिक्रिया में यह हेडर मौजूद नहीं है, तो प्रतिक्रिया निकाय कभी संसाधित नहीं किया जाएगा।

*उदाहरण*:```lua
location / {
    access_by_lua_block {
        -- increase the max response size to 2 MB
        waf:set_option("res_body_max_size", 1024 * 1024 * 2)
    }
}

Multiple MIME types can be added by passing a table of types to `set_option`.

### res_tid_header

*Default*: false

Set an HTTP header `X-Lua-Resty-WAF-ID` in the downstream response, with the value as the transaction ID. This ID will correlate with the transaction ID present in the debug logs (if set). This can be useful for request tracking or debug purposes.

*Example*:```lua
location / {
    access_by_lua_block {
        waf:set_option("res_tid_header", true)
    }
}

### storage_backend

*डिफ़ॉल्ट*: dict

पर्सिस्टेंट वेरिएबल स्टोरेज के लिए उपयोग होने वाले इंजन को परिभाषित करें। वर्तमान में उपलब्ध विकल्प हैं *dict* (ngx_lua साझा मेमोरी ज़ोन), *memcached*, और *redis*।

*उदाहरण*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_backend", "memcached")
    }
}

### storage_keepalive_timeout

*डिफ़ॉल्ट*: 10000

रिमोट स्थायी भंडारण होस्ट्स के लिए cosocket keepalive पूल का टाइमआउट (मिलीसेकंड में) कॉन्फ़िगर करें।

*उदाहरण*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_keepalive_timeout", 30000)
    }
}

### storage_memcached_host

*डिफ़ॉल्ट*: 127.0.0.1

मेमकैश्ड को स्थायी चर भंडारण इंजन के रूप में उपयोग करते समय उपयोग करने के लिए एक होस्ट परिभाषित करें।

*उदाहरण*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_memcached_host", "10.10.10.10")
    }
}

### storage_redis_host

*डिफ़ॉल्ट*: 127.0.0.1

जब redis को पर्सिस्टेंट वेरिएबल स्टोरेज इंजन के रूप में उपयोग किया जाए, तो उपयोग के लिए एक होस्ट परिभाषित करें।

*उदाहरण*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_redis_host", "10.10.10.10")
    }
}

### storage_zone

*डिफ़ॉल्ट*: कोई नहीं

उस `lua_shared_dict` को परिभाषित करता है जिसका उपयोग स्थायी संग्रहण डेटा रखने के लिए किया जाएगा। इस ज़ोन को कॉन्फ़िगरेशन के `http{}` ब्लॉक में परिभाषित किया जाना चाहिए।

*उदाहरण*:_```lua
http {
    -- define a 64M shared memory zone to hold persistent storage data
    lua_shared_dict persistent_storage 64m;
}

location / {
    access_by_lua_block {
        waf:set_option("storage_zone", "persistent_storage")
    }
}