第3部：OpenRestyを使用してマイクロサービスAPIゲートウェイを構築する方法

server {
    listen 9080;

    init_worker_by_lua_block {
        apisix.http_init_worker()
    }

    location / {
        access_by_lua_block {
            apisix.http_access_phase()
        }
        header_filter_by_lua_block {
            apisix.http_header_filter_phase()
        }
        body_filter_by_lua_block {
            apisix.http_body_filter_phase()
        }
        log_by_lua_block {
            apisix.http_log_phase()
        }
    }
}

function _M.http_init_worker()
    -- ルーティング、サービス、プラグインの初期化 - 最も重要な3つの部分
    router.init_worker()
    require("apisix.http.service").init_worker()
    require("apisix.plugins.ext-plugin.init").init_worker()
end

router.router_http.match(api_ctx)

local router = require("resty.radixtree")

local match_opts = {}

function _M.match(api_ctx)
    -- リクエストのパラメータをctxから取得し、ルートの判断条件として使用
    match_opts.method = api_ctx.var.method
    match_opts.host = api_ctx.var.host
    match_opts.remote_addr = api_ctx.var.remote_addr
    match_opts.vars = api_ctx.var
    -- ルートの判断関数を呼び出す
    local ok = uri_router:dispatch(api_ctx.var.uri, match_opts, api_ctx)
    -- ルートがマッチしない場合、404を返す
    if not ok then
        core.log.info("not find any matched route")
        return core.response.exit(404)
    end

    return true
end

local plugins = core.tablepool.fetch("plugins", 32, 0)
-- etcdのプラグインリストとローカル設定ファイルのプラグインリストを交差させる
api_ctx.plugins = plugin.filter(route, plugins)

-- rewriteとaccessフェーズにマウントされたプラグインの関数を順番に実行
run_plugin("rewrite", plugins, api_ctx)
run_plugin("access", plugins, api_ctx)

local function run_plugin(phase, plugins, api_ctx)
    for i = 1, #plugins, 2 do
        local phase_fun = plugins[i][phase]
        if phase_fun then
            -- コアとなる呼び出しコード
            phase_fun(plugins[i + 1], api_ctx)
        end
    end

    return api_ctx
end

phase_fun(plugins[i + 1], api_ctx)

limit_count_plugin_rewrite_function(conf_of_plugin, api_ctx)

local limit_count_new = require("resty.limit.count").new

local schema = {
    type = "object",
    properties = {
        count = {type = "integer", minimum = 0},
        time_window = {type = "integer", minimum = 0},
        key = {type = "string",
        enum = {"remote_addr", "server_addr"},
        },
        rejected_code = {type = "integer", minimum = 200, maximum = 600},
    },
    additionalProperties = false,
    required = {"count", "time_window", "key", "rejected_code"},
}

function _M.rewrite(conf, ctx)
    -- キャッシュからlimit countオブジェクトを取得し、存在しない場合は`create_limit_obj`関数を使用して新しいオブジェクトを作成し、キャッシュする
    local lim, err = core.lrucache.plugin_ctx(plugin_name, ctx,  create_limit_obj, conf)

    -- `ctx.var`からキーの値を取得し、設定タイプと設定バージョン番号と組み合わせて新しいキーを作成
    local key = (ctx.var[conf.key] or "") .. ctx.conf_type .. ctx.conf_version

    -- 制限が適用されるかどうかを判断する関数
    local delay, remaining = lim:incoming(key, true)
    if not delay then
        local err = remaining
        -- 閾値を超えた場合、指定されたステータスコードを返す
        if err == "rejected" then
            return conf.rejected_code
        end

        core.log.error("failed to limit req: ", err)
        return 500
    end

    -- 閾値を超えていない場合、リクエストを許可し、対応するレスポンスヘッダーを設定
    core.response.set_header("X-RateLimit-Limit", conf.count,
                             "X-RateLimit-Remaining", remaining)
end