파트 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()
    -- 라우팅, 서비스, 플러그인 초기화 - 가장 중요한 세 부분
    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